|
428
|
1 @c -*-texinfo-*-
|
|
|
2 @c This is part of the XEmacs Lisp Reference Manual.
|
|
444
|
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
428
|
4 @c See the file lispref.texi for copying conditions.
|
|
|
5 @setfilename ../../info/windows.info
|
|
|
6 @node Windows, Frames, Buffers, Top
|
|
|
7 @chapter Windows
|
|
|
8
|
|
|
9 This chapter describes most of the functions and variables related to
|
|
|
10 Emacs windows. See @ref{Display}, for information on how text is
|
|
|
11 displayed in windows.
|
|
|
12
|
|
|
13 @menu
|
|
|
14 * Basic Windows:: Basic information on using windows.
|
|
|
15 * Splitting Windows:: Splitting one window into two windows.
|
|
|
16 * Deleting Windows:: Deleting a window gives its space to other windows.
|
|
|
17 * Selecting Windows:: The selected window is the one that you edit in.
|
|
|
18 * Cyclic Window Ordering:: Moving around the existing windows.
|
|
|
19 * Buffers and Windows:: Each window displays the contents of a buffer.
|
|
|
20 * Displaying Buffers:: Higher-lever functions for displaying a buffer
|
|
|
21 and choosing a window for it.
|
|
|
22 * Choosing Window:: How to choose a window for displaying a buffer.
|
|
|
23 * Window Point:: Each window has its own location of point.
|
|
|
24 * Window Start:: The display-start position controls which text
|
|
444
|
25 is on-screen in the window.
|
|
428
|
26 * Vertical Scrolling:: Moving text up and down in the window.
|
|
|
27 * Horizontal Scrolling:: Moving text sideways on the window.
|
|
|
28 * Size of Window:: Accessing the size of a window.
|
|
|
29 * Position of Window:: Accessing the position of a window.
|
|
|
30 * Resizing Windows:: Changing the size of a window.
|
|
|
31 * Window Configurations:: Saving and restoring the state of the screen.
|
|
|
32 @end menu
|
|
|
33
|
|
|
34 @node Basic Windows
|
|
|
35 @section Basic Concepts of Emacs Windows
|
|
|
36 @cindex window
|
|
|
37 @cindex selected window
|
|
|
38
|
|
|
39 A @dfn{window} in XEmacs is the physical area of the screen in which a
|
|
|
40 buffer is displayed. The term is also used to refer to a Lisp object that
|
|
|
41 represents that screen area in XEmacs Lisp. It should be
|
|
|
42 clear from the context which is meant.
|
|
|
43
|
|
|
44 XEmacs groups windows into frames. A frame represents an area of
|
|
|
45 screen available for XEmacs to use. Each frame always contains at least
|
|
|
46 one window, but you can subdivide it vertically or horizontally into
|
|
|
47 multiple nonoverlapping Emacs windows.
|
|
|
48
|
|
|
49 In each frame, at any time, one and only one window is designated as
|
|
|
50 @dfn{selected within the frame}. The frame's cursor appears in that
|
|
|
51 window. At ant time, one frame is the selected frame; and the window
|
|
|
52 selected within that frame is @dfn{the selected window}. The selected
|
|
|
53 window's buffer is usually the current buffer (except when
|
|
|
54 @code{set-buffer} has been used). @xref{Current Buffer}.
|
|
|
55
|
|
|
56 For practical purposes, a window exists only while it is displayed in
|
|
|
57 a frame. Once removed from the frame, the window is effectively deleted
|
|
|
58 and should not be used, @emph{even though there may still be references
|
|
|
59 to it} from other Lisp objects. Restoring a saved window configuration
|
|
|
60 is the only way for a window no longer on the screen to come back to
|
|
|
61 life. (@xref{Deleting Windows}.)
|
|
|
62
|
|
|
63 Each window has the following attributes:
|
|
|
64
|
|
|
65 @itemize @bullet
|
|
|
66 @item
|
|
|
67 containing frame
|
|
|
68
|
|
444
|
69 @item
|
|
428
|
70 window height
|
|
|
71
|
|
444
|
72 @item
|
|
428
|
73 window width
|
|
|
74
|
|
444
|
75 @item
|
|
428
|
76 window edges with respect to the frame or screen
|
|
|
77
|
|
444
|
78 @item
|
|
428
|
79 the buffer it displays
|
|
|
80
|
|
444
|
81 @item
|
|
428
|
82 position within the buffer at the upper left of the window
|
|
|
83
|
|
444
|
84 @item
|
|
428
|
85 amount of horizontal scrolling, in columns
|
|
|
86
|
|
444
|
87 @item
|
|
428
|
88 point
|
|
|
89
|
|
444
|
90 @item
|
|
428
|
91 the mark
|
|
|
92
|
|
444
|
93 @item
|
|
428
|
94 how recently the window was selected
|
|
|
95 @end itemize
|
|
|
96
|
|
|
97 @cindex multiple windows
|
|
|
98 Users create multiple windows so they can look at several buffers at
|
|
|
99 once. Lisp libraries use multiple windows for a variety of reasons, but
|
|
|
100 most often to display related information. In Rmail, for example, you
|
|
|
101 can move through a summary buffer in one window while the other window
|
|
|
102 shows messages one at a time as they are reached.
|
|
|
103
|
|
|
104 The meaning of ``window'' in XEmacs is similar to what it means in the
|
|
|
105 context of general-purpose window systems such as X, but not identical.
|
|
|
106 The X Window System places X windows on the screen; XEmacs uses one or
|
|
|
107 more X windows as frames, and subdivides them into
|
|
|
108 Emacs windows. When you use XEmacs on a character-only terminal, XEmacs
|
|
|
109 treats the whole terminal screen as one frame.
|
|
|
110
|
|
|
111 @cindex terminal frame
|
|
|
112 @cindex frame of terminal
|
|
|
113 @cindex tiled windows
|
|
|
114 Most window systems support arbitrarily located overlapping windows.
|
|
|
115 In contrast, Emacs windows are @dfn{tiled}; they never overlap, and
|
|
|
116 together they fill the whole screen or frame. Because of the way
|
|
|
117 in which XEmacs creates new windows and resizes them, you can't create
|
|
|
118 every conceivable tiling of windows on an Emacs frame. @xref{Splitting
|
|
|
119 Windows}, and @ref{Size of Window}.
|
|
|
120
|
|
|
121 @xref{Display}, for information on how the contents of the
|
|
|
122 window's buffer are displayed in the window.
|
|
|
123
|
|
|
124 @defun windowp object
|
|
|
125 This function returns @code{t} if @var{object} is a window.
|
|
|
126 @end defun
|
|
|
127
|
|
|
128 @node Splitting Windows
|
|
|
129 @section Splitting Windows
|
|
|
130 @cindex splitting windows
|
|
|
131 @cindex window splitting
|
|
|
132
|
|
|
133 The functions described here are the primitives used to split a window
|
|
|
134 into two windows. Two higher level functions sometimes split a window,
|
|
|
135 but not always: @code{pop-to-buffer} and @code{display-buffer}
|
|
|
136 (@pxref{Displaying Buffers}).
|
|
|
137
|
|
|
138 The functions described here do not accept a buffer as an argument.
|
|
|
139 The two ``halves'' of the split window initially display the same buffer
|
|
|
140 previously visible in the window that was split.
|
|
|
141
|
|
444
|
142 @defun one-window-p &optional nomini which-frames which-devices
|
|
428
|
143 This function returns non-@code{nil} if there is only one window. The
|
|
444
|
144 argument @var{nomini}, if non-@code{nil}, means don't count the
|
|
428
|
145 minibuffer even if it is active; otherwise, the minibuffer window is
|
|
|
146 included, if active, in the total number of windows which is compared
|
|
|
147 against one.
|
|
|
148
|
|
444
|
149 The remaining arguments controls which set of windows are counted, as
|
|
|
150 with @code{next-window}.
|
|
428
|
151 @end defun
|
|
|
152
|
|
|
153 @deffn Command split-window &optional window size horizontal
|
|
|
154 This function splits @var{window} into two windows. The original
|
|
|
155 window @var{window} remains the selected window, but occupies only
|
|
|
156 part of its former screen area. The rest is occupied by a newly created
|
|
|
157 window which is returned as the value of this function.
|
|
|
158
|
|
|
159 If @var{horizontal} is non-@code{nil}, then @var{window} splits into
|
|
|
160 two side by side windows. The original window @var{window} keeps the
|
|
|
161 leftmost @var{size} columns, and gives the rest of the columns to the
|
|
|
162 new window. Otherwise, it splits into windows one above the other, and
|
|
|
163 @var{window} keeps the upper @var{size} lines and gives the rest of the
|
|
|
164 lines to the new window. The original window is therefore the
|
|
|
165 left-hand or upper of the two, and the new window is the right-hand or
|
|
|
166 lower.
|
|
|
167
|
|
|
168 If @var{window} is omitted or @code{nil}, then the selected window is
|
|
|
169 split. If @var{size} is omitted or @code{nil}, then @var{window} is
|
|
|
170 divided evenly into two parts. (If there is an odd line, it is
|
|
|
171 allocated to the new window.) When @code{split-window} is called
|
|
|
172 interactively, all its arguments are @code{nil}.
|
|
|
173
|
|
|
174 The following example starts with one window on a frame that is 50
|
|
|
175 lines high by 80 columns wide; then the window is split.
|
|
|
176
|
|
|
177 @smallexample
|
|
|
178 @group
|
|
|
179 (setq w (selected-window))
|
|
|
180 @result{} #<window 8 on windows.texi>
|
|
|
181 (window-edges) ; @r{Edges in order:}
|
|
|
182 @result{} (0 0 80 50) ; @r{left--top--right--bottom}
|
|
|
183 @end group
|
|
|
184
|
|
|
185 @group
|
|
|
186 ;; @r{Returns window created}
|
|
444
|
187 (setq w2 (split-window w 15))
|
|
428
|
188 @result{} #<window 28 on windows.texi>
|
|
|
189 @end group
|
|
|
190 @group
|
|
|
191 (window-edges w2)
|
|
|
192 @result{} (0 15 80 50) ; @r{Bottom window;}
|
|
|
193 ; @r{top is line 15}
|
|
|
194 @end group
|
|
|
195 @group
|
|
|
196 (window-edges w)
|
|
|
197 @result{} (0 0 80 15) ; @r{Top window}
|
|
|
198 @end group
|
|
|
199 @end smallexample
|
|
|
200
|
|
|
201 The frame looks like this:
|
|
|
202
|
|
|
203 @smallexample
|
|
|
204 @group
|
|
444
|
205 __________
|
|
|
206 | | line 0
|
|
428
|
207 | w |
|
|
|
208 |__________|
|
|
|
209 | | line 15
|
|
|
210 | w2 |
|
|
|
211 |__________|
|
|
|
212 line 50
|
|
|
213 column 0 column 80
|
|
|
214 @end group
|
|
|
215 @end smallexample
|
|
|
216
|
|
|
217 Next, the top window is split horizontally:
|
|
|
218
|
|
|
219 @smallexample
|
|
|
220 @group
|
|
|
221 (setq w3 (split-window w 35 t))
|
|
|
222 @result{} #<window 32 on windows.texi>
|
|
|
223 @end group
|
|
|
224 @group
|
|
|
225 (window-edges w3)
|
|
|
226 @result{} (35 0 80 15) ; @r{Left edge at column 35}
|
|
|
227 @end group
|
|
|
228 @group
|
|
|
229 (window-edges w)
|
|
|
230 @result{} (0 0 35 15) ; @r{Right edge at column 35}
|
|
|
231 @end group
|
|
|
232 @group
|
|
|
233 (window-edges w2)
|
|
|
234 @result{} (0 15 80 50) ; @r{Bottom window unchanged}
|
|
|
235 @end group
|
|
|
236 @end smallexample
|
|
|
237
|
|
|
238 @need 3000
|
|
|
239 Now, the screen looks like this:
|
|
|
240
|
|
|
241 @smallexample
|
|
|
242 @group
|
|
|
243 column 35
|
|
444
|
244 __________
|
|
|
245 | | | line 0
|
|
428
|
246 | w | w3 |
|
|
|
247 |___|______|
|
|
|
248 | | line 15
|
|
|
249 | w2 |
|
|
|
250 |__________|
|
|
|
251 line 50
|
|
|
252 column 0 column 80
|
|
|
253 @end group
|
|
|
254 @end smallexample
|
|
|
255
|
|
|
256 Normally, Emacs indicates the border between two side-by-side windows
|
|
|
257 with a scroll bar (@pxref{X Frame Properties,Scroll Bars}) or @samp{|}
|
|
|
258 characters. The display table can specify alternative border
|
|
|
259 characters; see @ref{Display Tables}.
|
|
|
260 @end deffn
|
|
|
261
|
|
|
262 @deffn Command split-window-vertically &optional size
|
|
|
263 This function splits the selected window into two windows, one above
|
|
|
264 the other, leaving the selected window with @var{size} lines.
|
|
|
265
|
|
444
|
266 This function is simply an interface to @code{split-window}.
|
|
428
|
267 Here is the complete function definition for it:
|
|
|
268
|
|
|
269 @smallexample
|
|
|
270 @group
|
|
|
271 (defun split-window-vertically (&optional arg)
|
|
|
272 "Split current window into two windows, one above the other."
|
|
|
273 (interactive "P")
|
|
|
274 (split-window nil (and arg (prefix-numeric-value arg))))
|
|
|
275 @end group
|
|
|
276 @end smallexample
|
|
|
277 @end deffn
|
|
|
278
|
|
|
279 @deffn Command split-window-horizontally &optional size
|
|
|
280 This function splits the selected window into two windows
|
|
|
281 side-by-side, leaving the selected window with @var{size} columns.
|
|
|
282
|
|
444
|
283 This function is simply an interface to @code{split-window}. Here is
|
|
428
|
284 the complete definition for @code{split-window-horizontally} (except for
|
|
|
285 part of the documentation string):
|
|
|
286
|
|
|
287 @smallexample
|
|
|
288 @group
|
|
|
289 (defun split-window-horizontally (&optional arg)
|
|
|
290 "Split selected window into two windows, side by side..."
|
|
|
291 (interactive "P")
|
|
|
292 (split-window nil (and arg (prefix-numeric-value arg)) t))
|
|
|
293 @end group
|
|
|
294 @end smallexample
|
|
|
295 @end deffn
|
|
|
296
|
|
|
297 @node Deleting Windows
|
|
|
298 @section Deleting Windows
|
|
|
299 @cindex deleting windows
|
|
|
300
|
|
|
301 A window remains visible on its frame unless you @dfn{delete} it by
|
|
|
302 calling certain functions that delete windows. A deleted window cannot
|
|
|
303 appear on the screen, but continues to exist as a Lisp object until
|
|
|
304 there are no references to it. There is no way to cancel the deletion
|
|
|
305 of a window aside from restoring a saved window configuration
|
|
|
306 (@pxref{Window Configurations}). Restoring a window configuration also
|
|
|
307 deletes any windows that aren't part of that configuration.
|
|
|
308
|
|
|
309 When you delete a window, the space it took up is given to one
|
|
|
310 adjacent sibling. (In Emacs version 18, the space was divided evenly
|
|
|
311 among all the siblings.)
|
|
|
312
|
|
|
313 @c Emacs 19 feature
|
|
|
314 @defun window-live-p window
|
|
|
315 This function returns @code{nil} if @var{window} is deleted, and
|
|
|
316 @code{t} otherwise.
|
|
|
317
|
|
|
318 @strong{Warning:} Erroneous information or fatal errors may result from
|
|
|
319 using a deleted window as if it were live.
|
|
|
320 @end defun
|
|
|
321
|
|
444
|
322 @deffn Command delete-window &optional window force
|
|
|
323 This function removes @var{window} from the display. If @var{window} is
|
|
|
324 omitted, then the selected window is deleted. If window is the only one
|
|
|
325 on its frame, the frame is deleted as well.
|
|
|
326
|
|
|
327 Normally, you cannot delete the last non-minibuffer-only frame (you must
|
|
|
328 use @code{save-buffers-kill-emacs} or @code{kill-emacs}); an error is
|
|
|
329 signaled instead. However, if optional second argument @var{force} is
|
|
|
330 non-@code{nil}, you can delete the last frame. (This will automatically
|
|
|
331 call @code{save-buffers-kill-emacs}.)
|
|
428
|
332
|
|
|
333 This function returns @code{nil}.
|
|
|
334
|
|
444
|
335 When @code{delete-window} is called interactively, the selected window
|
|
|
336 is deleted.
|
|
428
|
337 @end deffn
|
|
|
338
|
|
|
339 @deffn Command delete-other-windows &optional window
|
|
|
340 This function makes @var{window} the only window on its frame, by
|
|
|
341 deleting the other windows in that frame. If @var{window} is omitted or
|
|
|
342 @code{nil}, then the selected window is used by default.
|
|
|
343
|
|
|
344 The result is @code{nil}.
|
|
|
345 @end deffn
|
|
|
346
|
|
444
|
347 @deffn Command delete-windows-on buffer &optional which-frames which-devices
|
|
428
|
348 This function deletes all windows showing @var{buffer}. If there are
|
|
|
349 no windows showing @var{buffer}, it does nothing.
|
|
|
350
|
|
|
351 @code{delete-windows-on} operates frame by frame. If a frame has
|
|
|
352 several windows showing different buffers, then those showing
|
|
|
353 @var{buffer} are removed, and the others expand to fill the space. If
|
|
|
354 all windows in some frame are showing @var{buffer} (including the case
|
|
|
355 where there is only one window), then the frame reverts to having a
|
|
|
356 single window showing another buffer chosen with @code{other-buffer}.
|
|
|
357 @xref{The Buffer List}.
|
|
|
358
|
|
444
|
359 The argument @var{which-frames} controls which frames to operate on:
|
|
|
360
|
|
|
361 @table @asis
|
|
|
362 @item @code{nil}
|
|
|
363 Delete all windows showing @var{buffer} in any frame.
|
|
|
364
|
|
|
365 @item @code{t}
|
|
|
366 Delete only windows showing @var{buffer} in the selected frame.
|
|
|
367
|
|
|
368 @item @code{visible}
|
|
|
369 Delete all windows showing @var{buffer} in any visible frame.
|
|
|
370
|
|
|
371 @item @code{0}
|
|
|
372 Delete all windows showing @var{buffer} in any visible frame.
|
|
|
373
|
|
|
374 @item @var{frame}
|
|
|
375 If it is a frame, delete all windows showing @var{buffer} in that frame.
|
|
|
376 @end table
|
|
|
377
|
|
|
378 @strong{Warning:} This is similar to, but not identical to, the meaning
|
|
|
379 of the @var{which-frames} argument to @code{next-window}; the meanings
|
|
|
380 of @code{nil} and @code{t} are reversed.
|
|
428
|
381
|
|
444
|
382 The optional argument @var{which-devices} further clarifies on which
|
|
|
383 devices to search for frames as specified by @var{which-frames}.
|
|
|
384 This value is only meaningful if @var{which-frames} is not @code{t}.
|
|
|
385
|
|
|
386 @table @asis
|
|
|
387 @item @code{nil}
|
|
|
388 Consider all devices on the selected console.
|
|
|
389
|
|
|
390 @item @var{device}
|
|
|
391 Consider only the one device @var{device}.
|
|
|
392
|
|
|
393 @item @var{console}
|
|
|
394 Consider all devices on @var{console}.
|
|
|
395
|
|
|
396 @item @var{device-type}
|
|
|
397 Consider all devices with device type @var{device-type}.
|
|
|
398
|
|
|
399 @item @code{window-system}
|
|
|
400 Consider all devices on window system consoles.
|
|
|
401
|
|
|
402 @item anything else
|
|
|
403 Consider all devices without restriction.
|
|
|
404 @end table
|
|
428
|
405
|
|
|
406 This function always returns @code{nil}.
|
|
|
407 @end deffn
|
|
|
408
|
|
|
409 @node Selecting Windows
|
|
|
410 @section Selecting Windows
|
|
|
411 @cindex selecting windows
|
|
|
412
|
|
|
413 When a window is selected, the buffer in the window becomes the current
|
|
|
414 buffer, and the cursor will appear in it.
|
|
|
415
|
|
|
416 @defun selected-window &optional device
|
|
|
417 This function returns the selected window. This is the window in
|
|
|
418 which the cursor appears and to which many commands apply. Each
|
|
|
419 separate device can have its own selected window, which is remembered
|
|
|
420 as focus changes from device to device. Optional argument @var{device}
|
|
|
421 specifies which device to return the selected window for, and defaults
|
|
|
422 to the selected device.
|
|
|
423 @end defun
|
|
|
424
|
|
|
425 @defun select-window window &optional norecord
|
|
|
426 This function makes @var{window} the selected window. The cursor then
|
|
|
427 appears in @var{window} (on redisplay). The buffer being displayed in
|
|
|
428 @var{window} is immediately designated the current buffer.
|
|
|
429
|
|
|
430 If optional argument @var{norecord} is non-@code{nil} then the global
|
|
|
431 and per-frame buffer orderings are not modified, as by the function
|
|
444
|
432 @code{record-buffer}.
|
|
428
|
433
|
|
|
434 The return value is @var{window}.
|
|
|
435
|
|
|
436 @example
|
|
|
437 @group
|
|
|
438 (setq w (next-window))
|
|
|
439 (select-window w)
|
|
|
440 @result{} #<window 65 on windows.texi>
|
|
|
441 @end group
|
|
|
442 @end example
|
|
|
443 @end defun
|
|
|
444
|
|
444
|
445 @defspec save-selected-window forms@dots{}
|
|
|
446 This special form records the selected window, executes @var{forms} in
|
|
|
447 sequence, then restores the earlier selected window. It does not save
|
|
|
448 or restore anything about the sizes, arrangement or contents of windows;
|
|
|
449 therefore, if the @var{forms} change them, the changes are permanent.
|
|
|
450 @end defspec
|
|
428
|
451
|
|
|
452 @cindex finding windows
|
|
|
453 The following functions choose one of the windows on the screen,
|
|
|
454 offering various criteria for the choice.
|
|
|
455
|
|
444
|
456 @defun get-lru-window &optional which-frames which-devices
|
|
428
|
457 This function returns the window least recently ``used'' (that is,
|
|
|
458 selected). The selected window is always the most recently used window.
|
|
|
459
|
|
|
460 The selected window can be the least recently used window if it is the
|
|
|
461 only window. A newly created window becomes the least recently used
|
|
|
462 window until it is selected. A minibuffer window is never a candidate.
|
|
|
463
|
|
444
|
464 By default, only the windows in the selected frame are considered.
|
|
|
465 The optional argument @var{which-frames} changes this behavior.
|
|
|
466 Here are the possible values and their meanings:
|
|
|
467
|
|
|
468 @table @asis
|
|
|
469 @item @code{nil}
|
|
|
470 Consider all the windows in the selected windows's frame, plus the
|
|
|
471 minibuffer used by that frame even if it lies in some other frame.
|
|
|
472
|
|
|
473 @item @code{t}
|
|
|
474 Consider all windows in all existing frames.
|
|
|
475
|
|
|
476 @item @code{visible}
|
|
|
477 Consider all windows in all visible frames. (To get useful results, you
|
|
|
478 must ensure @var{window} is in a visible frame.)
|
|
|
479
|
|
|
480 @item @code{0}
|
|
|
481 Consider all windows in all visible or iconified frames.
|
|
|
482
|
|
|
483 @item @var{frame}
|
|
|
484 Consider all windows on frame @var{frame}.
|
|
428
|
485
|
|
444
|
486 @item anything else
|
|
|
487 Consider precisely the windows in the selected window's frame, and no others.
|
|
|
488 @end table
|
|
|
489
|
|
|
490 The optional argument @var{which-devices} further clarifies on which
|
|
|
491 devices to search for frames as specified by @var{which-frames}.
|
|
|
492 This value is only meaningful if @var{which-frames} is non-@code{nil}.
|
|
|
493
|
|
|
494 @table @asis
|
|
|
495 @item @code{nil}
|
|
|
496 Consider all devices on the selected console.
|
|
|
497
|
|
|
498 @item @var{device}
|
|
|
499 Consider only the one device @var{device}.
|
|
|
500
|
|
|
501 @item @var{console}
|
|
|
502 Consider all devices on @var{console}.
|
|
|
503
|
|
|
504 @item @var{device-type}
|
|
|
505 Consider all devices with device type @var{device-type}.
|
|
|
506
|
|
|
507 @item @code{window-system}
|
|
|
508 Consider all devices on window system consoles.
|
|
|
509
|
|
|
510 @item anything else
|
|
|
511 Consider all devices without restriction.
|
|
|
512 @end table
|
|
|
513
|
|
428
|
514 @end defun
|
|
|
515
|
|
444
|
516 @defun get-largest-window &optional which-frames which-devices
|
|
428
|
517 This function returns the window with the largest area (height times
|
|
|
518 width). If there are no side-by-side windows, then this is the window
|
|
|
519 with the most lines. A minibuffer window is never a candidate.
|
|
|
520
|
|
|
521 If there are two windows of the same size, then the function returns
|
|
|
522 the window that is first in the cyclic ordering of windows (see
|
|
|
523 following section), starting from the selected window.
|
|
|
524
|
|
444
|
525 The remaining arguments control which set of windows are considered.
|
|
|
526 See @code{next-window}, above.
|
|
428
|
527 @end defun
|
|
|
528
|
|
|
529 @node Cyclic Window Ordering
|
|
|
530 @section Cyclic Ordering of Windows
|
|
|
531 @cindex cyclic ordering of windows
|
|
|
532 @cindex ordering of windows, cyclic
|
|
444
|
533 @cindex window ordering, cyclic
|
|
428
|
534
|
|
|
535 When you use the command @kbd{C-x o} (@code{other-window}) to select
|
|
|
536 the next window, it moves through all the windows on the screen in a
|
|
|
537 specific cyclic order. For any given configuration of windows, this
|
|
|
538 order never varies. It is called the @dfn{cyclic ordering of windows}.
|
|
|
539
|
|
|
540 This ordering generally goes from top to bottom, and from left to
|
|
|
541 right. But it may go down first or go right first, depending on the
|
|
|
542 order in which the windows were split.
|
|
|
543
|
|
|
544 If the first split was vertical (into windows one above each other),
|
|
|
545 and then the subwindows were split horizontally, then the ordering is
|
|
|
546 left to right in the top of the frame, and then left to right in the
|
|
|
547 next lower part of the frame, and so on. If the first split was
|
|
|
548 horizontal, the ordering is top to bottom in the left part, and so on.
|
|
|
549 In general, within each set of siblings at any level in the window tree,
|
|
|
550 the order is left to right, or top to bottom.
|
|
|
551
|
|
444
|
552 @defun next-window &optional window minibuf which-frames which-devices
|
|
428
|
553 @cindex minibuffer window
|
|
|
554 This function returns the window following @var{window} in the cyclic
|
|
|
555 ordering of windows. This is the window that @kbd{C-x o} would select
|
|
|
556 if typed when @var{window} is selected. If @var{window} is the only
|
|
|
557 window visible, then this function returns @var{window}. If omitted,
|
|
|
558 @var{window} defaults to the selected window.
|
|
|
559
|
|
|
560 The value of the argument @var{minibuf} determines whether the
|
|
|
561 minibuffer is included in the window order. Normally, when
|
|
|
562 @var{minibuf} is @code{nil}, the minibuffer is included if it is
|
|
|
563 currently active; this is the behavior of @kbd{C-x o}. (The minibuffer
|
|
|
564 window is active while the minibuffer is in use. @xref{Minibuffers}.)
|
|
|
565
|
|
|
566 If @var{minibuf} is @code{t}, then the cyclic ordering includes the
|
|
|
567 minibuffer window even if it is not active.
|
|
|
568
|
|
|
569 If @var{minibuf} is neither @code{t} nor @code{nil}, then the minibuffer
|
|
|
570 window is not included even if it is active.
|
|
|
571
|
|
444
|
572 By default, only the windows in the selected frame are considered.
|
|
|
573 The optional argument @var{which-frames} changes this behavior.
|
|
|
574 Here are the possible values and their meanings:
|
|
428
|
575
|
|
|
576 @table @asis
|
|
|
577 @item @code{nil}
|
|
|
578 Consider all the windows in @var{window}'s frame, plus the minibuffer
|
|
|
579 used by that frame even if it lies in some other frame.
|
|
|
580
|
|
|
581 @item @code{t}
|
|
|
582 Consider all windows in all existing frames.
|
|
|
583
|
|
|
584 @item @code{visible}
|
|
|
585 Consider all windows in all visible frames. (To get useful results, you
|
|
|
586 must ensure @var{window} is in a visible frame.)
|
|
|
587
|
|
444
|
588 @item @code{0}
|
|
428
|
589 Consider all windows in all visible or iconified frames.
|
|
|
590
|
|
444
|
591 @item @var{frame}
|
|
|
592 Consider all windows on frame @var{frame}.
|
|
|
593
|
|
428
|
594 @item anything else
|
|
|
595 Consider precisely the windows in @var{window}'s frame, and no others.
|
|
|
596 @end table
|
|
|
597
|
|
444
|
598 The optional argument @var{which-devices} further clarifies on which
|
|
|
599 devices to search for frames as specified by @var{which-frames}.
|
|
|
600 This value is only meaningful if @var{which-frames} is non-@code{nil}.
|
|
|
601
|
|
|
602 @table @asis
|
|
|
603 @item @code{nil}
|
|
|
604 Consider all devices on the selected console.
|
|
|
605
|
|
|
606 @item @var{device}
|
|
|
607 Consider only the one device @var{device}.
|
|
|
608
|
|
|
609 @item @var{console}
|
|
|
610 Consider all devices on @var{console}.
|
|
|
611
|
|
|
612 @item @var{device-type}
|
|
|
613 Consider all devices with device type @var{device-type}.
|
|
|
614
|
|
|
615 @item @code{window-system}
|
|
|
616 Consider all devices on window system consoles.
|
|
|
617
|
|
|
618 @item anything else
|
|
|
619 Consider all devices without restriction.
|
|
|
620 @end table
|
|
|
621
|
|
|
622 If you use consistent values for @var{minibuf}, @var{which-frames}, and
|
|
|
623 @var{which-devices}, you can use @code{next-window} to iterate through the
|
|
|
624 entire cycle of acceptable windows, eventually ending up back at the
|
|
|
625 window you started with. @code{previous-window} traverses the same
|
|
|
626 cycle, in the reverse order.
|
|
|
627
|
|
|
628 This example assumes there are two windows, both displaying the
|
|
428
|
629 buffer @samp{windows.texi}:
|
|
|
630
|
|
|
631 @example
|
|
|
632 @group
|
|
|
633 (selected-window)
|
|
|
634 @result{} #<window 56 on windows.texi>
|
|
|
635 @end group
|
|
|
636 @group
|
|
|
637 (next-window (selected-window))
|
|
|
638 @result{} #<window 52 on windows.texi>
|
|
|
639 @end group
|
|
|
640 @group
|
|
|
641 (next-window (next-window (selected-window)))
|
|
|
642 @result{} #<window 56 on windows.texi>
|
|
|
643 @end group
|
|
|
644 @end example
|
|
|
645 @end defun
|
|
|
646
|
|
444
|
647 @defun previous-window &optional window minibuf which-frames which-devices
|
|
428
|
648 This function returns the window preceding @var{window} in the cyclic
|
|
|
649 ordering of windows. The other arguments specify which windows to
|
|
|
650 include in the cycle, as in @code{next-window}.
|
|
|
651 @end defun
|
|
|
652
|
|
444
|
653 @deffn Command other-window count &optional which-frames which-devices
|
|
|
654 This function selects the @var{count}th following window in the cyclic order.
|
|
|
655 If @var{count} is negative, then it selects the @minus{}@var{count}th
|
|
428
|
656 preceding window. It returns @code{nil}.
|
|
|
657
|
|
|
658 In an interactive call, @var{count} is the numeric prefix argument.
|
|
|
659
|
|
444
|
660 The other arguments specify which windows to include in the cycle, as in
|
|
|
661 @code{next-window}.
|
|
428
|
662 @end deffn
|
|
|
663
|
|
444
|
664 @defun walk-windows function &optional minibuf which-frames which-devices
|
|
|
665 This function cycles through all windows, calling @code{function}
|
|
428
|
666 once for each window with the window as its sole argument.
|
|
|
667
|
|
444
|
668 The other arguments specify which windows to cycle through, as in
|
|
|
669 @code{next-window}.
|
|
428
|
670 @end defun
|
|
|
671
|
|
|
672 @node Buffers and Windows
|
|
|
673 @section Buffers and Windows
|
|
|
674 @cindex examining windows
|
|
|
675 @cindex windows, controlling precisely
|
|
|
676 @cindex buffers, controlled in windows
|
|
|
677
|
|
|
678 This section describes low-level functions to examine windows or to
|
|
|
679 display buffers in windows in a precisely controlled fashion.
|
|
|
680 @iftex
|
|
|
681 See the following section for
|
|
|
682 @end iftex
|
|
|
683 @ifinfo
|
|
|
684 @xref{Displaying Buffers}, for
|
|
|
685 @end ifinfo
|
|
|
686 related functions that find a window to use and specify a buffer for it.
|
|
|
687 The functions described there are easier to use than these, but they
|
|
|
688 employ heuristics in choosing or creating a window; use these functions
|
|
|
689 when you need complete control.
|
|
|
690
|
|
444
|
691 @defun set-window-buffer window buffer-or-name &optional norecord
|
|
428
|
692 This function makes @var{window} display @var{buffer-or-name} as its
|
|
444
|
693 contents. @var{buffer-or-name} can be a buffer or a buffer name.
|
|
|
694
|
|
|
695 With non-@code{nil} optional argument @var{norecord}, do not modify the
|
|
|
696 global or per-frame buffer ordering.
|
|
|
697
|
|
|
698 This function returns @code{nil}.
|
|
428
|
699
|
|
|
700 @example
|
|
|
701 @group
|
|
|
702 (set-window-buffer (selected-window) "foo")
|
|
|
703 @result{} nil
|
|
|
704 @end group
|
|
|
705 @end example
|
|
|
706 @end defun
|
|
|
707
|
|
|
708 @defun window-buffer &optional window
|
|
|
709 This function returns the buffer that @var{window} is displaying. If
|
|
|
710 @var{window} is omitted, this function returns the buffer for the
|
|
|
711 selected window.
|
|
|
712
|
|
|
713 @example
|
|
|
714 @group
|
|
|
715 (window-buffer)
|
|
|
716 @result{} #<buffer windows.texi>
|
|
|
717 @end group
|
|
|
718 @end example
|
|
|
719 @end defun
|
|
|
720
|
|
444
|
721 @defun get-buffer-window buffer-or-name &optional which-frames which-devices
|
|
428
|
722 This function returns a window currently displaying
|
|
|
723 @var{buffer-or-name}, or @code{nil} if there is none. If there are
|
|
|
724 several such windows, then the function returns the first one in the
|
|
|
725 cyclic ordering of windows, starting from the selected window.
|
|
|
726 @xref{Cyclic Window Ordering}.
|
|
|
727
|
|
444
|
728 The remaining arguments control which windows to consider. They have
|
|
|
729 the same meaning as for @code{next-window}.
|
|
428
|
730 @end defun
|
|
|
731
|
|
|
732 @node Displaying Buffers
|
|
|
733 @section Displaying Buffers in Windows
|
|
|
734 @cindex switching to a buffer
|
|
|
735 @cindex displaying a buffer
|
|
|
736
|
|
|
737 In this section we describe convenient functions that choose a window
|
|
|
738 automatically and use it to display a specified buffer. These functions
|
|
|
739 can also split an existing window in certain circumstances. We also
|
|
|
740 describe variables that parameterize the heuristics used for choosing a
|
|
|
741 window.
|
|
|
742 @iftex
|
|
|
743 See the preceding section for
|
|
|
744 @end iftex
|
|
|
745 @ifinfo
|
|
|
746 @xref{Buffers and Windows}, for
|
|
|
747 @end ifinfo
|
|
|
748 low-level functions that give you more precise control.
|
|
|
749
|
|
|
750 Do not use the functions in this section in order to make a buffer
|
|
|
751 current so that a Lisp program can access or modify it; they are too
|
|
|
752 drastic for that purpose, since they change the display of buffers in
|
|
|
753 windows, which is gratuitous and will surprise the user. Instead, use
|
|
|
754 @code{set-buffer} (@pxref{Current Buffer}) and @code{save-excursion}
|
|
|
755 (@pxref{Excursions}), which designate buffers as current for programmed
|
|
|
756 access without affecting the display of buffers in windows.
|
|
|
757
|
|
|
758 @deffn Command switch-to-buffer buffer-or-name &optional norecord
|
|
|
759 This function makes @var{buffer-or-name} the current buffer, and also
|
|
|
760 displays the buffer in the selected window. This means that a human can
|
|
|
761 see the buffer and subsequent keyboard commands will apply to it.
|
|
|
762 Contrast this with @code{set-buffer}, which makes @var{buffer-or-name}
|
|
|
763 the current buffer but does not display it in the selected window.
|
|
|
764 @xref{Current Buffer}.
|
|
|
765
|
|
|
766 If @var{buffer-or-name} does not identify an existing buffer, then a new
|
|
|
767 buffer by that name is created. The major mode for the new buffer is
|
|
|
768 set according to the variable @code{default-major-mode}. @xref{Auto
|
|
|
769 Major Mode}.
|
|
|
770
|
|
|
771 Normally the specified buffer is put at the front of the buffer list.
|
|
|
772 This affects the operation of @code{other-buffer}. However, if
|
|
|
773 @var{norecord} is non-@code{nil}, this is not done. @xref{The Buffer
|
|
|
774 List}.
|
|
|
775
|
|
|
776 The @code{switch-to-buffer} function is often used interactively, as
|
|
|
777 the binding of @kbd{C-x b}. It is also used frequently in programs. It
|
|
|
778 always returns @code{nil}.
|
|
|
779 @end deffn
|
|
|
780
|
|
|
781 @deffn Command switch-to-buffer-other-window buffer-or-name
|
|
|
782 This function makes @var{buffer-or-name} the current buffer and
|
|
|
783 displays it in a window not currently selected. It then selects that
|
|
|
784 window. The handling of the buffer is the same as in
|
|
|
785 @code{switch-to-buffer}.
|
|
|
786
|
|
|
787 The currently selected window is absolutely never used to do the job.
|
|
|
788 If it is the only window, then it is split to make a distinct window for
|
|
|
789 this purpose. If the selected window is already displaying the buffer,
|
|
|
790 then it continues to do so, but another window is nonetheless found to
|
|
|
791 display it in as well.
|
|
|
792 @end deffn
|
|
|
793
|
|
|
794 @defun pop-to-buffer buffer-or-name &optional other-window on-frame
|
|
|
795 This function makes @var{buffer-or-name} the current buffer and
|
|
|
796 switches to it in some window, preferably not the window previously
|
|
|
797 selected. The ``popped-to'' window becomes the selected window within
|
|
|
798 its frame.
|
|
|
799
|
|
|
800 If the variable @code{pop-up-frames} is non-@code{nil},
|
|
|
801 @code{pop-to-buffer} looks for a window in any visible frame already
|
|
|
802 displaying the buffer; if there is one, it returns that window and makes
|
|
|
803 it be selected within its frame. If there is none, it creates a new
|
|
|
804 frame and displays the buffer in it.
|
|
|
805
|
|
|
806 If @code{pop-up-frames} is @code{nil}, then @code{pop-to-buffer}
|
|
|
807 operates entirely within the selected frame. (If the selected frame has
|
|
|
808 just a minibuffer, @code{pop-to-buffer} operates within the most
|
|
|
809 recently selected frame that was not just a minibuffer.)
|
|
|
810
|
|
|
811 If the variable @code{pop-up-windows} is non-@code{nil}, windows may
|
|
|
812 be split to create a new window that is different from the original
|
|
|
813 window. For details, see @ref{Choosing Window}.
|
|
|
814
|
|
|
815 If @var{other-window} is non-@code{nil}, @code{pop-to-buffer} finds or
|
|
|
816 creates another window even if @var{buffer-or-name} is already visible
|
|
|
817 in the selected window. Thus @var{buffer-or-name} could end up
|
|
|
818 displayed in two windows. On the other hand, if @var{buffer-or-name} is
|
|
|
819 already displayed in the selected window and @var{other-window} is
|
|
|
820 @code{nil}, then the selected window is considered sufficient display
|
|
|
821 for @var{buffer-or-name}, so that nothing needs to be done.
|
|
|
822
|
|
|
823 All the variables that affect @code{display-buffer} affect
|
|
|
824 @code{pop-to-buffer} as well. @xref{Choosing Window}.
|
|
|
825
|
|
|
826 If @var{buffer-or-name} is a string that does not name an existing
|
|
|
827 buffer, a buffer by that name is created. The major mode for the new
|
|
|
828 buffer is set according to the variable @code{default-major-mode}.
|
|
|
829 @xref{Auto Major Mode}.
|
|
|
830
|
|
|
831 If @var{on-frame} is non-@code{nil}, it is the frame to pop to this
|
|
|
832 buffer on.
|
|
|
833
|
|
|
834 An example use of this function is found at the end of @ref{Filter
|
|
|
835 Functions}.
|
|
|
836 @end defun
|
|
|
837
|
|
444
|
838 @deffn Command replace-buffer-in-windows buffer &optional which-frames which-devices
|
|
428
|
839 This function replaces @var{buffer} with some other buffer in all
|
|
|
840 windows displaying it. The other buffer used is chosen with
|
|
|
841 @code{other-buffer}. In the usual applications of this function, you
|
|
|
842 don't care which other buffer is used; you just want to make sure that
|
|
|
843 @var{buffer} is no longer displayed.
|
|
|
844
|
|
444
|
845 The optional arguments @var{which-frames} and @var{which-devices} have
|
|
|
846 the same meaning as with @code{delete-windows-on}.
|
|
|
847
|
|
428
|
848 This function returns @code{nil}.
|
|
|
849 @end deffn
|
|
|
850
|
|
|
851 @node Choosing Window
|
|
|
852 @section Choosing a Window for Display
|
|
|
853
|
|
|
854 This section describes the basic facility that chooses a window to
|
|
|
855 display a buffer in---@code{display-buffer}. All the higher-level
|
|
|
856 functions and commands use this subroutine. Here we describe how to use
|
|
|
857 @code{display-buffer} and how to customize it.
|
|
|
858
|
|
444
|
859 @deffn Command display-buffer buffer-or-name &optional not-this-window override-frame
|
|
428
|
860 This command makes @var{buffer-or-name} appear in some window, like
|
|
|
861 @code{pop-to-buffer}, but it does not select that window and does not
|
|
|
862 make the buffer current. The identity of the selected window is
|
|
|
863 unaltered by this function.
|
|
|
864
|
|
444
|
865 @var{buffer-or-name} can be a buffer or the name of one.
|
|
|
866
|
|
428
|
867 If @var{not-this-window} is non-@code{nil}, it means to display the
|
|
|
868 specified buffer in a window other than the selected one, even if it is
|
|
|
869 already on display in the selected window. This can cause the buffer to
|
|
|
870 appear in two windows at once. Otherwise, if @var{buffer-or-name} is
|
|
|
871 already being displayed in any window, that is good enough, so this
|
|
|
872 function does nothing.
|
|
|
873
|
|
444
|
874 If @var{override-frame} is non-@code{nil}, display on that frame instead
|
|
|
875 of the current frame (or the dedicated frame).
|
|
|
876
|
|
|
877 @code{display-buffer} returns the window chosen to display @var{buffer-or-name}.
|
|
428
|
878
|
|
|
879 Precisely how @code{display-buffer} finds or creates a window depends on
|
|
|
880 the variables described below.
|
|
|
881 @end deffn
|
|
|
882
|
|
|
883 @c Emacs 19 feature
|
|
|
884 @cindex dedicated window
|
|
|
885 A window can be marked as ``dedicated'' to a particular buffer.
|
|
|
886 Then XEmacs will not automatically change which buffer appears in the
|
|
|
887 window, such as @code{display-buffer} might normally do.
|
|
|
888
|
|
|
889 @defun window-dedicated-p window
|
|
|
890 This function returns @var{window}'s dedicated object, usually @code{t}
|
|
|
891 or @code{nil}.
|
|
|
892 @end defun
|
|
|
893
|
|
|
894 @defun set-window-buffer-dedicated window buffer
|
|
|
895 This function makes @var{window} display @var{buffer} and be dedicated
|
|
|
896 to that buffer. Then XEmacs will not automatically change which buffer
|
|
|
897 appears in @var{window}. If @var{buffer} is @code{nil}, this function makes
|
|
|
898 @var{window} not be dedicated (but doesn't change which buffer appears
|
|
|
899 in it currently).
|
|
|
900 @end defun
|
|
|
901
|
|
|
902 @defopt pop-up-windows
|
|
|
903 This variable controls whether @code{display-buffer} makes new windows.
|
|
|
904 If it is non-@code{nil} and there is only one window, then that window
|
|
|
905 is split. If it is @code{nil}, then @code{display-buffer} does not
|
|
|
906 split the single window, but uses it whole.
|
|
|
907 @end defopt
|
|
|
908
|
|
|
909 @defopt split-height-threshold
|
|
|
910 This variable determines when @code{display-buffer} may split a window,
|
|
|
911 if there are multiple windows. @code{display-buffer} always splits the
|
|
|
912 largest window if it has at least this many lines. If the largest
|
|
|
913 window is not this tall, it is split only if it is the sole window and
|
|
|
914 @code{pop-up-windows} is non-@code{nil}.
|
|
|
915 @end defopt
|
|
|
916
|
|
|
917 @c Emacs 19 feature
|
|
|
918 @defopt pop-up-frames
|
|
|
919 This variable controls whether @code{display-buffer} makes new frames.
|
|
|
920 If it is non-@code{nil}, @code{display-buffer} looks for an existing
|
|
|
921 window already displaying the desired buffer, on any visible frame. If
|
|
|
922 it finds one, it returns that window. Otherwise it makes a new frame.
|
|
|
923 The variables @code{pop-up-windows} and @code{split-height-threshold} do
|
|
|
924 not matter if @code{pop-up-frames} is non-@code{nil}.
|
|
|
925
|
|
|
926 If @code{pop-up-frames} is @code{nil}, then @code{display-buffer} either
|
|
|
927 splits a window or reuses one.
|
|
|
928
|
|
|
929 @xref{Frames}, for more information.
|
|
|
930 @end defopt
|
|
|
931
|
|
|
932 @c Emacs 19 feature
|
|
|
933 @defvar pop-up-frame-function
|
|
|
934 This variable specifies how to make a new frame if @code{pop-up-frames}
|
|
|
935 is non-@code{nil}.
|
|
|
936
|
|
|
937 Its value should be a function of no arguments. When
|
|
|
938 @code{display-buffer} makes a new frame, it does so by calling that
|
|
|
939 function, which should return a frame. The default value of the
|
|
|
940 variable is a function that creates a frame using properties from
|
|
|
941 @code{pop-up-frame-plist}.
|
|
|
942 @end defvar
|
|
|
943
|
|
|
944 @defvar pop-up-frame-plist
|
|
|
945 This variable holds a plist specifying frame properties used when
|
|
|
946 @code{display-buffer} makes a new frame. @xref{Frame Properties}, for
|
|
|
947 more information about frame properties.
|
|
|
948 @end defvar
|
|
|
949
|
|
|
950 @defvar special-display-buffer-names
|
|
|
951 A list of buffer names for buffers that should be displayed specially.
|
|
|
952 If the buffer's name is in this list, @code{display-buffer} handles the
|
|
|
953 buffer specially.
|
|
|
954
|
|
|
955 By default, special display means to give the buffer a dedicated frame.
|
|
|
956
|
|
|
957 If an element is a list, instead of a string, then the @sc{car} of the
|
|
|
958 list is the buffer name, and the rest of the list says how to create the
|
|
|
959 frame. There are two possibilities for the rest of the list. It can be
|
|
|
960 a plist, specifying frame properties, or it can contain a function and
|
|
|
961 arguments to give to it. (The function's first argument is always the
|
|
|
962 buffer to be displayed; the arguments from the list come after that.)
|
|
|
963 @end defvar
|
|
|
964
|
|
|
965 @defvar special-display-regexps
|
|
|
966 A list of regular expressions that specify buffers that should be
|
|
|
967 displayed specially. If the buffer's name matches any of the regular
|
|
|
968 expressions in this list, @code{display-buffer} handles the buffer
|
|
|
969 specially.
|
|
|
970
|
|
|
971 By default, special display means to give the buffer a dedicated frame.
|
|
|
972
|
|
|
973 If an element is a list, instead of a string, then the @sc{car} of the
|
|
|
974 list is the regular expression, and the rest of the list says how to
|
|
|
975 create the frame. See above, under @code{special-display-buffer-names}.
|
|
|
976 @end defvar
|
|
|
977
|
|
|
978 @defvar special-display-function
|
|
|
979 This variable holds the function to call to display a buffer specially.
|
|
|
980 It receives the buffer as an argument, and should return the window in
|
|
|
981 which it is displayed.
|
|
|
982
|
|
|
983 The default value of this variable is
|
|
|
984 @code{special-display-popup-frame}.
|
|
|
985 @end defvar
|
|
|
986
|
|
|
987 @defun special-display-popup-frame buffer
|
|
|
988 This function makes @var{buffer} visible in a frame of its own. If
|
|
|
989 @var{buffer} is already displayed in a window in some frame, it makes
|
|
|
990 the frame visible and raises it, to use that window. Otherwise, it
|
|
|
991 creates a frame that will be dedicated to @var{buffer}.
|
|
|
992
|
|
|
993 This function uses an existing window displaying @var{buffer} whether or
|
|
|
994 not it is in a frame of its own; but if you set up the above variables
|
|
|
995 in your init file, before @var{buffer} was created, then presumably the
|
|
|
996 window was previously made by this function.
|
|
|
997 @end defun
|
|
|
998
|
|
|
999 @defopt special-display-frame-plist
|
|
|
1000 This variable holds frame properties for
|
|
|
1001 @code{special-display-popup-frame} to use when it creates a frame.
|
|
|
1002 @end defopt
|
|
|
1003
|
|
|
1004 @defvar same-window-buffer-names
|
|
|
1005 A list of buffer names for buffers that should be displayed in the
|
|
|
1006 selected window. If the buffer's name is in this list,
|
|
|
1007 @code{display-buffer} handles the buffer by switching to it in the
|
|
|
1008 selected window.
|
|
|
1009 @end defvar
|
|
|
1010
|
|
|
1011 @defvar same-window-regexps
|
|
|
1012 A list of regular expressions that specify buffers that should be
|
|
|
1013 displayed in the selected window. If the buffer's name matches any of
|
|
|
1014 the regular expressions in this list, @code{display-buffer} handles the
|
|
|
1015 buffer by switching to it in the selected window.
|
|
|
1016 @end defvar
|
|
|
1017
|
|
|
1018 @c Emacs 19 feature
|
|
|
1019 @defvar display-buffer-function
|
|
|
1020 This variable is the most flexible way to customize the behavior of
|
|
|
1021 @code{display-buffer}. If it is non-@code{nil}, it should be a function
|
|
|
1022 that @code{display-buffer} calls to do the work. The function should
|
|
|
1023 accept two arguments, the same two arguments that @code{display-buffer}
|
|
|
1024 received. It should choose or create a window, display the specified
|
|
|
1025 buffer, and then return the window.
|
|
|
1026
|
|
|
1027 This hook takes precedence over all the other options and hooks
|
|
|
1028 described above.
|
|
|
1029 @end defvar
|
|
|
1030
|
|
|
1031 @c Emacs 19 feature
|
|
|
1032 @cindex dedicated window
|
|
|
1033 A window can be marked as ``dedicated'' to its buffer. Then
|
|
|
1034 @code{display-buffer} does not try to use that window.
|
|
|
1035
|
|
|
1036 @defun window-dedicated-p window
|
|
|
1037 This function returns @code{t} if @var{window} is marked as dedicated;
|
|
|
1038 otherwise @code{nil}.
|
|
|
1039 @end defun
|
|
|
1040
|
|
|
1041 @defun set-window-dedicated-p window flag
|
|
|
1042 This function marks @var{window} as dedicated if @var{flag} is
|
|
|
1043 non-@code{nil}, and nondedicated otherwise.
|
|
|
1044 @end defun
|
|
|
1045
|
|
|
1046 @node Window Point
|
|
|
1047 @section Windows and Point
|
|
|
1048 @cindex window position
|
|
|
1049 @cindex window point
|
|
|
1050 @cindex position in window
|
|
|
1051 @cindex point in window
|
|
|
1052
|
|
|
1053 Each window has its own value of point, independent of the value of
|
|
|
1054 point in other windows displaying the same buffer. This makes it useful
|
|
|
1055 to have multiple windows showing one buffer.
|
|
|
1056
|
|
|
1057 @itemize @bullet
|
|
|
1058 @item
|
|
|
1059 The window point is established when a window is first created; it is
|
|
|
1060 initialized from the buffer's point, or from the window point of another
|
|
|
1061 window opened on the buffer if such a window exists.
|
|
|
1062
|
|
|
1063 @item
|
|
|
1064 Selecting a window sets the value of point in its buffer to the window's
|
|
|
1065 value of point. Conversely, deselecting a window sets the window's
|
|
|
1066 value of point from that of the buffer. Thus, when you switch between
|
|
|
1067 windows that display a given buffer, the point value for the selected
|
|
|
1068 window is in effect in the buffer, while the point values for the other
|
|
|
1069 windows are stored in those windows.
|
|
|
1070
|
|
|
1071 @item
|
|
|
1072 As long as the selected window displays the current buffer, the window's
|
|
|
1073 point and the buffer's point always move together; they remain equal.
|
|
|
1074
|
|
|
1075 @item
|
|
|
1076 @xref{Positions}, for more details on buffer positions.
|
|
|
1077 @end itemize
|
|
|
1078
|
|
|
1079 As far as the user is concerned, point is where the cursor is, and
|
|
|
1080 when the user switches to another buffer, the cursor jumps to the
|
|
|
1081 position of point in that buffer.
|
|
|
1082
|
|
444
|
1083 @defun window-point &optional window
|
|
428
|
1084 This function returns the current position of point in @var{window}.
|
|
442
|
1085 For a non-selected window, this is the value point would have (in that
|
|
428
|
1086 window's buffer) if that window were selected.
|
|
|
1087
|
|
|
1088 When @var{window} is the selected window and its buffer is also the
|
|
444
|
1089 current buffer, the value returned is the same as the value of point in
|
|
|
1090 that buffer.
|
|
428
|
1091
|
|
|
1092 Strictly speaking, it would be more correct to return the
|
|
|
1093 ``top-level'' value of point, outside of any @code{save-excursion}
|
|
|
1094 forms. But that value is hard to find.
|
|
|
1095 @end defun
|
|
|
1096
|
|
|
1097 @defun set-window-point window position
|
|
|
1098 This function positions point in @var{window} at position
|
|
|
1099 @var{position} in @var{window}'s buffer.
|
|
|
1100 @end defun
|
|
|
1101
|
|
|
1102 @node Window Start
|
|
|
1103 @section The Window Start Position
|
|
|
1104
|
|
|
1105 Each window contains a marker used to keep track of a buffer position
|
|
|
1106 that specifies where in the buffer display should start. This position
|
|
|
1107 is called the @dfn{display-start} position of the window (or just the
|
|
|
1108 @dfn{start}). The character after this position is the one that appears
|
|
|
1109 at the upper left corner of the window. It is usually, but not
|
|
|
1110 inevitably, at the beginning of a text line.
|
|
|
1111
|
|
|
1112 @defun window-start &optional window
|
|
|
1113 @cindex window top line
|
|
|
1114 This function returns the display-start position of window
|
|
|
1115 @var{window}. If @var{window} is @code{nil}, the selected window is
|
|
444
|
1116 used. For example,
|
|
428
|
1117
|
|
|
1118 @example
|
|
|
1119 @group
|
|
|
1120 (window-start)
|
|
|
1121 @result{} 7058
|
|
|
1122 @end group
|
|
|
1123 @end example
|
|
|
1124
|
|
|
1125 When you create a window, or display a different buffer in it, the
|
|
|
1126 display-start position is set to a display-start position recently used
|
|
|
1127 for the same buffer, or 1 if the buffer doesn't have any.
|
|
|
1128
|
|
|
1129 For a realistic example, see the description of @code{count-lines} in
|
|
|
1130 @ref{Text Lines}.
|
|
|
1131 @end defun
|
|
|
1132
|
|
444
|
1133 @defun window-end &optional window guarantee
|
|
428
|
1134 This function returns the position of the end of the display in window
|
|
|
1135 @var{window}. If @var{window} is @code{nil}, the selected window is
|
|
|
1136 used.
|
|
|
1137
|
|
444
|
1138 Simply changing the buffer text or setting @code{window-start} does not
|
|
|
1139 update the value that @code{window-end} returns. The value is updated
|
|
|
1140 only when Emacs redisplays and redisplay actually finishes.
|
|
428
|
1141
|
|
|
1142 If the last redisplay of @var{window} was preempted, and did not finish,
|
|
|
1143 Emacs does not know the position of the end of display in that window.
|
|
|
1144 In that case, this function returns a value that is not correct. In a
|
|
|
1145 future version, @code{window-end} will return @code{nil} in that case.
|
|
444
|
1146
|
|
|
1147 If optional arg @var{guarantee} is non-@code{nil}, the return value is
|
|
|
1148 guaranteed to be the same as @code{window-end} would return at the end
|
|
|
1149 of the next full redisplay assuming nothing else changes in the
|
|
|
1150 meantime. This function is potentially much slower with this flag set.
|
|
|
1151
|
|
428
|
1152 @ignore
|
|
|
1153 in that case, this function returns @code{nil}. You can compute where
|
|
|
1154 the end of the window @emph{would} have been, if redisplay had finished,
|
|
|
1155 like this:
|
|
|
1156
|
|
|
1157 @example
|
|
|
1158 (save-excursion
|
|
|
1159 (goto-char (window-start window))
|
|
|
1160 (vertical-motion (1- (window-height window))
|
|
|
1161 window)
|
|
|
1162 (point))
|
|
|
1163 @end example
|
|
|
1164 @end ignore
|
|
|
1165 @end defun
|
|
|
1166
|
|
|
1167 @defun set-window-start window position &optional noforce
|
|
|
1168 This function sets the display-start position of @var{window} to
|
|
|
1169 @var{position} in @var{window}'s buffer. It returns @var{position}.
|
|
|
1170
|
|
|
1171 The display routines insist that the position of point be visible when a
|
|
|
1172 buffer is displayed. Normally, they change the display-start position
|
|
|
1173 (that is, scroll the window) whenever necessary to make point visible.
|
|
|
1174 However, if you specify the start position with this function using
|
|
|
1175 @code{nil} for @var{noforce}, it means you want display to start at
|
|
|
1176 @var{position} even if that would put the location of point off the
|
|
|
1177 screen. If this does place point off screen, the display routines move
|
|
|
1178 point to the left margin on the middle line in the window.
|
|
|
1179
|
|
|
1180 For example, if point @w{is 1} and you set the start of the window @w{to
|
|
|
1181 2}, then point would be ``above'' the top of the window. The display
|
|
|
1182 routines will automatically move point if it is still 1 when redisplay
|
|
|
1183 occurs. Here is an example:
|
|
|
1184
|
|
|
1185 @example
|
|
|
1186 @group
|
|
|
1187 ;; @r{Here is what @samp{foo} looks like before executing}
|
|
|
1188 ;; @r{the @code{set-window-start} expression.}
|
|
|
1189 @end group
|
|
|
1190
|
|
|
1191 @group
|
|
|
1192 ---------- Buffer: foo ----------
|
|
|
1193 @point{}This is the contents of buffer foo.
|
|
|
1194 2
|
|
|
1195 3
|
|
|
1196 4
|
|
|
1197 5
|
|
|
1198 6
|
|
|
1199 ---------- Buffer: foo ----------
|
|
|
1200 @end group
|
|
|
1201
|
|
|
1202 @group
|
|
|
1203 (set-window-start
|
|
|
1204 (selected-window)
|
|
|
1205 (1+ (window-start)))
|
|
|
1206 @result{} 2
|
|
|
1207 @end group
|
|
|
1208
|
|
|
1209 @group
|
|
|
1210 ;; @r{Here is what @samp{foo} looks like after executing}
|
|
|
1211 ;; @r{the @code{set-window-start} expression.}
|
|
|
1212 ---------- Buffer: foo ----------
|
|
|
1213 his is the contents of buffer foo.
|
|
|
1214 2
|
|
|
1215 3
|
|
|
1216 @point{}4
|
|
|
1217 5
|
|
|
1218 6
|
|
|
1219 ---------- Buffer: foo ----------
|
|
|
1220 @end group
|
|
|
1221 @end example
|
|
|
1222
|
|
|
1223 If @var{noforce} is non-@code{nil}, and @var{position} would place point
|
|
|
1224 off screen at the next redisplay, then redisplay computes a new window-start
|
|
|
1225 position that works well with point, and thus @var{position} is not used.
|
|
|
1226 @end defun
|
|
|
1227
|
|
|
1228 @defun pos-visible-in-window-p &optional position window
|
|
|
1229 This function returns @code{t} if @var{position} is within the range
|
|
|
1230 of text currently visible on the screen in @var{window}. It returns
|
|
|
1231 @code{nil} if @var{position} is scrolled vertically out of view. The
|
|
|
1232 argument @var{position} defaults to the current position of point;
|
|
|
1233 @var{window}, to the selected window. Here is an example:
|
|
|
1234
|
|
|
1235 @example
|
|
|
1236 @group
|
|
|
1237 (or (pos-visible-in-window-p
|
|
|
1238 (point) (selected-window))
|
|
|
1239 (recenter 0))
|
|
|
1240 @end group
|
|
|
1241 @end example
|
|
|
1242
|
|
|
1243 The @code{pos-visible-in-window-p} function considers only vertical
|
|
|
1244 scrolling. If @var{position} is out of view only because @var{window}
|
|
|
1245 has been scrolled horizontally, @code{pos-visible-in-window-p} returns
|
|
|
1246 @code{t}. @xref{Horizontal Scrolling}.
|
|
|
1247 @end defun
|
|
|
1248
|
|
|
1249 @node Vertical Scrolling
|
|
|
1250 @section Vertical Scrolling
|
|
|
1251 @cindex vertical scrolling
|
|
|
1252 @cindex scrolling vertically
|
|
|
1253
|
|
|
1254 Vertical scrolling means moving the text up or down in a window. It
|
|
|
1255 works by changing the value of the window's display-start location. It
|
|
|
1256 may also change the value of @code{window-point} to keep it on the
|
|
|
1257 screen.
|
|
|
1258
|
|
|
1259 In the commands @code{scroll-up} and @code{scroll-down}, the directions
|
|
|
1260 ``up'' and ``down'' refer to the motion of the text in the buffer at which
|
|
|
1261 you are looking through the window. Imagine that the text is
|
|
|
1262 written on a long roll of paper and that the scrolling commands move the
|
|
|
1263 paper up and down. Thus, if you are looking at text in the middle of a
|
|
|
1264 buffer and repeatedly call @code{scroll-down}, you will eventually see
|
|
|
1265 the beginning of the buffer.
|
|
|
1266
|
|
|
1267 Some people have urged that the opposite convention be used: they
|
|
|
1268 imagine that the window moves over text that remains in place. Then
|
|
|
1269 ``down'' commands would take you to the end of the buffer. This view is
|
|
|
1270 more consistent with the actual relationship between windows and the
|
|
|
1271 text in the buffer, but it is less like what the user sees. The
|
|
|
1272 position of a window on the terminal does not move, and short scrolling
|
|
|
1273 commands clearly move the text up or down on the screen. We have chosen
|
|
|
1274 names that fit the user's point of view.
|
|
|
1275
|
|
|
1276 The scrolling functions (aside from @code{scroll-other-window}) have
|
|
|
1277 unpredictable results if the current buffer is different from the buffer
|
|
|
1278 that is displayed in the selected window. @xref{Current Buffer}.
|
|
|
1279
|
|
444
|
1280 @deffn Command scroll-up &optional lines
|
|
428
|
1281 This function scrolls the text in the selected window upward
|
|
444
|
1282 @var{lines} lines. If @var{lines} is negative, scrolling is actually
|
|
428
|
1283 downward.
|
|
|
1284
|
|
444
|
1285 If @var{lines} is @code{nil} (or omitted), then the length of scroll
|
|
428
|
1286 is @code{next-screen-context-lines} lines less than the usable height of
|
|
|
1287 the window (not counting its modeline).
|
|
|
1288
|
|
|
1289 @code{scroll-up} returns @code{nil}.
|
|
|
1290 @end deffn
|
|
|
1291
|
|
444
|
1292 @deffn Command scroll-down &optional lines
|
|
428
|
1293 This function scrolls the text in the selected window downward
|
|
444
|
1294 @var{lines} lines. If @var{lines} is negative, scrolling is actually
|
|
428
|
1295 upward.
|
|
|
1296
|
|
444
|
1297 If @var{lines} is omitted or @code{nil}, then the length of the scroll
|
|
428
|
1298 is @code{next-screen-context-lines} lines less than the usable height of
|
|
|
1299 the window (not counting its mode line).
|
|
|
1300
|
|
|
1301 @code{scroll-down} returns @code{nil}.
|
|
|
1302 @end deffn
|
|
|
1303
|
|
444
|
1304 @deffn Command scroll-other-window &optional lines
|
|
|
1305 This function scrolls the text in another window upward @var{lines}
|
|
|
1306 lines. Negative values of @var{lines}, or @code{nil}, are handled
|
|
428
|
1307 as in @code{scroll-up}.
|
|
|
1308
|
|
|
1309 You can specify a buffer to scroll with the variable
|
|
|
1310 @code{other-window-scroll-buffer}. When the selected window is the
|
|
|
1311 minibuffer, the next window is normally the one at the top left corner.
|
|
|
1312 You can specify a different window to scroll with the variable
|
|
|
1313 @code{minibuffer-scroll-window}. This variable has no effect when any
|
|
|
1314 other window is selected. @xref{Minibuffer Misc}.
|
|
|
1315
|
|
|
1316 When the minibuffer is active, it is the next window if the selected
|
|
|
1317 window is the one at the bottom right corner. In this case,
|
|
|
1318 @code{scroll-other-window} attempts to scroll the minibuffer. If the
|
|
|
1319 minibuffer contains just one line, it has nowhere to scroll to, so the
|
|
|
1320 line reappears after the echo area momentarily displays the message
|
|
|
1321 ``Beginning of buffer''.
|
|
|
1322 @end deffn
|
|
|
1323
|
|
|
1324 @c Emacs 19 feature
|
|
|
1325 @defvar other-window-scroll-buffer
|
|
|
1326 If this variable is non-@code{nil}, it tells @code{scroll-other-window}
|
|
|
1327 which buffer to scroll.
|
|
|
1328 @end defvar
|
|
|
1329
|
|
|
1330 @defopt scroll-step
|
|
|
1331 This variable controls how scrolling is done automatically when point
|
|
|
1332 moves off the screen. If the value is zero, then redisplay scrolls the
|
|
|
1333 text to center point vertically in the window. If the value is a
|
|
|
1334 positive integer @var{n}, then redisplay brings point back on screen by
|
|
|
1335 scrolling @var{n} lines in either direction, if possible; otherwise, it
|
|
|
1336 centers point. The default value is zero.
|
|
|
1337 @end defopt
|
|
|
1338
|
|
|
1339 @defopt scroll-conservatively
|
|
|
1340 This variable controls how many lines Emacs tries to scroll before
|
|
|
1341 recentering. If you set it to a small number, then when you move point
|
|
|
1342 a short distance off the screen, XEmacs will scroll the screen just far
|
|
|
1343 enough to bring point back on screen, provided that does not exceed
|
|
|
1344 @code{scroll-conservatively} lines. This variable overrides the
|
|
|
1345 redisplay preemption.
|
|
|
1346 @end defopt
|
|
|
1347
|
|
|
1348 @defopt next-screen-context-lines
|
|
|
1349 The value of this variable is the number of lines of continuity to
|
|
|
1350 retain when scrolling by full screens. For example, @code{scroll-up}
|
|
|
1351 with an argument of @code{nil} scrolls so that this many lines at the
|
|
|
1352 bottom of the window appear instead at the top. The default value is
|
|
|
1353 @code{2}.
|
|
|
1354 @end defopt
|
|
|
1355
|
|
444
|
1356 @deffn Command recenter &optional location window
|
|
428
|
1357 @cindex centering point
|
|
444
|
1358 This function scrolls @var{window} (which defaults to the selected
|
|
|
1359 window) to put the text where point is located at a specified vertical
|
|
|
1360 position within the window.
|
|
428
|
1361
|
|
444
|
1362 If @var{location} is a nonnegative number, it puts the line containing
|
|
|
1363 point @var{location} lines down from the top of the window. If @var{location}
|
|
428
|
1364 is a negative number, then it counts upward from the bottom of the
|
|
|
1365 window, so that @minus{}1 stands for the last usable line in the window.
|
|
444
|
1366 If @var{location} is a non-@code{nil} list, then it stands for the line in
|
|
428
|
1367 the middle of the window.
|
|
|
1368
|
|
444
|
1369 If @var{location} is @code{nil}, @code{recenter} puts the line containing
|
|
428
|
1370 point in the middle of the window, then clears and redisplays the entire
|
|
|
1371 selected frame.
|
|
|
1372
|
|
444
|
1373 When @code{recenter} is called interactively, @var{location} is the raw
|
|
428
|
1374 prefix argument. Thus, typing @kbd{C-u} as the prefix sets the
|
|
444
|
1375 @var{location} to a non-@code{nil} list, while typing @kbd{C-u 4} sets
|
|
|
1376 @var{location} to 4, which positions the current line four lines from the
|
|
428
|
1377 top.
|
|
|
1378
|
|
|
1379 With an argument of zero, @code{recenter} positions the current line at
|
|
|
1380 the top of the window. This action is so handy that some people make a
|
|
|
1381 separate key binding to do this. For example,
|
|
|
1382
|
|
|
1383 @example
|
|
|
1384 @group
|
|
|
1385 (defun line-to-top-of-window ()
|
|
|
1386 "Scroll current line to top of window.
|
|
|
1387 Replaces three keystroke sequence C-u 0 C-l."
|
|
444
|
1388 (interactive)
|
|
428
|
1389 (recenter 0))
|
|
|
1390
|
|
444
|
1391 (global-set-key [kp-multiply] 'line-to-top-of-window)
|
|
428
|
1392 @end group
|
|
|
1393 @end example
|
|
|
1394 @end deffn
|
|
|
1395
|
|
|
1396 @node Horizontal Scrolling
|
|
|
1397 @section Horizontal Scrolling
|
|
|
1398 @cindex horizontal scrolling
|
|
|
1399
|
|
|
1400 Because we read English first from top to bottom and second from left
|
|
|
1401 to right, horizontal scrolling is not like vertical scrolling. Vertical
|
|
|
1402 scrolling involves selection of a contiguous portion of text to display.
|
|
|
1403 Horizontal scrolling causes part of each line to go off screen. The
|
|
|
1404 amount of horizontal scrolling is therefore specified as a number of
|
|
|
1405 columns rather than as a position in the buffer. It has nothing to do
|
|
|
1406 with the display-start position returned by @code{window-start}.
|
|
|
1407
|
|
|
1408 Usually, no horizontal scrolling is in effect; then the leftmost
|
|
|
1409 column is at the left edge of the window. In this state, scrolling to
|
|
|
1410 the right is meaningless, since there is no data to the left of the
|
|
|
1411 screen to be revealed by it; so this is not allowed. Scrolling to the
|
|
|
1412 left is allowed; it scrolls the first columns of text off the edge of
|
|
|
1413 the window and can reveal additional columns on the right that were
|
|
|
1414 truncated before. Once a window has a nonzero amount of leftward
|
|
|
1415 horizontal scrolling, you can scroll it back to the right, but only so
|
|
|
1416 far as to reduce the net horizontal scroll to zero. There is no limit
|
|
|
1417 to how far left you can scroll, but eventually all the text will
|
|
|
1418 disappear off the left edge.
|
|
|
1419
|
|
444
|
1420 @deffn Command scroll-left &optional count
|
|
428
|
1421 This function scrolls the selected window @var{count} columns to the
|
|
|
1422 left (or to the right if @var{count} is negative). The return value is
|
|
|
1423 the total amount of leftward horizontal scrolling in effect after the
|
|
|
1424 change---just like the value returned by @code{window-hscroll} (below).
|
|
|
1425 @end deffn
|
|
|
1426
|
|
444
|
1427 @deffn Command scroll-right &optional count
|
|
428
|
1428 This function scrolls the selected window @var{count} columns to the
|
|
|
1429 right (or to the left if @var{count} is negative). The return value is
|
|
|
1430 the total amount of leftward horizontal scrolling in effect after the
|
|
|
1431 change---just like the value returned by @code{window-hscroll} (below).
|
|
|
1432
|
|
|
1433 Once you scroll a window as far right as it can go, back to its normal
|
|
|
1434 position where the total leftward scrolling is zero, attempts to scroll
|
|
|
1435 any farther right have no effect.
|
|
|
1436 @end deffn
|
|
|
1437
|
|
|
1438 @defun window-hscroll &optional window
|
|
|
1439 This function returns the total leftward horizontal scrolling of
|
|
|
1440 @var{window}---the number of columns by which the text in @var{window}
|
|
|
1441 is scrolled left past the left margin.
|
|
|
1442
|
|
|
1443 The value is never negative. It is zero when no horizontal scrolling
|
|
|
1444 has been done in @var{window} (which is usually the case).
|
|
|
1445
|
|
|
1446 If @var{window} is @code{nil}, the selected window is used.
|
|
|
1447
|
|
|
1448 @example
|
|
|
1449 @group
|
|
|
1450 (window-hscroll)
|
|
|
1451 @result{} 0
|
|
|
1452 @end group
|
|
|
1453 @group
|
|
|
1454 (scroll-left 5)
|
|
|
1455 @result{} 5
|
|
|
1456 @end group
|
|
|
1457 @group
|
|
|
1458 (window-hscroll)
|
|
|
1459 @result{} 5
|
|
|
1460 @end group
|
|
|
1461 @end example
|
|
|
1462 @end defun
|
|
|
1463
|
|
|
1464 @defun set-window-hscroll window columns
|
|
|
1465 This function sets the number of columns from the left margin that
|
|
|
1466 @var{window} is scrolled to the value of @var{columns}. The argument
|
|
|
1467 @var{columns} should be zero or positive; if not, it is taken as zero.
|
|
|
1468
|
|
|
1469 The value returned is @var{columns}.
|
|
|
1470
|
|
|
1471 @example
|
|
|
1472 @group
|
|
|
1473 (set-window-hscroll (selected-window) 10)
|
|
|
1474 @result{} 10
|
|
|
1475 @end group
|
|
|
1476 @end example
|
|
|
1477 @end defun
|
|
|
1478
|
|
|
1479 Here is how you can determine whether a given position @var{position}
|
|
|
1480 is off the screen due to horizontal scrolling:
|
|
|
1481
|
|
|
1482 @example
|
|
|
1483 @group
|
|
|
1484 (defun hscroll-on-screen (window position)
|
|
444
|
1485 (save-excursion
|
|
428
|
1486 (goto-char position)
|
|
444
|
1487 (and
|
|
428
|
1488 (>= (- (current-column) (window-hscroll window)) 0)
|
|
|
1489 (< (- (current-column) (window-hscroll window))
|
|
|
1490 (window-width window)))))
|
|
|
1491 @end group
|
|
|
1492 @end example
|
|
|
1493 @node Size of Window
|
|
|
1494 @section The Size of a Window
|
|
|
1495 @cindex window size
|
|
|
1496 @cindex size of window
|
|
|
1497
|
|
|
1498 An Emacs window is rectangular, and its size information consists of
|
|
|
1499 the height (in lines or pixels) and the width (in character positions
|
|
|
1500 or pixels). The modeline is included in the height. The pixel
|
|
|
1501 width and height values include scrollbars and margins, while the
|
|
|
1502 line/character-position values do not.
|
|
|
1503
|
|
|
1504 Note that the height in lines, and the width in characters, are
|
|
|
1505 determined by dividing the corresponding pixel value by the height or
|
|
|
1506 width of the default font in that window (if this is a variable-width
|
|
|
1507 font, the average width is used). The resulting values may or may not
|
|
|
1508 represent the actual number of lines in the window, or the actual number
|
|
|
1509 of character positions in any particular line, esp. if there are pixmaps
|
|
|
1510 or various different fonts in the window.
|
|
|
1511
|
|
|
1512 The following functions return size information about a window:
|
|
|
1513
|
|
|
1514 @defun window-height &optional window
|
|
|
1515 This function returns the number of lines in @var{window}, including
|
|
|
1516 its modeline but not including the horizontal scrollbar, if any (this
|
|
|
1517 is different from @code{window-pixel-height}). If @var{window} is
|
|
|
1518 @code{nil}, the function uses the selected window.
|
|
|
1519
|
|
|
1520 @example
|
|
|
1521 @group
|
|
|
1522 (window-height)
|
|
|
1523 @result{} 40
|
|
|
1524 @end group
|
|
|
1525 @group
|
|
|
1526 (split-window-vertically)
|
|
|
1527 @result{} #<window on "windows.texi" 0x679b>
|
|
|
1528 @end group
|
|
|
1529 @group
|
|
|
1530 (window-height)
|
|
|
1531 @result{} 20
|
|
|
1532 @end group
|
|
|
1533 @end example
|
|
|
1534 @end defun
|
|
|
1535
|
|
|
1536 @defun window-width &optional window
|
|
|
1537 This function returns the number of columns in @var{window}, not
|
|
|
1538 including any left margin, right margin, or vertical scrollbar (this is
|
|
|
1539 different from @code{window-pixel-width}). If @var{window} is
|
|
|
1540 @code{nil}, the function uses the selected window.
|
|
|
1541
|
|
|
1542 @example
|
|
|
1543 @group
|
|
|
1544 (window-width)
|
|
|
1545 @result{} 80
|
|
|
1546 @end group
|
|
|
1547 @group
|
|
|
1548 (window-height)
|
|
|
1549 @result{} 40
|
|
|
1550 @end group
|
|
|
1551 @group
|
|
|
1552 (split-window-horizontally)
|
|
|
1553 @result{} #<window on "windows.texi" 0x7538>
|
|
|
1554 @end group
|
|
|
1555 @group
|
|
|
1556 (window-width)
|
|
|
1557 @result{} 39
|
|
|
1558 @end group
|
|
|
1559 @end example
|
|
|
1560 @end defun
|
|
|
1561
|
|
|
1562 Note that after splitting the window into two side-by-side windows,
|
|
|
1563 the width of each window is less the half the width of the original
|
|
|
1564 window because a vertical scrollbar appeared between the windows,
|
|
|
1565 occupying two columns worth of space. Also, the height shrunk by
|
|
|
1566 one because horizontal scrollbars appeared that weren't there
|
|
|
1567 before. (Horizontal scrollbars appear only when lines are
|
|
|
1568 truncated, not when they wrap. This is usually the case for
|
|
|
1569 horizontally split windows but not for full-frame windows. You
|
|
|
1570 can change this using the variables @code{truncate-lines} and
|
|
|
1571 @code{truncate-partial-width-windows}.)
|
|
|
1572
|
|
|
1573 @defun window-pixel-height &optional window
|
|
|
1574 This function returns the height of @var{window} in pixels, including
|
|
|
1575 its modeline and horizontal scrollbar, if any. If @var{window} is
|
|
|
1576 @code{nil}, the function uses the selected window.
|
|
|
1577
|
|
|
1578 @example
|
|
|
1579 @group
|
|
|
1580 (window-pixel-height)
|
|
|
1581 @result{} 600
|
|
|
1582 @end group
|
|
|
1583 @group
|
|
|
1584 (split-window-vertically)
|
|
|
1585 @result{} #<window on "windows.texi" 0x68a6>
|
|
|
1586 @end group
|
|
|
1587 @group
|
|
|
1588 (window-pixel-height)
|
|
|
1589 @result{} 300
|
|
|
1590 @end group
|
|
|
1591 @end example
|
|
|
1592 @end defun
|
|
|
1593
|
|
|
1594 @defun window-pixel-width &optional window
|
|
|
1595 This function returns the width of @var{window} in pixels, including
|
|
|
1596 any left margin, right margin, or vertical scrollbar that may be
|
|
|
1597 displayed alongside it. If @var{window} is @code{nil}, the function
|
|
|
1598 uses the selected window.
|
|
|
1599
|
|
|
1600 @example
|
|
|
1601 @group
|
|
|
1602 (window-pixel-width)
|
|
|
1603 @result{} 735
|
|
|
1604 @end group
|
|
|
1605 @group
|
|
|
1606 (window-pixel-height)
|
|
|
1607 @result{} 600
|
|
|
1608 @end group
|
|
|
1609 @group
|
|
|
1610 (split-window-horizontally)
|
|
|
1611 @result{} #<window on "windows.texi" 0x7538>
|
|
|
1612 @end group
|
|
|
1613 @group
|
|
|
1614 (window-pixel-width)
|
|
|
1615 @result{} 367
|
|
|
1616 @end group
|
|
|
1617 @group
|
|
|
1618 (window-pixel-height)
|
|
|
1619 @result{} 600
|
|
|
1620 @end group
|
|
|
1621 @end example
|
|
|
1622 @end defun
|
|
|
1623
|
|
|
1624 @defun window-text-area-pixel-height &optional window
|
|
|
1625 This function returns the height in pixels of the text displaying
|
|
|
1626 portion of @var{window}, which defaults to the selected window. Unlike
|
|
|
1627 @code{window-pixel-height}, the space occupied by the modeline and
|
|
|
1628 horizontal scrollbar, if any, is not counted.
|
|
|
1629 @end defun
|
|
|
1630
|
|
|
1631 @defun window-text-area-pixel-width &optional window
|
|
|
1632 This function returns the width in pixels of the text displaying
|
|
|
1633 portion of @var{window}, which defaults to the selected window. Unlike
|
|
|
1634 @code{window-pixel-width}, the space occupied by the vertical scrollbar
|
|
|
1635 and divider, if any, is not counted.
|
|
|
1636 @end defun
|
|
|
1637
|
|
|
1638 @defun window-displayed-text-pixel-height &optional window noclipped
|
|
|
1639 This function returns the height in pixels of the text displayed in
|
|
|
1640 @var{window}, which defaults to the selected window. Unlike
|
|
|
1641 @code{window-text-area-pixel-height}, any blank space below the
|
|
444
|
1642 end of the buffer is not included. If optional argument @var{noclipped}
|
|
428
|
1643 is non-@code{nil}, any space occupied by clipped lines will not be
|
|
|
1644 included.
|
|
|
1645 @end defun
|
|
|
1646
|
|
|
1647 @node Position of Window
|
|
|
1648 @section The Position of a Window
|
|
|
1649 @cindex window position
|
|
|
1650 @cindex position of window
|
|
|
1651
|
|
|
1652 XEmacs provides functions to determine the absolute location of windows
|
|
|
1653 within a frame, and the relative location of a window in comparison to
|
|
|
1654 other windows in the same frame.
|
|
|
1655
|
|
|
1656 @defun window-pixel-edges &optional window
|
|
|
1657 This function returns a list of the pixel edge coordinates of
|
|
|
1658 @var{window}. If @var{window} is @code{nil}, the selected window is
|
|
|
1659 used.
|
|
|
1660
|
|
|
1661 The order of the list is @code{(@var{left} @var{top} @var{right}
|
|
|
1662 @var{bottom})}, all elements relative to 0, 0 at the top left corner of
|
|
444
|
1663 @var{window}'s frame. The element @var{right} of the value is one more
|
|
|
1664 than the rightmost pixel used by @var{window} (including any left
|
|
|
1665 margin, right margin, or vertical scrollbar displayed alongside it), and
|
|
428
|
1666 @var{bottom} is one more than the bottommost pixel used by @var{window}
|
|
444
|
1667 (including any modeline or horizontal scrollbar displayed above or below
|
|
|
1668 it). The frame area does not include any frame menubars, toolbars, or
|
|
|
1669 gutters that may be displayed; thus, for example, if there is only one
|
|
|
1670 window on the frame, the values for @var{left} and @var{top} will always
|
|
|
1671 be 0.
|
|
428
|
1672
|
|
|
1673 If @var{window} is at the upper left corner of its frame, @var{right}
|
|
|
1674 and @var{bottom} are the same as the values returned by
|
|
|
1675 @code{(window-pixel-width)} and @code{(window-pixel-height)}
|
|
444
|
1676 respectively, and @var{left} and @var{top} are zero.
|
|
428
|
1677 @end defun
|
|
|
1678
|
|
|
1679 There is no longer a function @code{window-edges} because it does not
|
|
|
1680 make sense in a world with variable-width and variable-height lines,
|
|
|
1681 as are allowed in XEmacs.
|
|
|
1682
|
|
|
1683 @defun window-highest-p window
|
|
|
1684 This function returns non-@code{nil} if @var{window} is along the
|
|
|
1685 top of its frame.
|
|
|
1686 @end defun
|
|
|
1687
|
|
|
1688 @defun window-lowest-p window
|
|
|
1689 This function returns non-@code{nil} if @var{window} is along the
|
|
|
1690 bottom of its frame.
|
|
|
1691 @end defun
|
|
|
1692
|
|
|
1693 @defun window-text-area-pixel-edges &optional window
|
|
|
1694 This function allows one to determine the location of the
|
|
|
1695 text-displaying portion of @var{window}, which defaults to the selected
|
|
|
1696 window, with respect to the top left corner of the window. It returns
|
|
|
1697 a list of integer pixel positions @code{(left top right bottom)}, all
|
|
|
1698 relative to @code{(0,0)} at the top left corner of the window.
|
|
|
1699 @end defun
|
|
|
1700
|
|
|
1701 @node Resizing Windows
|
|
|
1702 @section Changing the Size of a Window
|
|
|
1703 @cindex window resizing
|
|
|
1704 @cindex changing window size
|
|
|
1705 @cindex window size, changing
|
|
|
1706
|
|
|
1707 The window size functions fall into two classes: high-level commands
|
|
|
1708 that change the size of windows and low-level functions that access
|
|
|
1709 window size. XEmacs does not permit overlapping windows or gaps between
|
|
|
1710 windows, so resizing one window affects other windows.
|
|
|
1711
|
|
444
|
1712 @deffn Command enlarge-window count &optional horizontal window
|
|
|
1713 This function makes the selected window @var{count} lines taller,
|
|
428
|
1714 stealing lines from neighboring windows. It takes the lines from one
|
|
|
1715 window at a time until that window is used up, then takes from another.
|
|
|
1716 If a window from which lines are stolen shrinks below
|
|
|
1717 @code{window-min-height} lines, that window disappears.
|
|
|
1718
|
|
|
1719 If @var{horizontal} is non-@code{nil}, this function makes
|
|
444
|
1720 @var{window} wider by @var{count} columns, stealing columns instead of
|
|
428
|
1721 lines. If a window from which columns are stolen shrinks below
|
|
|
1722 @code{window-min-width} columns, that window disappears.
|
|
|
1723
|
|
|
1724 If the requested size would exceed that of the window's frame, then the
|
|
|
1725 function makes the window occupy the entire height (or width) of the
|
|
|
1726 frame.
|
|
|
1727
|
|
444
|
1728 If @var{count} is negative, this function shrinks the window by
|
|
|
1729 @minus{}@var{count} lines or columns. If that makes the window smaller
|
|
428
|
1730 than the minimum size (@code{window-min-height} and
|
|
|
1731 @code{window-min-width}), @code{enlarge-window} deletes the window.
|
|
|
1732
|
|
|
1733 If @var{window} is non-@code{nil}, it specifies a window to change
|
|
|
1734 instead of the selected window.
|
|
|
1735
|
|
444
|
1736 @code{enlarge-window} returns @code{nil}.
|
|
428
|
1737 @end deffn
|
|
|
1738
|
|
|
1739 @deffn Command enlarge-window-horizontally columns
|
|
|
1740 This function makes the selected window @var{columns} wider.
|
|
|
1741 It could be defined as follows:
|
|
|
1742
|
|
|
1743 @example
|
|
|
1744 @group
|
|
|
1745 (defun enlarge-window-horizontally (columns)
|
|
|
1746 (enlarge-window columns t))
|
|
|
1747 @end group
|
|
|
1748 @end example
|
|
|
1749 @end deffn
|
|
|
1750
|
|
|
1751 @deffn Command enlarge-window-pixels count &optional side window
|
|
444
|
1752 This function makes the selected window @var{count} pixels larger.
|
|
|
1753 When called from Lisp, optional second argument @var{side}
|
|
|
1754 non-@code{nil} means to grow sideways @var{count} pixels, and optional
|
|
|
1755 third argument @var{window} specifies the window to change instead of
|
|
|
1756 the selected window.
|
|
428
|
1757 @end deffn
|
|
|
1758
|
|
444
|
1759 @deffn Command shrink-window count &optional horizontal window
|
|
428
|
1760 This function is like @code{enlarge-window} but negates the argument
|
|
444
|
1761 @var{count}, making the selected window smaller by giving lines (or
|
|
428
|
1762 columns) to the other windows. If the window shrinks below
|
|
|
1763 @code{window-min-height} or @code{window-min-width}, then it disappears.
|
|
|
1764
|
|
444
|
1765 If @var{count} is negative, the window is enlarged by @minus{}@var{count}
|
|
428
|
1766 lines or columns.
|
|
|
1767
|
|
|
1768 If @var{window} is non-@code{nil}, it specifies a window to change
|
|
|
1769 instead of the selected window.
|
|
|
1770 @end deffn
|
|
|
1771
|
|
|
1772 @deffn Command shrink-window-horizontally columns
|
|
|
1773 This function makes the selected window @var{columns} narrower.
|
|
|
1774 It could be defined as follows:
|
|
|
1775
|
|
|
1776 @example
|
|
|
1777 @group
|
|
|
1778 (defun shrink-window-horizontally (columns)
|
|
|
1779 (shrink-window columns t))
|
|
|
1780 @end group
|
|
|
1781 @end example
|
|
|
1782 @end deffn
|
|
|
1783
|
|
|
1784 @deffn Command shrink-window-pixels count &optional side window
|
|
|
1785 This function makes the selected window @var{count} pixels smaller.
|
|
|
1786 When called from Lisp, optional second argument @var{side}
|
|
|
1787 non-@code{nil} means to shrink sideways @var{count} pixels, and optional
|
|
|
1788 third argument @var{window} specifies the window to change instead of
|
|
|
1789 the selected window.
|
|
|
1790 @end deffn
|
|
|
1791
|
|
|
1792 @cindex minimum window size
|
|
|
1793 The following two variables constrain the window-size-changing
|
|
|
1794 functions to a minimum height and width.
|
|
|
1795
|
|
|
1796 @defopt window-min-height
|
|
|
1797 The value of this variable determines how short a window may become
|
|
|
1798 before it is automatically deleted. Making a window smaller than
|
|
|
1799 @code{window-min-height} automatically deletes it, and no window may be
|
|
|
1800 created shorter than this. The absolute minimum height is two (allowing
|
|
|
1801 one line for the mode line, and one line for the buffer display).
|
|
|
1802 Actions that change window sizes reset this variable to two if it is
|
|
|
1803 less than two. The default value is 4.
|
|
|
1804 @end defopt
|
|
|
1805
|
|
|
1806 @defopt window-min-width
|
|
|
1807 The value of this variable determines how narrow a window may become
|
|
|
1808 before it automatically deleted. Making a window smaller than
|
|
|
1809 @code{window-min-width} automatically deletes it, and no window may be
|
|
|
1810 created narrower than this. The absolute minimum width is one; any
|
|
|
1811 value below that is ignored. The default value is 10.
|
|
|
1812 @end defopt
|
|
|
1813
|
|
|
1814 @c This is not yet implemented. Why is it "documented"?
|
|
|
1815 @defvar window-size-change-functions
|
|
|
1816 This variable holds a list of functions to be called if the size of any
|
|
|
1817 window changes for any reason. The functions are called just once per
|
|
|
1818 redisplay, and just once for each frame on which size changes have
|
|
|
1819 occurred.
|
|
|
1820
|
|
|
1821 Each function receives the frame as its sole argument. There is no
|
|
|
1822 direct way to find out which windows changed size, or precisely how;
|
|
|
1823 however, if your size-change function keeps track, after each change, of
|
|
|
1824 the windows that interest you, you can figure out what has changed by
|
|
|
1825 comparing the old size data with the new.
|
|
|
1826
|
|
|
1827 Creating or deleting windows counts as a size change, and therefore
|
|
|
1828 causes these functions to be called. Changing the frame size also
|
|
|
1829 counts, because it changes the sizes of the existing windows.
|
|
|
1830
|
|
|
1831 It is not a good idea to use @code{save-window-excursion} in these
|
|
|
1832 functions, because that always counts as a size change, and it would
|
|
|
1833 cause these functions to be called over and over. In most cases,
|
|
|
1834 @code{save-selected-window} is what you need here.
|
|
|
1835 @end defvar
|
|
|
1836
|
|
|
1837 @node Window Configurations
|
|
|
1838 @section Window Configurations
|
|
|
1839 @cindex window configurations
|
|
|
1840 @cindex saving window information
|
|
|
1841
|
|
|
1842 A @dfn{window configuration} records the entire layout of a
|
|
|
1843 frame---all windows, their sizes, which buffers they contain, what part
|
|
|
1844 of each buffer is displayed, and the values of point and the mark. You
|
|
|
1845 can bring back an entire previous layout by restoring a window
|
|
|
1846 configuration previously saved.
|
|
|
1847
|
|
|
1848 If you want to record all frames instead of just one, use a frame
|
|
|
1849 configuration instead of a window configuration. @xref{Frame
|
|
|
1850 Configurations}.
|
|
|
1851
|
|
444
|
1852 @defun current-window-configuration &optional frame
|
|
625
|
1853 This function returns a new object representing the current window
|
|
|
1854 configuration of @var{frame}, namely the number of windows, their sizes
|
|
|
1855 and current buffers, which window is the selected window, and for each
|
|
|
1856 window the displayed buffer, the display-start position, and the
|
|
444
|
1857 positions of point and the mark. An exception is made for point in the
|
|
|
1858 current buffer, whose value is not saved.
|
|
|
1859
|
|
|
1860 @var{frame} defaults to the selected frame.
|
|
428
|
1861 @end defun
|
|
|
1862
|
|
|
1863 @defun set-window-configuration configuration
|
|
|
1864 This function restores the configuration of XEmacs's windows and
|
|
|
1865 buffers to the state specified by @var{configuration}. The argument
|
|
|
1866 @var{configuration} must be a value that was previously returned by
|
|
|
1867 @code{current-window-configuration}.
|
|
|
1868
|
|
|
1869 This function always counts as a window size change and triggers
|
|
|
1870 execution of the @code{window-size-change-functions}. (It doesn't know
|
|
|
1871 how to tell whether the new configuration actually differs from the old
|
|
|
1872 one.)
|
|
|
1873
|
|
|
1874 Here is a way of using this function to get the same effect
|
|
|
1875 as @code{save-window-excursion}:
|
|
|
1876
|
|
|
1877 @example
|
|
|
1878 @group
|
|
|
1879 (let ((config (current-window-configuration)))
|
|
|
1880 (unwind-protect
|
|
|
1881 (progn (split-window-vertically nil)
|
|
|
1882 @dots{})
|
|
|
1883 (set-window-configuration config)))
|
|
|
1884 @end group
|
|
|
1885 @end example
|
|
|
1886 @end defun
|
|
|
1887
|
|
|
1888 @defspec save-window-excursion forms@dots{}
|
|
|
1889 This special form records the window configuration, executes @var{forms}
|
|
|
1890 in sequence, then restores the earlier window configuration. The window
|
|
|
1891 configuration includes the value of point and the portion of the buffer
|
|
|
1892 that is visible. It also includes the choice of selected window.
|
|
|
1893 However, it does not include the value of point in the current buffer;
|
|
|
1894 use @code{save-excursion} if you wish to preserve that.
|
|
|
1895
|
|
|
1896 Don't use this construct when @code{save-selected-window} is all you need.
|
|
|
1897
|
|
|
1898 Exit from @code{save-window-excursion} always triggers execution of the
|
|
|
1899 @code{window-size-change-functions}. (It doesn't know how to tell
|
|
|
1900 whether the restored configuration actually differs from the one in
|
|
|
1901 effect at the end of the @var{forms}.)
|
|
|
1902
|
|
|
1903 The return value is the value of the final form in @var{forms}.
|
|
|
1904 For example:
|
|
|
1905
|
|
|
1906 @example
|
|
|
1907 @group
|
|
|
1908 (split-window)
|
|
|
1909 @result{} #<window 25 on control.texi>
|
|
|
1910 @end group
|
|
|
1911 @group
|
|
|
1912 (setq w (selected-window))
|
|
|
1913 @result{} #<window 19 on control.texi>
|
|
|
1914 @end group
|
|
|
1915 @group
|
|
|
1916 (save-window-excursion
|
|
|
1917 (delete-other-windows w)
|
|
|
1918 (switch-to-buffer "foo")
|
|
|
1919 'do-something)
|
|
|
1920 @result{} do-something
|
|
|
1921 ;; @r{The frame is now split again.}
|
|
|
1922 @end group
|
|
|
1923 @end example
|
|
|
1924 @end defspec
|
|
|
1925
|
|
|
1926 @defun window-configuration-p object
|
|
|
1927 This function returns @code{t} if @var{object} is a window configuration.
|
|
|
1928 @end defun
|
|
|
1929
|
|
|
1930 Primitives to look inside of window configurations would make sense,
|
|
|
1931 but none are implemented. It is not clear they are useful enough to be
|
|
|
1932 worth implementing.
|
