]> code.delx.au - gnu-emacs/blob - src/window.c
upstream
[gnu-emacs] / src / window.c
1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2012
4 Free Software Foundation, Inc.
5
6 This file is part of GNU Emacs.
7
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include <config.h>
22
23 #define WINDOW_INLINE EXTERN_INLINE
24
25 #include <stdio.h>
26
27 #include "lisp.h"
28 #include "character.h"
29 #include "buffer.h"
30 #include "keyboard.h"
31 #include "keymap.h"
32 #include "frame.h"
33 #include "window.h"
34 #include "commands.h"
35 #include "indent.h"
36 #include "termchar.h"
37 #include "disptab.h"
38 #include "dispextern.h"
39 #include "blockinput.h"
40 #include "intervals.h"
41 #include "termhooks.h" /* For FRAME_TERMINAL. */
42
43 #ifdef HAVE_X_WINDOWS
44 #include "xterm.h"
45 #endif /* HAVE_X_WINDOWS */
46 #ifdef HAVE_NTGUI
47 #include "w32term.h"
48 #endif
49 #ifdef MSDOS
50 #include "msdos.h"
51 #endif
52 #ifdef HAVE_NS
53 #include "nsterm.h"
54 #endif
55 #ifdef HAVE_XWIDGETS
56 #include "xwidget.h"
57 #endif
58 Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_valid_p;
59 static Lisp_Object Qwindow_configuration_p, Qrecord_window_buffer;
60 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
61 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
62 static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically;
63 static Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
64 static Lisp_Object Qsafe, Qabove, Qbelow, Qwindow_size, Qclone_of;
65
66 static int displayed_window_lines (struct window *);
67 static int count_windows (struct window *);
68 static int get_leaf_windows (struct window *, struct window **, int);
69 static void window_scroll (Lisp_Object, EMACS_INT, int, int);
70 static void window_scroll_pixel_based (Lisp_Object, int, int, int);
71 static void window_scroll_line_based (Lisp_Object, int, int, int);
72 static int freeze_window_start (struct window *, void *);
73 static Lisp_Object window_list (void);
74 static int add_window_to_list (struct window *, void *);
75 static int candidate_window_p (Lisp_Object, Lisp_Object, Lisp_Object,
76 Lisp_Object);
77 static Lisp_Object next_window (Lisp_Object, Lisp_Object,
78 Lisp_Object, int);
79 static void decode_next_window_args (Lisp_Object *, Lisp_Object *,
80 Lisp_Object *);
81 static void foreach_window (struct frame *,
82 int (* fn) (struct window *, void *),
83 void *);
84 static int foreach_window_1 (struct window *,
85 int (* fn) (struct window *, void *),
86 void *);
87 static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
88 static int window_resize_check (struct window *, int);
89 static void window_resize_apply (struct window *, int);
90 static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
91
92 /* This is the window in which the terminal's cursor should
93 be left when nothing is being done with it. This must
94 always be a leaf window, and its buffer is selected by
95 the top level editing loop at the end of each command.
96
97 This value is always the same as
98 FRAME_SELECTED_WINDOW (selected_frame). */
99 Lisp_Object selected_window;
100
101 /* A list of all windows for use by next_window and Fwindow_list.
102 Functions creating or deleting windows should invalidate this cache
103 by setting it to nil. */
104 Lisp_Object Vwindow_list;
105
106 /* The mini-buffer window of the selected frame.
107 Note that you cannot test for mini-bufferness of an arbitrary window
108 by comparing against this; but you can test for mini-bufferness of
109 the selected window. */
110 Lisp_Object minibuf_window;
111
112 /* Non-nil means it is the window whose mode line should be
113 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window;
115
116 /* Hook run at end of temp_output_buffer_show. */
117 static Lisp_Object Qtemp_buffer_show_hook;
118
119 /* Incremented for each window created. */
120 static int sequence_number;
121
122 /* Nonzero after init_window_once has finished. */
123 static int window_initialized;
124
125 /* Hook to run when window config changes. */
126 static Lisp_Object Qwindow_configuration_change_hook;
127
128 /* Used by the function window_scroll_pixel_based */
129 static int window_scroll_pixel_based_preserve_x;
130 static int window_scroll_pixel_based_preserve_y;
131
132 /* Same for window_scroll_line_based. */
133 static EMACS_INT window_scroll_preserve_hpos;
134 static EMACS_INT window_scroll_preserve_vpos;
135 \f
136 /* These setters are used only in this file, so they can be private. */
137 static void
138 wset_combination_limit (struct window *w, Lisp_Object val)
139 {
140 w->combination_limit = val;
141 }
142 static void
143 wset_dedicated (struct window *w, Lisp_Object val)
144 {
145 w->dedicated = val;
146 }
147 static void
148 wset_display_table (struct window *w, Lisp_Object val)
149 {
150 w->display_table = val;
151 }
152 static void
153 wset_hchild (struct window *w, Lisp_Object val)
154 {
155 w->hchild = val;
156 }
157 static void
158 wset_left_fringe_width (struct window *w, Lisp_Object val)
159 {
160 w->left_fringe_width = val;
161 }
162 static void
163 wset_left_margin_cols (struct window *w, Lisp_Object val)
164 {
165 w->left_margin_cols = val;
166 }
167 static void
168 wset_new_normal (struct window *w, Lisp_Object val)
169 {
170 w->new_normal = val;
171 }
172 static void
173 wset_new_total (struct window *w, Lisp_Object val)
174 {
175 w->new_total = val;
176 }
177 static void
178 wset_normal_cols (struct window *w, Lisp_Object val)
179 {
180 w->normal_cols = val;
181 }
182 static void
183 wset_normal_lines (struct window *w, Lisp_Object val)
184 {
185 w->normal_lines = val;
186 }
187 static void
188 wset_parent (struct window *w, Lisp_Object val)
189 {
190 w->parent = val;
191 }
192 static void
193 wset_pointm (struct window *w, Lisp_Object val)
194 {
195 w->pointm = val;
196 }
197 static void
198 wset_right_fringe_width (struct window *w, Lisp_Object val)
199 {
200 w->right_fringe_width = val;
201 }
202 static void
203 wset_right_margin_cols (struct window *w, Lisp_Object val)
204 {
205 w->right_margin_cols = val;
206 }
207 static void
208 wset_scroll_bar_width (struct window *w, Lisp_Object val)
209 {
210 w->scroll_bar_width = val;
211 }
212 static void
213 wset_start (struct window *w, Lisp_Object val)
214 {
215 w->start = val;
216 }
217 static void
218 wset_temslot (struct window *w, Lisp_Object val)
219 {
220 w->temslot = val;
221 }
222 static void
223 wset_vchild (struct window *w, Lisp_Object val)
224 {
225 w->vchild = val;
226 }
227 static void
228 wset_vertical_scroll_bar_type (struct window *w, Lisp_Object val)
229 {
230 w->vertical_scroll_bar_type = val;
231 }
232 static void
233 wset_window_parameters (struct window *w, Lisp_Object val)
234 {
235 w->window_parameters = val;
236 }
237
238 struct window *
239 decode_live_window (register Lisp_Object window)
240 {
241 if (NILP (window))
242 return XWINDOW (selected_window);
243
244 CHECK_LIVE_WINDOW (window);
245 return XWINDOW (window);
246 }
247
248 struct window *
249 decode_any_window (register Lisp_Object window)
250 {
251 struct window *w;
252
253 if (NILP (window))
254 return XWINDOW (selected_window);
255
256 CHECK_WINDOW (window);
257 w = XWINDOW (window);
258 return w;
259 }
260
261 static struct window *
262 decode_valid_window (register Lisp_Object window)
263 {
264 struct window *w;
265
266 if (NILP (window))
267 return XWINDOW (selected_window);
268
269 CHECK_VALID_WINDOW (window);
270 w = XWINDOW (window);
271 return w;
272 }
273
274 /* Build a frequently used 4-integer (X Y W H) list. */
275
276 static Lisp_Object
277 quad (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
278 {
279 return list4 (make_number (x), make_number (y),
280 make_number (w), make_number (h));
281 }
282
283 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
284 doc: /* Return t if OBJECT is a window and nil otherwise. */)
285 (Lisp_Object object)
286 {
287 return WINDOWP (object) ? Qt : Qnil;
288 }
289
290 DEFUN ("window-valid-p", Fwindow_valid_p, Swindow_valid_p, 1, 1, 0,
291 doc: /* Return t if OBJECT is a valid window and nil otherwise.
292 A valid window is either a window that displays a buffer or an internal
293 window. Deleted windows are not live. */)
294 (Lisp_Object object)
295 {
296 return WINDOW_VALID_P (object) ? Qt : Qnil;
297 }
298
299 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
300 doc: /* Return t if OBJECT is a live window and nil otherwise.
301 A live window is a window that displays a buffer.
302 Internal windows and deleted windows are not live. */)
303 (Lisp_Object object)
304 {
305 return WINDOW_LIVE_P (object) ? Qt : Qnil;
306 }
307 \f
308 /* Frames and windows. */
309 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 0, 1, 0,
310 doc: /* Return the frame that window WINDOW is on.
311 WINDOW must be a valid window and defaults to the selected one. */)
312 (Lisp_Object window)
313 {
314 return decode_valid_window (window)->frame;
315 }
316
317 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
318 doc: /* Return the root window of FRAME-OR-WINDOW.
319 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
320 With a frame argument, return that frame's root window.
321 With a window argument, return the root window of that window's frame. */)
322 (Lisp_Object frame_or_window)
323 {
324 Lisp_Object window;
325
326 if (NILP (frame_or_window))
327 window = SELECTED_FRAME ()->root_window;
328 else if (WINDOW_VALID_P (frame_or_window))
329 window = XFRAME (XWINDOW (frame_or_window)->frame)->root_window;
330 else
331 {
332 CHECK_LIVE_FRAME (frame_or_window);
333 window = XFRAME (frame_or_window)->root_window;
334 }
335
336 return window;
337 }
338
339 DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
340 doc: /* Return the minibuffer window for frame FRAME.
341 If FRAME is omitted or nil, it defaults to the selected frame. */)
342 (Lisp_Object frame)
343 {
344 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame));
345 }
346
347 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
348 Swindow_minibuffer_p, 0, 1, 0,
349 doc: /* Return non-nil if WINDOW is a minibuffer window.
350 WINDOW must be a valid window and defaults to the selected one. */)
351 (Lisp_Object window)
352 {
353 return MINI_WINDOW_P (decode_valid_window (window)) ? Qt : Qnil;
354 }
355
356 /* Don't move this to window.el - this must be a safe routine. */
357 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
358 doc: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
359 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
360 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
361 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
362 the first window of that frame. */)
363 (Lisp_Object frame_or_window)
364 {
365 Lisp_Object window;
366
367 if (NILP (frame_or_window))
368 window = SELECTED_FRAME ()->root_window;
369 else if (WINDOW_VALID_P (frame_or_window))
370 window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
371 else
372 {
373 CHECK_LIVE_FRAME (frame_or_window);
374 window = XFRAME (frame_or_window)->root_window;
375 }
376
377 while (NILP (XWINDOW (window)->buffer))
378 {
379 if (! NILP (XWINDOW (window)->hchild))
380 window = XWINDOW (window)->hchild;
381 else if (! NILP (XWINDOW (window)->vchild))
382 window = XWINDOW (window)->vchild;
383 else
384 emacs_abort ();
385 }
386
387 return window;
388 }
389
390 DEFUN ("frame-selected-window", Fframe_selected_window,
391 Sframe_selected_window, 0, 1, 0,
392 doc: /* Return the selected window of FRAME-OR-WINDOW.
393 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
394 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
395 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
396 return the selected window of that frame. */)
397 (Lisp_Object frame_or_window)
398 {
399 Lisp_Object window;
400
401 if (NILP (frame_or_window))
402 window = SELECTED_FRAME ()->selected_window;
403 else if (WINDOW_VALID_P (frame_or_window))
404 window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->selected_window;
405 else
406 {
407 CHECK_LIVE_FRAME (frame_or_window);
408 window = XFRAME (frame_or_window)->selected_window;
409 }
410
411 return window;
412 }
413
414 DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
415 Sset_frame_selected_window, 2, 3, 0,
416 doc: /* Set selected window of FRAME to WINDOW.
417 FRAME must be a live frame and defaults to the selected one. If FRAME
418 is the selected frame, this makes WINDOW the selected window. Optional
419 argument NORECORD non-nil means to neither change the order of recently
420 selected windows nor the buffer list. WINDOW must denote a live window.
421 Return WINDOW. */)
422 (Lisp_Object frame, Lisp_Object window, Lisp_Object norecord)
423 {
424 if (NILP (frame))
425 frame = selected_frame;
426
427 CHECK_LIVE_FRAME (frame);
428 CHECK_LIVE_WINDOW (window);
429
430 if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
431 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
432
433 if (EQ (frame, selected_frame))
434 return Fselect_window (window, norecord);
435 else
436 {
437 fset_selected_window (XFRAME (frame), window);
438 return window;
439 }
440 }
441
442 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
443 doc: /* Return the selected window.
444 The selected window is the window in which the standard cursor for
445 selected windows appears and to which many commands apply. */)
446 (void)
447 {
448 return selected_window;
449 }
450
451 int window_select_count;
452
453 /* If select_window is called with inhibit_point_swap non-zero it will
454 not store point of the old selected window's buffer back into that
455 window's pointm slot. This is needed by Fset_window_configuration to
456 avoid that the display routine is called with selected_window set to
457 Qnil causing a subsequent crash. */
458 static Lisp_Object
459 select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
460 {
461 register struct window *w;
462 register struct window *ow;
463 struct frame *sf;
464
465 CHECK_LIVE_WINDOW (window);
466
467 w = XWINDOW (window);
468 w->frozen_window_start_p = 0;
469
470 if (NILP (norecord))
471 {
472 w->use_time = ++window_select_count;
473 record_buffer (w->buffer);
474 }
475
476 /* Make the selected window's buffer current. */
477 Fset_buffer (w->buffer);
478
479 if (EQ (window, selected_window) && !inhibit_point_swap)
480 return window;
481
482 sf = SELECTED_FRAME ();
483 if (XFRAME (WINDOW_FRAME (w)) != sf)
484 {
485 fset_selected_window (XFRAME (WINDOW_FRAME (w)), window);
486 /* Use this rather than Fhandle_switch_frame
487 so that FRAME_FOCUS_FRAME is moved appropriately as we
488 move around in the state where a minibuffer in a separate
489 frame is active. */
490 Fselect_frame (WINDOW_FRAME (w), norecord);
491 /* Fselect_frame called us back so we've done all the work already. */
492 eassert (EQ (window, selected_window));
493 return window;
494 }
495 else
496 fset_selected_window (sf, window);
497
498 /* Store the old selected window's buffer's point in pointm of the old
499 selected window. It belongs to that window, and when the window is
500 not selected, must be in the window. */
501 if (!inhibit_point_swap)
502 {
503 ow = XWINDOW (selected_window);
504 if (! NILP (ow->buffer))
505 set_marker_both (ow->pointm, ow->buffer,
506 BUF_PT (XBUFFER (ow->buffer)),
507 BUF_PT_BYTE (XBUFFER (ow->buffer)));
508 }
509
510 selected_window = window;
511 bset_last_selected_window (XBUFFER (w->buffer), window);
512
513 /* Go to the point recorded in the window.
514 This is important when the buffer is in more
515 than one window. It also matters when
516 redisplay_window has altered point after scrolling,
517 because it makes the change only in the window. */
518 {
519 register ptrdiff_t new_point = marker_position (w->pointm);
520 if (new_point < BEGV)
521 SET_PT (BEGV);
522 else if (new_point > ZV)
523 SET_PT (ZV);
524 else
525 SET_PT (new_point);
526 }
527
528 windows_or_buffers_changed++;
529 return window;
530 }
531
532 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
533 doc: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
534 Also make WINDOW's buffer current and make WINDOW the frame's selected
535 window. Return WINDOW.
536
537 Optional second arg NORECORD non-nil means do not put this buffer at the
538 front of the buffer list and do not make this window the most recently
539 selected one.
540
541 Note that the main editor command loop sets the current buffer to the
542 buffer of the selected window before each command. */)
543 (register Lisp_Object window, Lisp_Object norecord)
544 {
545 return select_window (window, norecord, 0);
546 }
547 \f
548 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
549 doc: /* Return the buffer displayed in window WINDOW.
550 If WINDOW is omitted or nil, it defaults to the selected window.
551 Return nil for an internal window or a deleted window. */)
552 (Lisp_Object window)
553 {
554 return decode_any_window (window)->buffer;
555 }
556
557 DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
558 doc: /* Return the parent window of window WINDOW.
559 WINDOW must be a valid window and defaults to the selected one.
560 Return nil for a window with no parent (e.g. a root window). */)
561 (Lisp_Object window)
562 {
563 return decode_valid_window (window)->parent;
564 }
565
566 DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 0, 1, 0,
567 doc: /* Return the topmost child window of window WINDOW.
568 WINDOW must be a valid window and defaults to the selected one.
569 Return nil if WINDOW is a live window (live windows have no children).
570 Return nil if WINDOW is an internal window whose children form a
571 horizontal combination. */)
572 (Lisp_Object window)
573 {
574 return decode_valid_window (window)->vchild;
575 }
576
577 DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 0, 1, 0,
578 doc: /* Return the leftmost child window of window WINDOW.
579 WINDOW must be a valid window and defaults to the selected one.
580 Return nil if WINDOW is a live window (live windows have no children).
581 Return nil if WINDOW is an internal window whose children form a
582 vertical combination. */)
583 (Lisp_Object window)
584 {
585 return decode_valid_window (window)->hchild;
586 }
587
588 DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
589 doc: /* Return the next sibling window of window WINDOW.
590 WINDOW must be a valid window and defaults to the selected one.
591 Return nil if WINDOW has no next sibling. */)
592 (Lisp_Object window)
593 {
594 return decode_valid_window (window)->next;
595 }
596
597 DEFUN ("window-prev-sibling", Fwindow_prev_sibling, Swindow_prev_sibling, 0, 1, 0,
598 doc: /* Return the previous sibling window of window WINDOW.
599 WINDOW must be a valid window and defaults to the selected one.
600 Return nil if WINDOW has no previous sibling. */)
601 (Lisp_Object window)
602 {
603 return decode_valid_window (window)->prev;
604 }
605
606 DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
607 doc: /* Return combination limit of window WINDOW.
608 If the return value is nil, child windows of WINDOW can be recombined with
609 WINDOW's siblings. A return value of t means that child windows of
610 WINDOW are never \(re-)combined with WINDOW's siblings.
611
612 WINDOW must be a valid window. The return value is meaningful for
613 internal windows only. */)
614 (Lisp_Object window)
615 {
616 CHECK_VALID_WINDOW (window);
617 return XWINDOW (window)->combination_limit;
618 }
619
620 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
621 doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
622 WINDOW must be a valid window and defaults to the selected one.
623 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
624 siblings. LIMIT t means that child windows of WINDOW are never
625 \(re-)combined with WINDOW's siblings. Other values are reserved for
626 future use. */)
627 (Lisp_Object window, Lisp_Object limit)
628 {
629 wset_combination_limit (decode_valid_window (window), limit);
630 return limit;
631 }
632
633 DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
634 doc: /* Return the use time of window WINDOW.
635 WINDOW must be a live window and defaults to the selected one.
636 The window with the highest use time is the most recently selected
637 one. The window with the lowest use time is the least recently
638 selected one. */)
639 (Lisp_Object window)
640 {
641 return make_number (decode_live_window (window)->use_time);
642 }
643 \f
644 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
645 doc: /* Return the total height, in lines, of window WINDOW.
646 WINDOW must be a valid window and defaults to the selected one.
647
648 The return value includes the mode line and header line, if any.
649 If WINDOW is an internal window, the total height is the height
650 of the screen areas spanned by its children.
651
652 On a graphical display, this total height is reported as an
653 integer multiple of the default character height. */)
654 (Lisp_Object window)
655 {
656 return decode_valid_window (window)->total_lines;
657 }
658
659 DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 1, 0,
660 doc: /* Return the total width, in columns, of window WINDOW.
661 WINDOW must be a valid window and defaults to the selected one.
662
663 The return value includes any vertical dividers or scroll bars
664 belonging to WINDOW. If WINDOW is an internal window, the total width
665 is the width of the screen areas spanned by its children.
666
667 On a graphical display, this total width is reported as an
668 integer multiple of the default character width. */)
669 (Lisp_Object window)
670 {
671 return decode_valid_window (window)->total_cols;
672 }
673
674 DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
675 doc: /* Return the new total size of window WINDOW.
676 WINDOW must be a valid window and defaults to the selected one. */)
677 (Lisp_Object window)
678 {
679 return decode_valid_window (window)->new_total;
680 }
681
682 DEFUN ("window-normal-size", Fwindow_normal_size, Swindow_normal_size, 0, 2, 0,
683 doc: /* Return the normal height of window WINDOW.
684 WINDOW must be a valid window and defaults to the selected one.
685 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
686 (Lisp_Object window, Lisp_Object horizontal)
687 {
688 struct window *w = decode_valid_window (window);
689
690 return NILP (horizontal) ? w->normal_lines : w->normal_cols;
691 }
692
693 DEFUN ("window-new-normal", Fwindow_new_normal, Swindow_new_normal, 0, 1, 0,
694 doc: /* Return new normal size of window WINDOW.
695 WINDOW must be a valid window and defaults to the selected one. */)
696 (Lisp_Object window)
697 {
698 return decode_valid_window (window)->new_normal;
699 }
700
701 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
702 doc: /* Return left column of window WINDOW.
703 This is the distance, in columns, between the left edge of WINDOW and
704 the left edge of the frame's window area. For instance, the return
705 value is 0 if there is no window to the left of WINDOW.
706
707 WINDOW must be a valid window and defaults to the selected one. */)
708 (Lisp_Object window)
709 {
710 return decode_valid_window (window)->left_col;
711 }
712
713 DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
714 doc: /* Return top line of window WINDOW.
715 This is the distance, in lines, between the top of WINDOW and the top
716 of the frame's window area. For instance, the return value is 0 if
717 there is no window above WINDOW.
718
719 WINDOW must be a valid window and defaults to the selected one. */)
720 (Lisp_Object window)
721 {
722 return decode_valid_window (window)->top_line;
723 }
724
725 /* Return the number of lines of W's body. Don't count any mode or
726 header line of W. */
727
728 static int
729 window_body_lines (struct window *w)
730 {
731 int height = XFASTINT (w->total_lines);
732
733 if (!MINI_WINDOW_P (w))
734 {
735 if (WINDOW_WANTS_MODELINE_P (w))
736 --height;
737 if (WINDOW_WANTS_HEADER_LINE_P (w))
738 --height;
739 }
740
741 return height;
742 }
743
744 /* Return the number of columns of W's body. Don't count columns
745 occupied by the scroll bar or the vertical bar separating W from its
746 right sibling. On window-systems don't count fringes or display
747 margins either. */
748
749 int
750 window_body_cols (struct window *w)
751 {
752 struct frame *f = XFRAME (WINDOW_FRAME (w));
753 int width = XINT (w->total_cols);
754
755 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
756 /* Scroll bars occupy a few columns. */
757 width -= WINDOW_CONFIG_SCROLL_BAR_COLS (w);
758 else if (!FRAME_WINDOW_P (f)
759 && !WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
760 /* The column of `|' characters separating side-by-side windows
761 occupies one column only. */
762 width -= 1;
763
764 if (FRAME_WINDOW_P (f))
765 /* On window-systems, fringes and display margins cannot be
766 used for normal text. */
767 width -= (WINDOW_FRINGE_COLS (w)
768 + WINDOW_LEFT_MARGIN_COLS (w)
769 + WINDOW_RIGHT_MARGIN_COLS (w));
770
771 return width;
772 }
773
774 DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 1, 0,
775 doc: /* Return the height, in lines, of WINDOW's text area.
776 WINDOW must be a live window and defaults to the selected one.
777
778 The returned height does not include the mode line or header line.
779 On a graphical display, the height is expressed as an integer multiple
780 of the default character height. If a line at the bottom of the text
781 area is only partially visible, that counts as a whole line; to
782 exclude partially-visible lines, use `window-text-height'. */)
783 (Lisp_Object window)
784 {
785 return make_number (window_body_lines (decode_live_window (window)));
786 }
787
788 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
789 doc: /* Return the width, in columns, of WINDOW's text area.
790 WINDOW must be a live window and defaults to the selected one.
791
792 The return value does not include any vertical dividers, fringe or
793 marginal areas, or scroll bars. On a graphical display, the width is
794 expressed as an integer multiple of the default character width. */)
795 (Lisp_Object window)
796 {
797 return make_number (window_body_cols (decode_live_window (window)));
798 }
799
800 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
801 doc: /* Return the number of columns by which WINDOW is scrolled from left margin.
802 WINDOW must be a live window and defaults to the selected one. */)
803 (Lisp_Object window)
804 {
805 return make_number (decode_live_window (window)->hscroll);
806 }
807
808 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
809 range, returning the new amount as a fixnum. */
810 static Lisp_Object
811 set_window_hscroll (struct window *w, EMACS_INT hscroll)
812 {
813 /* Horizontal scrolling has problems with large scroll amounts.
814 It's too slow with long lines, and even with small lines the
815 display can be messed up. For now, though, impose only the limits
816 required by the internal representation: horizontal scrolling must
817 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
818 (since it's stored in a ptrdiff_t). */
819 ptrdiff_t hscroll_max = min (MOST_POSITIVE_FIXNUM, PTRDIFF_MAX);
820 ptrdiff_t new_hscroll = clip_to_bounds (0, hscroll, hscroll_max);
821
822 /* Prevent redisplay shortcuts when changing the hscroll. */
823 if (w->hscroll != new_hscroll)
824 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
825
826 w->hscroll = new_hscroll;
827 return make_number (new_hscroll);
828 }
829
830 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
831 doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
832 WINDOW must be a live window and defaults to the selected one.
833 Clip the number to a reasonable value if out of range.
834 Return the new number. NCOL should be zero or positive.
835
836 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
837 window so that the location of point moves off-window. */)
838 (Lisp_Object window, Lisp_Object ncol)
839 {
840 CHECK_NUMBER (ncol);
841 return set_window_hscroll (decode_live_window (window), XINT (ncol));
842 }
843
844 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
845 Swindow_redisplay_end_trigger, 0, 1, 0,
846 doc: /* Return WINDOW's redisplay end trigger value.
847 WINDOW must be a live window and defaults to the selected one.
848 See `set-window-redisplay-end-trigger' for more information. */)
849 (Lisp_Object window)
850 {
851 return decode_live_window (window)->redisplay_end_trigger;
852 }
853
854 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
855 Sset_window_redisplay_end_trigger, 2, 2, 0,
856 doc: /* Set WINDOW's redisplay end trigger value to VALUE.
857 WINDOW must be a live window and defaults to the selected one. VALUE
858 should be a buffer position (typically a marker) or nil. If it is a
859 buffer position, then if redisplay in WINDOW reaches a position beyond
860 VALUE, the functions in `redisplay-end-trigger-functions' are called
861 with two arguments: WINDOW, and the end trigger value. Afterwards the
862 end-trigger value is reset to nil. */)
863 (register Lisp_Object window, Lisp_Object value)
864 {
865 wset_redisplay_end_trigger (decode_live_window (window), value);
866 return value;
867 }
868
869 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
870 doc: /* Return a list of the edge coordinates of WINDOW.
871 WINDOW must be a valid window and defaults to the selected one.
872
873 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
874 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
875 0 at top left corner of frame.
876
877 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
878 is one more than the bottommost row occupied by WINDOW. The edges
879 include the space used by WINDOW's scroll bar, display margins, fringes,
880 header line, and/or mode line. For the edges of just the text area, use
881 `window-inside-edges'. */)
882 (Lisp_Object window)
883 {
884 register struct window *w = decode_valid_window (window);
885
886 return quad (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
887 WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
888 }
889
890 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
891 doc: /* Return a list of the edge pixel coordinates of WINDOW.
892 WINDOW must be a valid window and defaults to the selected one.
893
894 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
895 0, 0 at the top left corner of the frame.
896
897 RIGHT is one more than the rightmost x position occupied by WINDOW.
898 BOTTOM is one more than the bottommost y position occupied by WINDOW.
899 The pixel edges include the space used by WINDOW's scroll bar, display
900 margins, fringes, header line, and/or mode line. For the pixel edges
901 of just the text area, use `window-inside-pixel-edges'. */)
902 (Lisp_Object window)
903 {
904 register struct window *w = decode_valid_window (window);
905
906 return quad (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
907 WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
908 }
909
910 static void
911 calc_absolute_offset (struct window *w, int *add_x, int *add_y)
912 {
913 struct frame *f = XFRAME (w->frame);
914 *add_y = f->top_pos;
915 #ifdef FRAME_MENUBAR_HEIGHT
916 *add_y += FRAME_MENUBAR_HEIGHT (f);
917 #endif
918 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
919 *add_y += FRAME_TOOLBAR_TOP_HEIGHT (f);
920 #elif FRAME_TOOLBAR_HEIGHT
921 *add_y += FRAME_TOOLBAR_HEIGHT (f);
922 #endif
923 #ifdef FRAME_NS_TITLEBAR_HEIGHT
924 *add_y += FRAME_NS_TITLEBAR_HEIGHT (f);
925 #endif
926 *add_x = f->left_pos;
927 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
928 *add_x += FRAME_TOOLBAR_LEFT_WIDTH (f);
929 #endif
930 }
931
932 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges,
933 Swindow_absolute_pixel_edges, 0, 1, 0,
934 doc: /* Return a list of the edge pixel coordinates of WINDOW.
935 WINDOW must be a valid window and defaults to the selected one.
936
937 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
938 0, 0 at the top left corner of the display.
939
940 RIGHT is one more than the rightmost x position occupied by WINDOW.
941 BOTTOM is one more than the bottommost y position occupied by WINDOW.
942 The pixel edges include the space used by WINDOW's scroll bar, display
943 margins, fringes, header line, and/or mode line. For the pixel edges
944 of just the text area, use `window-inside-absolute-pixel-edges'. */)
945 (Lisp_Object window)
946 {
947 register struct window *w = decode_valid_window (window);
948 int add_x, add_y;
949
950 calc_absolute_offset (w, &add_x, &add_y);
951
952 return quad (WINDOW_LEFT_EDGE_X (w) + add_x,
953 WINDOW_TOP_EDGE_Y (w) + add_y,
954 WINDOW_RIGHT_EDGE_X (w) + add_x,
955 WINDOW_BOTTOM_EDGE_Y (w) + add_y);
956 }
957
958 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
959 doc: /* Return a list of the edge coordinates of WINDOW.
960 WINDOW must be a live window and defaults to the selected one.
961
962 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
963 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
964 0 at top left corner of frame.
965
966 RIGHT is one more than the rightmost column of WINDOW's text area.
967 BOTTOM is one more than the bottommost row of WINDOW's text area. The
968 inside edges do not include the space used by the WINDOW's scroll bar,
969 display margins, fringes, header line, and/or mode line. */)
970 (Lisp_Object window)
971 {
972 register struct window *w = decode_live_window (window);
973
974 return quad (WINDOW_BOX_LEFT_EDGE_COL (w)
975 + WINDOW_LEFT_MARGIN_COLS (w)
976 + WINDOW_LEFT_FRINGE_COLS (w),
977 WINDOW_TOP_EDGE_LINE (w)
978 + WINDOW_HEADER_LINE_LINES (w),
979 WINDOW_BOX_RIGHT_EDGE_COL (w)
980 - WINDOW_RIGHT_MARGIN_COLS (w)
981 - WINDOW_RIGHT_FRINGE_COLS (w),
982 WINDOW_BOTTOM_EDGE_LINE (w)
983 - WINDOW_MODE_LINE_LINES (w));
984 }
985
986 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
987 doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
988 WINDOW must be a live window and defaults to the selected one.
989
990 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
991 (0,0) at the top left corner of the frame's window area.
992
993 RIGHT is one more than the rightmost x position of WINDOW's text area.
994 BOTTOM is one more than the bottommost y position of WINDOW's text area.
995 The inside edges do not include the space used by WINDOW's scroll bar,
996 display margins, fringes, header line, and/or mode line. */)
997 (Lisp_Object window)
998 {
999 register struct window *w = decode_live_window (window);
1000
1001 return quad (WINDOW_BOX_LEFT_EDGE_X (w)
1002 + WINDOW_LEFT_MARGIN_WIDTH (w)
1003 + WINDOW_LEFT_FRINGE_WIDTH (w),
1004 WINDOW_TOP_EDGE_Y (w)
1005 + WINDOW_HEADER_LINE_HEIGHT (w),
1006 WINDOW_BOX_RIGHT_EDGE_X (w)
1007 - WINDOW_RIGHT_MARGIN_WIDTH (w)
1008 - WINDOW_RIGHT_FRINGE_WIDTH (w),
1009 WINDOW_BOTTOM_EDGE_Y (w)
1010 - WINDOW_MODE_LINE_HEIGHT (w));
1011 }
1012
1013 DEFUN ("window-inside-absolute-pixel-edges",
1014 Fwindow_inside_absolute_pixel_edges,
1015 Swindow_inside_absolute_pixel_edges, 0, 1, 0,
1016 doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1017 WINDOW must be a live window and defaults to the selected one.
1018
1019 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1020 (0,0) at the top left corner of the frame's window area.
1021
1022 RIGHT is one more than the rightmost x position of WINDOW's text area.
1023 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1024 The inside edges do not include the space used by WINDOW's scroll bar,
1025 display margins, fringes, header line, and/or mode line. */)
1026 (Lisp_Object window)
1027 {
1028 register struct window *w = decode_live_window (window);
1029 int add_x, add_y;
1030
1031 calc_absolute_offset (w, &add_x, &add_y);
1032
1033 return quad (WINDOW_BOX_LEFT_EDGE_X (w)
1034 + WINDOW_LEFT_MARGIN_WIDTH (w)
1035 + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x,
1036 WINDOW_TOP_EDGE_Y (w)
1037 + WINDOW_HEADER_LINE_HEIGHT (w) + add_y,
1038 WINDOW_BOX_RIGHT_EDGE_X (w)
1039 - WINDOW_RIGHT_MARGIN_WIDTH (w)
1040 - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x,
1041 WINDOW_BOTTOM_EDGE_Y (w)
1042 - WINDOW_MODE_LINE_HEIGHT (w) + add_y);
1043 }
1044
1045 /* Test if the character at column X, row Y is within window W.
1046 If it is not, return ON_NOTHING;
1047 if it is in the window's text area, return ON_TEXT;
1048 if it is on the window's modeline, return ON_MODE_LINE;
1049 if it is on the border between the window and its right sibling,
1050 return ON_VERTICAL_BORDER.
1051 if it is on a scroll bar, return ON_SCROLL_BAR.
1052 if it is on the window's top line, return ON_HEADER_LINE;
1053 if it is in left or right fringe of the window,
1054 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1055 if it is in the marginal area to the left/right of the window,
1056 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1057
1058 X and Y are frame relative pixel coordinates. */
1059
1060 static enum window_part
1061 coordinates_in_window (register struct window *w, int x, int y)
1062 {
1063 struct frame *f = XFRAME (WINDOW_FRAME (w));
1064 enum window_part part;
1065 int ux = FRAME_COLUMN_WIDTH (f);
1066 int left_x = WINDOW_LEFT_EDGE_X (w);
1067 int right_x = WINDOW_RIGHT_EDGE_X (w);
1068 int top_y = WINDOW_TOP_EDGE_Y (w);
1069 int bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
1070 /* The width of the area where the vertical line can be dragged.
1071 (Between mode lines for instance. */
1072 int grabbable_width = ux;
1073 int lmargin_width, rmargin_width, text_left, text_right;
1074
1075 /* Outside any interesting row or column? */
1076 if (y < top_y || y >= bottom_y || x < left_x || x >= right_x)
1077 return ON_NOTHING;
1078
1079 /* On the mode line or header line? */
1080 if ((WINDOW_WANTS_MODELINE_P (w)
1081 && y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w)
1082 && (part = ON_MODE_LINE))
1083 || (WINDOW_WANTS_HEADER_LINE_P (w)
1084 && y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
1085 && (part = ON_HEADER_LINE)))
1086 {
1087 /* If it's under/over the scroll bar portion of the mode/header
1088 line, say it's on the vertical line. That's to be able to
1089 resize windows horizontally in case we're using toolkit scroll
1090 bars. Note: If scrollbars are on the left, the window that
1091 must be eventually resized is that on the left of WINDOW. */
1092 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
1093 && !WINDOW_LEFTMOST_P (w)
1094 && eabs (x - left_x) < grabbable_width)
1095 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
1096 && !WINDOW_RIGHTMOST_P (w)
1097 && eabs (x - right_x) < grabbable_width))
1098 return ON_VERTICAL_BORDER;
1099 else
1100 return part;
1101 }
1102
1103 /* In what's below, we subtract 1 when computing right_x because we
1104 want the rightmost pixel, which is given by left_pixel+width-1. */
1105 if (w->pseudo_window_p)
1106 {
1107 left_x = 0;
1108 right_x = WINDOW_TOTAL_WIDTH (w) - 1;
1109 }
1110 else
1111 {
1112 left_x = WINDOW_BOX_LEFT_EDGE_X (w);
1113 right_x = WINDOW_BOX_RIGHT_EDGE_X (w) - 1;
1114 }
1115
1116 /* Outside any interesting column? */
1117 if (x < left_x || x > right_x)
1118 return ON_SCROLL_BAR;
1119
1120 lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
1121 rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
1122
1123 text_left = window_box_left (w, TEXT_AREA);
1124 text_right = text_left + window_box_width (w, TEXT_AREA);
1125
1126 if (FRAME_WINDOW_P (f))
1127 {
1128 if (!w->pseudo_window_p
1129 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
1130 && !WINDOW_RIGHTMOST_P (w)
1131 && (eabs (x - right_x) < grabbable_width))
1132 return ON_VERTICAL_BORDER;
1133 }
1134 /* Need to say "x > right_x" rather than >=, since on character
1135 terminals, the vertical line's x coordinate is right_x. */
1136 else if (!w->pseudo_window_p
1137 && !WINDOW_RIGHTMOST_P (w)
1138 && x > right_x - ux)
1139 return ON_VERTICAL_BORDER;
1140
1141 if (x < text_left)
1142 {
1143 if (lmargin_width > 0
1144 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
1145 ? (x >= left_x + WINDOW_LEFT_FRINGE_WIDTH (w))
1146 : (x < left_x + lmargin_width)))
1147 return ON_LEFT_MARGIN;
1148
1149 return ON_LEFT_FRINGE;
1150 }
1151
1152 if (x >= text_right)
1153 {
1154 if (rmargin_width > 0
1155 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
1156 ? (x < right_x - WINDOW_RIGHT_FRINGE_WIDTH (w))
1157 : (x >= right_x - rmargin_width)))
1158 return ON_RIGHT_MARGIN;
1159
1160 return ON_RIGHT_FRINGE;
1161 }
1162
1163 /* Everything special ruled out - must be on text area */
1164 return ON_TEXT;
1165 }
1166
1167 /* Take X is the frame-relative pixel x-coordinate, and return the
1168 x-coordinate relative to part PART of window W. */
1169 int
1170 window_relative_x_coord (struct window *w, enum window_part part, int x)
1171 {
1172 int left_x = (w->pseudo_window_p) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w);
1173
1174 switch (part)
1175 {
1176 case ON_TEXT:
1177 return x - window_box_left (w, TEXT_AREA);
1178
1179 case ON_LEFT_FRINGE:
1180 return x - left_x;
1181
1182 case ON_RIGHT_FRINGE:
1183 return x - left_x - WINDOW_LEFT_FRINGE_WIDTH (w);
1184
1185 case ON_LEFT_MARGIN:
1186 return (x - left_x
1187 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
1188 ? WINDOW_LEFT_FRINGE_WIDTH (w) : 0));
1189
1190 case ON_RIGHT_MARGIN:
1191 return (x + 1
1192 - ((w->pseudo_window_p)
1193 ? WINDOW_TOTAL_WIDTH (w)
1194 : WINDOW_BOX_RIGHT_EDGE_X (w))
1195 + window_box_width (w, RIGHT_MARGIN_AREA)
1196 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
1197 ? WINDOW_RIGHT_FRINGE_WIDTH (w) : 0));
1198 }
1199
1200 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1201 return 0;
1202 }
1203
1204
1205 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
1206 Scoordinates_in_window_p, 2, 2, 0,
1207 doc: /* Return non-nil if COORDINATES are in WINDOW.
1208 WINDOW must be a live window and defaults to the selected one.
1209 COORDINATES is a cons of the form (X . Y), X and Y being distances
1210 measured in characters from the upper-left corner of the frame.
1211 \(0 . 0) denotes the character in the upper left corner of the
1212 frame.
1213 If COORDINATES are in the text portion of WINDOW,
1214 the coordinates relative to the window are returned.
1215 If they are in the mode line of WINDOW, `mode-line' is returned.
1216 If they are in the top mode line of WINDOW, `header-line' is returned.
1217 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1218 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1219 If they are on the border between WINDOW and its right sibling,
1220 `vertical-line' is returned.
1221 If they are in the windows's left or right marginal areas, `left-margin'\n\
1222 or `right-margin' is returned. */)
1223 (register Lisp_Object coordinates, Lisp_Object window)
1224 {
1225 struct window *w;
1226 struct frame *f;
1227 int x, y;
1228 Lisp_Object lx, ly;
1229
1230 w = decode_live_window (window);
1231 f = XFRAME (w->frame);
1232 CHECK_CONS (coordinates);
1233 lx = Fcar (coordinates);
1234 ly = Fcdr (coordinates);
1235 CHECK_NUMBER_OR_FLOAT (lx);
1236 CHECK_NUMBER_OR_FLOAT (ly);
1237 x = FRAME_PIXEL_X_FROM_CANON_X (f, lx) + FRAME_INTERNAL_BORDER_WIDTH (f);
1238 y = FRAME_PIXEL_Y_FROM_CANON_Y (f, ly) + FRAME_INTERNAL_BORDER_WIDTH (f);
1239
1240 switch (coordinates_in_window (w, x, y))
1241 {
1242 case ON_NOTHING:
1243 return Qnil;
1244
1245 case ON_TEXT:
1246 /* Convert X and Y to window relative pixel coordinates, and
1247 return the canonical char units. */
1248 x -= window_box_left (w, TEXT_AREA);
1249 y -= WINDOW_TOP_EDGE_Y (w);
1250 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f, x),
1251 FRAME_CANON_Y_FROM_PIXEL_Y (f, y));
1252
1253 case ON_MODE_LINE:
1254 return Qmode_line;
1255
1256 case ON_VERTICAL_BORDER:
1257 return Qvertical_line;
1258
1259 case ON_HEADER_LINE:
1260 return Qheader_line;
1261
1262 case ON_LEFT_FRINGE:
1263 return Qleft_fringe;
1264
1265 case ON_RIGHT_FRINGE:
1266 return Qright_fringe;
1267
1268 case ON_LEFT_MARGIN:
1269 return Qleft_margin;
1270
1271 case ON_RIGHT_MARGIN:
1272 return Qright_margin;
1273
1274 case ON_SCROLL_BAR:
1275 /* Historically we are supposed to return nil in this case. */
1276 return Qnil;
1277
1278 default:
1279 emacs_abort ();
1280 }
1281 }
1282
1283
1284 /* Callback for foreach_window, used in window_from_coordinates.
1285 Check if window W contains coordinates specified by USER_DATA which
1286 is actually a pointer to a struct check_window_data CW.
1287
1288 Check if window W contains coordinates *CW->x and *CW->y. If it
1289 does, return W in *CW->window, as Lisp_Object, and return in
1290 *CW->part the part of the window under coordinates *X,*Y. Return
1291 zero from this function to stop iterating over windows. */
1292
1293 struct check_window_data
1294 {
1295 Lisp_Object *window;
1296 int x, y;
1297 enum window_part *part;
1298 };
1299
1300 static int
1301 check_window_containing (struct window *w, void *user_data)
1302 {
1303 struct check_window_data *cw = (struct check_window_data *) user_data;
1304 enum window_part found;
1305 int continue_p = 1;
1306
1307 found = coordinates_in_window (w, cw->x, cw->y);
1308 if (found != ON_NOTHING)
1309 {
1310 *cw->part = found;
1311 XSETWINDOW (*cw->window, w);
1312 continue_p = 0;
1313 }
1314
1315 return continue_p;
1316 }
1317
1318
1319 /* Find the window containing frame-relative pixel position X/Y and
1320 return it as a Lisp_Object.
1321
1322 If X, Y is on one of the window's special `window_part' elements,
1323 set *PART to the id of that element.
1324
1325 If there is no window under X, Y return nil and leave *PART
1326 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1327
1328 This function was previously implemented with a loop cycling over
1329 windows with Fnext_window, and starting with the frame's selected
1330 window. It turned out that this doesn't work with an
1331 implementation of next_window using Vwindow_list, because
1332 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1333 tree of F when this function is called asynchronously from
1334 note_mouse_highlight. The original loop didn't terminate in this
1335 case. */
1336
1337 Lisp_Object
1338 window_from_coordinates (struct frame *f, int x, int y,
1339 enum window_part *part, int tool_bar_p)
1340 {
1341 Lisp_Object window;
1342 struct check_window_data cw;
1343 enum window_part dummy;
1344
1345 if (part == 0)
1346 part = &dummy;
1347
1348 window = Qnil;
1349 cw.window = &window, cw.x = x, cw.y = y; cw.part = part;
1350 foreach_window (f, check_window_containing, &cw);
1351
1352 /* If not found above, see if it's in the tool bar window, if a tool
1353 bar exists. */
1354 if (NILP (window)
1355 && tool_bar_p
1356 && WINDOWP (f->tool_bar_window)
1357 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0
1358 && (coordinates_in_window (XWINDOW (f->tool_bar_window), x, y)
1359 != ON_NOTHING))
1360 {
1361 *part = ON_TEXT;
1362 window = f->tool_bar_window;
1363 }
1364
1365 return window;
1366 }
1367
1368 DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
1369 doc: /* Return window containing coordinates X and Y on FRAME.
1370 FRAME must be a live frame and defaults to the selected one.
1371 The top left corner of the frame is considered to be row 0,
1372 column 0. */)
1373 (Lisp_Object x, Lisp_Object y, Lisp_Object frame)
1374 {
1375 struct frame *f = decode_live_frame (frame);
1376
1377 /* Check that arguments are integers or floats. */
1378 CHECK_NUMBER_OR_FLOAT (x);
1379 CHECK_NUMBER_OR_FLOAT (y);
1380
1381 return window_from_coordinates (f,
1382 (FRAME_PIXEL_X_FROM_CANON_X (f, x)
1383 + FRAME_INTERNAL_BORDER_WIDTH (f)),
1384 (FRAME_PIXEL_Y_FROM_CANON_Y (f, y)
1385 + FRAME_INTERNAL_BORDER_WIDTH (f)),
1386 0, 0);
1387 }
1388
1389 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
1390 doc: /* Return current value of point in WINDOW.
1391 WINDOW must be a live window and defaults to the selected one.
1392
1393 For a nonselected window, this is the value point would have if that
1394 window were selected.
1395
1396 Note that, when WINDOW is selected, the value returned is the same as
1397 that returned by `point' for WINDOW's buffer. It would be more strictly
1398 correct to return the `top-level' value of `point', outside of any
1399 `save-excursion' forms. But that is hard to define. */)
1400 (Lisp_Object window)
1401 {
1402 register struct window *w = decode_live_window (window);
1403
1404 if (w == XWINDOW (selected_window))
1405 return make_number (BUF_PT (XBUFFER (w->buffer)));
1406 else
1407 return Fmarker_position (w->pointm);
1408 }
1409
1410 DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
1411 doc: /* Return position at which display currently starts in WINDOW.
1412 WINDOW must be a live window and defaults to the selected one.
1413 This is updated by redisplay or by calling `set-window-start'. */)
1414 (Lisp_Object window)
1415 {
1416 return Fmarker_position (decode_live_window (window)->start);
1417 }
1418
1419 /* This is text temporarily removed from the doc string below.
1420
1421 This function returns nil if the position is not currently known.
1422 That happens when redisplay is preempted and doesn't finish.
1423 If in that case you want to compute where the end of the window would
1424 have been if redisplay had finished, do this:
1425 (save-excursion
1426 (goto-char (window-start window))
1427 (vertical-motion (1- (window-height window)) window)
1428 (point))") */
1429
1430 DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0,
1431 doc: /* Return position at which display currently ends in WINDOW.
1432 WINDOW must be a live window and defaults to the selected one.
1433 This is updated by redisplay, when it runs to completion.
1434 Simply changing the buffer text or setting `window-start'
1435 does not update this value.
1436 Return nil if there is no recorded value. (This can happen if the
1437 last redisplay of WINDOW was preempted, and did not finish.)
1438 If UPDATE is non-nil, compute the up-to-date position
1439 if it isn't already recorded. */)
1440 (Lisp_Object window, Lisp_Object update)
1441 {
1442 Lisp_Object value;
1443 struct window *w = decode_live_window (window);
1444 Lisp_Object buf;
1445 struct buffer *b;
1446
1447 buf = w->buffer;
1448 CHECK_BUFFER (buf);
1449 b = XBUFFER (buf);
1450
1451 #if 0 /* This change broke some things. We should make it later. */
1452 /* If we don't know the end position, return nil.
1453 The user can compute it with vertical-motion if he wants to.
1454 It would be nicer to do it automatically,
1455 but that's so slow that it would probably bother people. */
1456 if (NILP (w->window_end_valid))
1457 return Qnil;
1458 #endif
1459
1460 if (! NILP (update)
1461 && (windows_or_buffers_changed || NILP (w->window_end_valid))
1462 && !noninteractive)
1463 {
1464 struct text_pos startp;
1465 struct it it;
1466 struct buffer *old_buffer = NULL;
1467 void *itdata = NULL;
1468
1469 /* Cannot use Fvertical_motion because that function doesn't
1470 cope with variable-height lines. */
1471 if (b != current_buffer)
1472 {
1473 old_buffer = current_buffer;
1474 set_buffer_internal (b);
1475 }
1476
1477 /* In case W->start is out of the range, use something
1478 reasonable. This situation occurred when loading a file with
1479 `-l' containing a call to `rmail' with subsequent other
1480 commands. At the end, W->start happened to be BEG, while
1481 rmail had already narrowed the buffer. */
1482 if (XMARKER (w->start)->charpos < BEGV)
1483 SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
1484 else if (XMARKER (w->start)->charpos > ZV)
1485 SET_TEXT_POS (startp, ZV, ZV_BYTE);
1486 else
1487 SET_TEXT_POS_FROM_MARKER (startp, w->start);
1488
1489 itdata = bidi_shelve_cache ();
1490 start_display (&it, w, startp);
1491 move_it_vertically (&it, window_box_height (w));
1492 if (it.current_y < it.last_visible_y)
1493 move_it_past_eol (&it);
1494 value = make_number (IT_CHARPOS (it));
1495 bidi_unshelve_cache (itdata, 0);
1496
1497 if (old_buffer)
1498 set_buffer_internal (old_buffer);
1499 }
1500 else
1501 XSETINT (value, BUF_Z (b) - XFASTINT (w->window_end_pos));
1502
1503 return value;
1504 }
1505
1506 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
1507 doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1508 WINDOW must be a live window and defaults to the selected one.
1509 Return POS. */)
1510 (Lisp_Object window, Lisp_Object pos)
1511 {
1512 register struct window *w = decode_live_window (window);
1513
1514 CHECK_NUMBER_COERCE_MARKER (pos);
1515
1516 if (w == XWINDOW (selected_window))
1517 {
1518 if (XBUFFER (w->buffer) == current_buffer)
1519 Fgoto_char (pos);
1520 else
1521 {
1522 struct buffer *old_buffer = current_buffer;
1523
1524 set_buffer_internal (XBUFFER (w->buffer));
1525 Fgoto_char (pos);
1526 set_buffer_internal (old_buffer);
1527 }
1528 }
1529 else
1530 {
1531 set_marker_restricted (w->pointm, pos, w->buffer);
1532 /* We have to make sure that redisplay updates the window to show
1533 the new value of point. */
1534 ++windows_or_buffers_changed;
1535 }
1536
1537 return pos;
1538 }
1539
1540 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
1541 doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1542 WINDOW must be a live window and defaults to the selected one. Return
1543 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1544 overriding motion of point in order to display at this exact start. */)
1545 (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
1546 {
1547 register struct window *w = decode_live_window (window);
1548
1549 CHECK_NUMBER_COERCE_MARKER (pos);
1550 set_marker_restricted (w->start, pos, w->buffer);
1551 /* this is not right, but much easier than doing what is right. */
1552 w->start_at_line_beg = 0;
1553 if (NILP (noforce))
1554 w->force_start = 1;
1555 w->update_mode_line = 1;
1556 w->last_modified = 0;
1557 w->last_overlay_modified = 0;
1558 if (!EQ (window, selected_window))
1559 windows_or_buffers_changed++;
1560
1561 return pos;
1562 }
1563
1564 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
1565 Spos_visible_in_window_p, 0, 3, 0,
1566 doc: /* Return non-nil if position POS is currently on the frame in WINDOW.
1567 WINDOW must be a live window and defaults to the selected one.
1568
1569 Return nil if that position is scrolled vertically out of view. If a
1570 character is only partially visible, nil is returned, unless the
1571 optional argument PARTIALLY is non-nil. If POS is only out of view
1572 because of horizontal scrolling, return non-nil. If POS is t, it
1573 specifies the position of the last visible glyph in WINDOW. POS
1574 defaults to point in WINDOW; WINDOW defaults to the selected window.
1575
1576 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1577 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1578 where X and Y are the pixel coordinates relative to the top left corner
1579 of the window. The remaining elements are omitted if the character after
1580 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1581 off-window at the top and bottom of the row, ROWH is the height of the
1582 display row, and VPOS is the row number (0-based) containing POS. */)
1583 (Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
1584 {
1585 register struct window *w;
1586 register EMACS_INT posint;
1587 register struct buffer *buf;
1588 struct text_pos top;
1589 Lisp_Object in_window = Qnil;
1590 int rtop, rbot, rowh, vpos, fully_p = 1;
1591 int x, y;
1592
1593 w = decode_live_window (window);
1594 buf = XBUFFER (w->buffer);
1595 SET_TEXT_POS_FROM_MARKER (top, w->start);
1596
1597 if (EQ (pos, Qt))
1598 posint = -1;
1599 else if (!NILP (pos))
1600 {
1601 CHECK_NUMBER_COERCE_MARKER (pos);
1602 posint = XINT (pos);
1603 }
1604 else if (w == XWINDOW (selected_window))
1605 posint = PT;
1606 else
1607 posint = XMARKER (w->pointm)->charpos;
1608
1609 /* If position is above window start or outside buffer boundaries,
1610 or if window start is out of range, position is not visible. */
1611 if ((EQ (pos, Qt)
1612 || (posint >= CHARPOS (top) && posint <= BUF_ZV (buf)))
1613 && CHARPOS (top) >= BUF_BEGV (buf)
1614 && CHARPOS (top) <= BUF_ZV (buf)
1615 && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, &rowh, &vpos)
1616 && (fully_p = !rtop && !rbot, (!NILP (partially) || fully_p)))
1617 in_window = Qt;
1618
1619 if (!NILP (in_window) && !NILP (partially))
1620 {
1621 Lisp_Object part = Qnil;
1622 if (!fully_p)
1623 part = quad (rtop, rbot, rowh, vpos);
1624 in_window = Fcons (make_number (x),
1625 Fcons (make_number (y), part));
1626 }
1627
1628 return in_window;
1629 }
1630
1631 DEFUN ("window-line-height", Fwindow_line_height,
1632 Swindow_line_height, 0, 2, 0,
1633 doc: /* Return height in pixels of text line LINE in window WINDOW.
1634 WINDOW must be a live window and defaults to the selected one.
1635
1636 Return height of current line if LINE is omitted or nil. Return height of
1637 header or mode line if LINE is `header-line' or `mode-line'.
1638 Otherwise, LINE is a text line number starting from 0. A negative number
1639 counts from the end of the window.
1640
1641 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1642 in pixels of the visible part of the line, VPOS and YPOS are the
1643 vertical position in lines and pixels of the line, relative to the top
1644 of the first text line, and OFFBOT is the number of off-window pixels at
1645 the bottom of the text line. If there are off-window pixels at the top
1646 of the (first) text line, YPOS is negative.
1647
1648 Return nil if window display is not up-to-date. In that case, use
1649 `pos-visible-in-window-p' to obtain the information. */)
1650 (Lisp_Object line, Lisp_Object window)
1651 {
1652 register struct window *w;
1653 register struct buffer *b;
1654 struct glyph_row *row, *end_row;
1655 int max_y, crop, i;
1656 EMACS_INT n;
1657
1658 w = decode_live_window (window);
1659
1660 if (noninteractive || w->pseudo_window_p)
1661 return Qnil;
1662
1663 CHECK_BUFFER (w->buffer);
1664 b = XBUFFER (w->buffer);
1665
1666 /* Fail if current matrix is not up-to-date. */
1667 if (NILP (w->window_end_valid)
1668 || current_buffer->clip_changed
1669 || current_buffer->prevent_redisplay_optimizations_p
1670 || w->last_modified < BUF_MODIFF (b)
1671 || w->last_overlay_modified < BUF_OVERLAY_MODIFF (b))
1672 return Qnil;
1673
1674 if (NILP (line))
1675 {
1676 i = w->cursor.vpos;
1677 if (i < 0 || i >= w->current_matrix->nrows
1678 || (row = MATRIX_ROW (w->current_matrix, i), !row->enabled_p))
1679 return Qnil;
1680 max_y = window_text_bottom_y (w);
1681 goto found_row;
1682 }
1683
1684 if (EQ (line, Qheader_line))
1685 {
1686 if (!WINDOW_WANTS_HEADER_LINE_P (w))
1687 return Qnil;
1688 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
1689 return row->enabled_p ? quad (row->height, 0, 0, 0) : Qnil;
1690 }
1691
1692 if (EQ (line, Qmode_line))
1693 {
1694 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
1695 return (row->enabled_p ?
1696 quad (row->height,
1697 0, /* not accurate */
1698 WINDOW_HEADER_LINE_HEIGHT (w)
1699 + window_text_bottom_y (w), 0)
1700 : Qnil);
1701 }
1702
1703 CHECK_NUMBER (line);
1704 n = XINT (line);
1705
1706 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
1707 end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
1708 max_y = window_text_bottom_y (w);
1709 i = 0;
1710
1711 while ((n < 0 || i < n)
1712 && row <= end_row && row->enabled_p
1713 && row->y + row->height < max_y)
1714 row++, i++;
1715
1716 if (row > end_row || !row->enabled_p)
1717 return Qnil;
1718
1719 if (++n < 0)
1720 {
1721 if (-n > i)
1722 return Qnil;
1723 row += n;
1724 i += n;
1725 }
1726
1727 found_row:
1728 crop = max (0, (row->y + row->height) - max_y);
1729 return quad (row->height + min (0, row->y) - crop, i, row->y, crop);
1730 }
1731
1732 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
1733 0, 1, 0,
1734 doc: /* Return non-nil when WINDOW is dedicated to its buffer.
1735 More precisely, return the value assigned by the last call of
1736 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1737 never called with WINDOW as its argument, or the value set by that
1738 function was internally reset since its last call. WINDOW must be a
1739 live window and defaults to the selected one.
1740
1741 When a window is dedicated to its buffer, `display-buffer' will refrain
1742 from displaying another buffer in it. `get-lru-window' and
1743 `get-largest-window' treat dedicated windows specially.
1744 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1745 `kill-buffer' can delete a dedicated window and the containing frame.
1746
1747 Functions like `set-window-buffer' may change the buffer displayed by a
1748 window, unless that window is "strongly" dedicated to its buffer, that
1749 is the value returned by `window-dedicated-p' is t. */)
1750 (Lisp_Object window)
1751 {
1752 return decode_live_window (window)->dedicated;
1753 }
1754
1755 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
1756 Sset_window_dedicated_p, 2, 2, 0,
1757 doc: /* Mark WINDOW as dedicated according to FLAG.
1758 WINDOW must be a live window and defaults to the selected one. FLAG
1759 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1760 mark WINDOW as non-dedicated. Return FLAG.
1761
1762 When a window is dedicated to its buffer, `display-buffer' will refrain
1763 from displaying another buffer in it. `get-lru-window' and
1764 `get-largest-window' treat dedicated windows specially.
1765 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1766 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1767 and the containing frame.
1768
1769 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1770 its buffer. Functions like `set-window-buffer' may change the buffer
1771 displayed by a window, unless that window is strongly dedicated to its
1772 buffer. If and when `set-window-buffer' displays another buffer in a
1773 window, it also makes sure that the window is no more dedicated. */)
1774 (Lisp_Object window, Lisp_Object flag)
1775 {
1776 wset_dedicated (decode_live_window (window), flag);
1777 return flag;
1778 }
1779
1780 DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
1781 0, 1, 0,
1782 doc: /* Return buffers previously shown in WINDOW.
1783 WINDOW must be a live window and defaults to the selected one.
1784
1785 The return value is a list of elements (BUFFER WINDOW-START POS),
1786 where BUFFER is a buffer, WINDOW-START is the start position of the
1787 window for that buffer, and POS is a window-specific point value. */)
1788 (Lisp_Object window)
1789 {
1790 return decode_live_window (window)->prev_buffers;
1791 }
1792
1793 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
1794 Sset_window_prev_buffers, 2, 2, 0,
1795 doc: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1796 WINDOW must be a live window and defaults to the selected one.
1797
1798 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1799 where BUFFER is a buffer, WINDOW-START is the start position of the
1800 window for that buffer, and POS is a window-specific point value. */)
1801 (Lisp_Object window, Lisp_Object prev_buffers)
1802 {
1803 wset_prev_buffers (decode_live_window (window), prev_buffers);
1804 return prev_buffers;
1805 }
1806
1807 DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
1808 0, 1, 0,
1809 doc: /* Return list of buffers recently re-shown in WINDOW.
1810 WINDOW must be a live window and defaults to the selected one. */)
1811 (Lisp_Object window)
1812 {
1813 return decode_live_window (window)->next_buffers;
1814 }
1815
1816 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
1817 Sset_window_next_buffers, 2, 2, 0,
1818 doc: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1819 WINDOW must be a live window and defaults to the selected one.
1820 NEXT-BUFFERS should be a list of buffers. */)
1821 (Lisp_Object window, Lisp_Object next_buffers)
1822 {
1823 wset_next_buffers (decode_live_window (window), next_buffers);
1824 return next_buffers;
1825 }
1826
1827 DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
1828 0, 1, 0,
1829 doc: /* Return the parameters of WINDOW and their values.
1830 WINDOW must be a valid window and defaults to the selected one. The
1831 return value is a list of elements of the form (PARAMETER . VALUE). */)
1832 (Lisp_Object window)
1833 {
1834 return Fcopy_alist (decode_valid_window (window)->window_parameters);
1835 }
1836
1837 DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
1838 2, 2, 0,
1839 doc: /* Return WINDOW's value for PARAMETER.
1840 WINDOW can be any window and defaults to the selected one. */)
1841 (Lisp_Object window, Lisp_Object parameter)
1842 {
1843 Lisp_Object result;
1844
1845 result = Fassq (parameter, decode_any_window (window)->window_parameters);
1846 return CDR_SAFE (result);
1847 }
1848
1849 DEFUN ("set-window-parameter", Fset_window_parameter,
1850 Sset_window_parameter, 3, 3, 0,
1851 doc: /* Set WINDOW's value of PARAMETER to VALUE.
1852 WINDOW can be any window and defaults to the selected one.
1853 Return VALUE. */)
1854 (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
1855 {
1856 register struct window *w = decode_any_window (window);
1857 Lisp_Object old_alist_elt;
1858
1859 old_alist_elt = Fassq (parameter, w->window_parameters);
1860 if (NILP (old_alist_elt))
1861 wset_window_parameters
1862 (w, Fcons (Fcons (parameter, value), w->window_parameters));
1863 else
1864 Fsetcdr (old_alist_elt, value);
1865 return value;
1866 }
1867
1868 DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
1869 0, 1, 0,
1870 doc: /* Return the display-table that WINDOW is using.
1871 WINDOW must be a live window and defaults to the selected one. */)
1872 (Lisp_Object window)
1873 {
1874 return decode_live_window (window)->display_table;
1875 }
1876
1877 /* Get the display table for use on window W. This is either W's
1878 display table or W's buffer's display table. Ignore the specified
1879 tables if they are not valid; if no valid table is specified,
1880 return 0. */
1881
1882 struct Lisp_Char_Table *
1883 window_display_table (struct window *w)
1884 {
1885 struct Lisp_Char_Table *dp = NULL;
1886
1887 if (DISP_TABLE_P (w->display_table))
1888 dp = XCHAR_TABLE (w->display_table);
1889 else if (BUFFERP (w->buffer))
1890 {
1891 struct buffer *b = XBUFFER (w->buffer);
1892
1893 if (DISP_TABLE_P (BVAR (b, display_table)))
1894 dp = XCHAR_TABLE (BVAR (b, display_table));
1895 else if (DISP_TABLE_P (Vstandard_display_table))
1896 dp = XCHAR_TABLE (Vstandard_display_table);
1897 }
1898
1899 return dp;
1900 }
1901
1902 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
1903 doc: /* Set WINDOW's display-table to TABLE.
1904 WINDOW must be a live window and defaults to the selected one. */)
1905 (register Lisp_Object window, Lisp_Object table)
1906 {
1907 wset_display_table (decode_live_window (window), table);
1908 return table;
1909 }
1910 \f
1911 /* Record info on buffer window W is displaying
1912 when it is about to cease to display that buffer. */
1913 static void
1914 unshow_buffer (register struct window *w)
1915 {
1916 Lisp_Object buf;
1917 struct buffer *b;
1918
1919 buf = w->buffer;
1920 b = XBUFFER (buf);
1921 if (b != XMARKER (w->pointm)->buffer)
1922 emacs_abort ();
1923
1924 #if 0
1925 if (w == XWINDOW (selected_window)
1926 || ! EQ (buf, XWINDOW (selected_window)->buffer))
1927 /* Do this except when the selected window's buffer
1928 is being removed from some other window. */
1929 #endif
1930 /* last_window_start records the start position that this buffer
1931 had in the last window to be disconnected from it.
1932 Now that this statement is unconditional,
1933 it is possible for the buffer to be displayed in the
1934 selected window, while last_window_start reflects another
1935 window which was recently showing the same buffer.
1936 Some people might say that might be a good thing. Let's see. */
1937 b->last_window_start = marker_position (w->start);
1938
1939 /* Point in the selected window's buffer
1940 is actually stored in that buffer, and the window's pointm isn't used.
1941 So don't clobber point in that buffer. */
1942 if (! EQ (buf, XWINDOW (selected_window)->buffer)
1943 /* Don't clobber point in current buffer either (this could be
1944 useful in connection with bug#12208).
1945 && XBUFFER (buf) != current_buffer */
1946 /* This line helps to fix Horsley's testbug.el bug. */
1947 && !(WINDOWP (BVAR (b, last_selected_window))
1948 && w != XWINDOW (BVAR (b, last_selected_window))
1949 && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->buffer)))
1950 temp_set_point_both (b,
1951 clip_to_bounds (BUF_BEGV (b),
1952 XMARKER (w->pointm)->charpos,
1953 BUF_ZV (b)),
1954 clip_to_bounds (BUF_BEGV_BYTE (b),
1955 marker_byte_position (w->pointm),
1956 BUF_ZV_BYTE (b)));
1957
1958 if (WINDOWP (BVAR (b, last_selected_window))
1959 && w == XWINDOW (BVAR (b, last_selected_window)))
1960 bset_last_selected_window (b, Qnil);
1961 }
1962
1963 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1964 means change window structure only. Otherwise store geometry and
1965 other settings as well. */
1966 static void
1967 replace_window (Lisp_Object old, Lisp_Object new, int setflag)
1968 {
1969 register Lisp_Object tem;
1970 register struct window *o = XWINDOW (old), *n = XWINDOW (new);
1971
1972 /* If OLD is its frame's root window, then NEW is the new
1973 root window for that frame. */
1974 if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
1975 fset_root_window (XFRAME (o->frame), new);
1976
1977 if (setflag)
1978 {
1979 wset_left_col (n, o->left_col);
1980 wset_top_line (n, o->top_line);
1981 wset_total_cols (n, o->total_cols);
1982 wset_total_lines (n, o->total_lines);
1983 wset_normal_cols (n, o->normal_cols);
1984 wset_normal_cols (o, make_float (1.0));
1985 wset_normal_lines (n, o->normal_lines);
1986 wset_normal_lines (o, make_float (1.0));
1987 n->desired_matrix = n->current_matrix = 0;
1988 n->vscroll = 0;
1989 memset (&n->cursor, 0, sizeof (n->cursor));
1990 memset (&n->last_cursor, 0, sizeof (n->last_cursor));
1991 memset (&n->phys_cursor, 0, sizeof (n->phys_cursor));
1992 n->phys_cursor_type = -1;
1993 n->phys_cursor_width = -1;
1994 n->must_be_updated_p = 0;
1995 n->pseudo_window_p = 0;
1996 wset_window_end_vpos (n, make_number (0));
1997 wset_window_end_pos (n, make_number (0));
1998 wset_window_end_valid (n, Qnil);
1999 n->frozen_window_start_p = 0;
2000 }
2001
2002 tem = o->next;
2003 wset_next (n, tem);
2004 if (!NILP (tem))
2005 wset_prev (XWINDOW (tem), new);
2006
2007 tem = o->prev;
2008 wset_prev (n, tem);
2009 if (!NILP (tem))
2010 wset_next (XWINDOW (tem), new);
2011
2012 tem = o->parent;
2013 wset_parent (n, tem);
2014 if (!NILP (tem))
2015 {
2016 if (EQ (XWINDOW (tem)->vchild, old))
2017 wset_vchild (XWINDOW (tem), new);
2018 if (EQ (XWINDOW (tem)->hchild, old))
2019 wset_hchild (XWINDOW (tem), new);
2020 }
2021 }
2022
2023 /* If window WINDOW and its parent window are iso-combined, merge
2024 WINDOW's children into those of its parent window and mark WINDOW as
2025 deleted. */
2026
2027 static void
2028 recombine_windows (Lisp_Object window)
2029 {
2030 struct window *w, *p, *c;
2031 Lisp_Object parent, child;
2032 int horflag;
2033
2034 w = XWINDOW (window);
2035 parent = w->parent;
2036 if (!NILP (parent) && NILP (w->combination_limit))
2037 {
2038 p = XWINDOW (parent);
2039 if (((!NILP (p->vchild) && !NILP (w->vchild))
2040 || (!NILP (p->hchild) && !NILP (w->hchild))))
2041 /* WINDOW and PARENT are both either a vertical or a horizontal
2042 combination. */
2043 {
2044 horflag = NILP (w->vchild);
2045 child = horflag ? w->hchild : w->vchild;
2046 c = XWINDOW (child);
2047
2048 /* Splice WINDOW's children into its parent's children and
2049 assign new normal sizes. */
2050 if (NILP (w->prev))
2051 if (horflag)
2052 wset_hchild (p, child);
2053 else
2054 wset_vchild (p, child);
2055 else
2056 {
2057 wset_prev (c, w->prev);
2058 wset_next (XWINDOW (w->prev), child);
2059 }
2060
2061 while (c)
2062 {
2063 wset_parent (c, parent);
2064
2065 if (horflag)
2066 wset_normal_cols (c,
2067 make_float (XFLOATINT (c->total_cols)
2068 / XFLOATINT (p->total_cols)));
2069 else
2070 wset_normal_lines (c,
2071 make_float (XFLOATINT (c->total_lines)
2072 / XFLOATINT (p->total_lines)));
2073
2074 if (NILP (c->next))
2075 {
2076 if (!NILP (w->next))
2077 {
2078 wset_next (c, w->next);
2079 wset_prev (XWINDOW (c->next), child);
2080 }
2081
2082 c = 0;
2083 }
2084 else
2085 {
2086 child = c->next;
2087 c = XWINDOW (child);
2088 }
2089 }
2090
2091 /* WINDOW can be deleted now. */
2092 wset_vchild (w, Qnil);
2093 wset_hchild (w, Qnil);
2094 }
2095 }
2096 }
2097
2098 /* If WINDOW can be deleted, delete it. */
2099 static void
2100 delete_deletable_window (Lisp_Object window)
2101 {
2102 if (!NILP (call1 (Qwindow_deletable_p, window)))
2103 call1 (Qdelete_window, window);
2104 }
2105 \f
2106 /***********************************************************************
2107 Window List
2108 ***********************************************************************/
2109
2110 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2111 pointer. This is a callback function for foreach_window, used in
2112 the window_list function. */
2113
2114 static int
2115 add_window_to_list (struct window *w, void *user_data)
2116 {
2117 Lisp_Object *list = (Lisp_Object *) user_data;
2118 Lisp_Object window;
2119 XSETWINDOW (window, w);
2120 *list = Fcons (window, *list);
2121 return 1;
2122 }
2123
2124
2125 /* Return a list of all windows, for use by next_window. If
2126 Vwindow_list is a list, return that list. Otherwise, build a new
2127 list, cache it in Vwindow_list, and return that. */
2128
2129 static Lisp_Object
2130 window_list (void)
2131 {
2132 if (!CONSP (Vwindow_list))
2133 {
2134 Lisp_Object tail;
2135
2136 Vwindow_list = Qnil;
2137 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
2138 {
2139 Lisp_Object args[2];
2140
2141 /* We are visiting windows in canonical order, and add
2142 new windows at the front of args[1], which means we
2143 have to reverse this list at the end. */
2144 args[1] = Qnil;
2145 foreach_window (XFRAME (XCAR (tail)), add_window_to_list, &args[1]);
2146 args[0] = Vwindow_list;
2147 args[1] = Fnreverse (args[1]);
2148 Vwindow_list = Fnconc (2, args);
2149 }
2150 }
2151
2152 return Vwindow_list;
2153 }
2154
2155
2156 /* Value is non-zero if WINDOW satisfies the constraints given by
2157 OWINDOW, MINIBUF and ALL_FRAMES.
2158
2159 MINIBUF t means WINDOW may be minibuffer windows.
2160 `lambda' means WINDOW may not be a minibuffer window.
2161 a window means a specific minibuffer window
2162
2163 ALL_FRAMES t means search all frames,
2164 nil means search just current frame,
2165 `visible' means search just visible frames on the
2166 current terminal,
2167 0 means search visible and iconified frames on the
2168 current terminal,
2169 a window means search the frame that window belongs to,
2170 a frame means consider windows on that frame, only. */
2171
2172 static int
2173 candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf, Lisp_Object all_frames)
2174 {
2175 struct window *w = XWINDOW (window);
2176 struct frame *f = XFRAME (w->frame);
2177 int candidate_p = 1;
2178
2179 if (!BUFFERP (w->buffer))
2180 candidate_p = 0;
2181 else if (MINI_WINDOW_P (w)
2182 && (EQ (minibuf, Qlambda)
2183 || (WINDOWP (minibuf) && !EQ (minibuf, window))))
2184 {
2185 /* If MINIBUF is `lambda' don't consider any mini-windows.
2186 If it is a window, consider only that one. */
2187 candidate_p = 0;
2188 }
2189 else if (EQ (all_frames, Qt))
2190 candidate_p = 1;
2191 else if (NILP (all_frames))
2192 {
2193 eassert (WINDOWP (owindow));
2194 candidate_p = EQ (w->frame, XWINDOW (owindow)->frame);
2195 }
2196 else if (EQ (all_frames, Qvisible))
2197 {
2198 FRAME_SAMPLE_VISIBILITY (f);
2199 candidate_p = FRAME_VISIBLE_P (f)
2200 && (FRAME_TERMINAL (XFRAME (w->frame))
2201 == FRAME_TERMINAL (XFRAME (selected_frame)));
2202
2203 }
2204 else if (INTEGERP (all_frames) && XINT (all_frames) == 0)
2205 {
2206 FRAME_SAMPLE_VISIBILITY (f);
2207 candidate_p = (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)
2208 #ifdef HAVE_X_WINDOWS
2209 /* Yuck!! If we've just created the frame and the
2210 window-manager requested the user to place it
2211 manually, the window may still not be considered
2212 `visible'. I'd argue it should be at least
2213 something like `iconified', but don't know how to do
2214 that yet. --Stef */
2215 || (FRAME_X_P (f) && f->output_data.x->asked_for_visible
2216 && !f->output_data.x->has_been_visible)
2217 #endif
2218 )
2219 && (FRAME_TERMINAL (XFRAME (w->frame))
2220 == FRAME_TERMINAL (XFRAME (selected_frame)));
2221 }
2222 else if (WINDOWP (all_frames))
2223 candidate_p = (EQ (FRAME_MINIBUF_WINDOW (f), all_frames)
2224 || EQ (XWINDOW (all_frames)->frame, w->frame)
2225 || EQ (XWINDOW (all_frames)->frame, FRAME_FOCUS_FRAME (f)));
2226 else if (FRAMEP (all_frames))
2227 candidate_p = EQ (all_frames, w->frame);
2228
2229 return candidate_p;
2230 }
2231
2232
2233 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2234 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2235 MINIBUF, and ALL_FRAMES. */
2236
2237 static void
2238 decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object *all_frames)
2239 {
2240 struct window *w = decode_live_window (*window);
2241
2242 XSETWINDOW (*window, w);
2243 /* MINIBUF nil may or may not include minibuffers. Decide if it
2244 does. */
2245 if (NILP (*minibuf))
2246 *minibuf = minibuf_level ? minibuf_window : Qlambda;
2247 else if (!EQ (*minibuf, Qt))
2248 *minibuf = Qlambda;
2249
2250 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2251 => count none of them, or a specific minibuffer window (the
2252 active one) to count. */
2253
2254 /* ALL_FRAMES nil doesn't specify which frames to include. */
2255 if (NILP (*all_frames))
2256 *all_frames
2257 = (!EQ (*minibuf, Qlambda)
2258 ? FRAME_MINIBUF_WINDOW (XFRAME (w->frame))
2259 : Qnil);
2260 else if (EQ (*all_frames, Qvisible))
2261 ;
2262 else if (EQ (*all_frames, make_number (0)))
2263 ;
2264 else if (FRAMEP (*all_frames))
2265 ;
2266 else if (!EQ (*all_frames, Qt))
2267 *all_frames = Qnil;
2268 }
2269
2270
2271 /* Return the next or previous window of WINDOW in cyclic ordering
2272 of windows. NEXT_P non-zero means return the next window. See the
2273 documentation string of next-window for the meaning of MINIBUF and
2274 ALL_FRAMES. */
2275
2276 static Lisp_Object
2277 next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames, int next_p)
2278 {
2279 decode_next_window_args (&window, &minibuf, &all_frames);
2280
2281 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2282 return the first window on the frame. */
2283 if (FRAMEP (all_frames)
2284 && !EQ (all_frames, XWINDOW (window)->frame))
2285 return Fframe_first_window (all_frames);
2286
2287 if (next_p)
2288 {
2289 Lisp_Object list;
2290
2291 /* Find WINDOW in the list of all windows. */
2292 list = Fmemq (window, window_list ());
2293
2294 /* Scan forward from WINDOW to the end of the window list. */
2295 if (CONSP (list))
2296 for (list = XCDR (list); CONSP (list); list = XCDR (list))
2297 if (candidate_window_p (XCAR (list), window, minibuf, all_frames))
2298 break;
2299
2300 /* Scan from the start of the window list up to WINDOW. */
2301 if (!CONSP (list))
2302 for (list = Vwindow_list;
2303 CONSP (list) && !EQ (XCAR (list), window);
2304 list = XCDR (list))
2305 if (candidate_window_p (XCAR (list), window, minibuf, all_frames))
2306 break;
2307
2308 if (CONSP (list))
2309 window = XCAR (list);
2310 }
2311 else
2312 {
2313 Lisp_Object candidate, list;
2314
2315 /* Scan through the list of windows for candidates. If there are
2316 candidate windows in front of WINDOW, the last one of these
2317 is the one we want. If there are candidates following WINDOW
2318 in the list, again the last one of these is the one we want. */
2319 candidate = Qnil;
2320 for (list = window_list (); CONSP (list); list = XCDR (list))
2321 {
2322 if (EQ (XCAR (list), window))
2323 {
2324 if (WINDOWP (candidate))
2325 break;
2326 }
2327 else if (candidate_window_p (XCAR (list), window, minibuf,
2328 all_frames))
2329 candidate = XCAR (list);
2330 }
2331
2332 if (WINDOWP (candidate))
2333 window = candidate;
2334 }
2335
2336 return window;
2337 }
2338
2339
2340 DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
2341 doc: /* Return live window after WINDOW in the cyclic ordering of windows.
2342 WINDOW must be a live window and defaults to the selected one. The
2343 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2344 consider.
2345
2346 MINIBUF nil or omitted means consider the minibuffer window only if the
2347 minibuffer is active. MINIBUF t means consider the minibuffer window
2348 even if the minibuffer is not active. Any other value means do not
2349 consider the minibuffer window even if the minibuffer is active.
2350
2351 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2352 plus the minibuffer window if specified by the MINIBUF argument. If the
2353 minibuffer counts, consider all windows on all frames that share that
2354 minibuffer too. The following non-nil values of ALL-FRAMES have special
2355 meanings:
2356
2357 - t means consider all windows on all existing frames.
2358
2359 - `visible' means consider all windows on all visible frames.
2360
2361 - 0 (the number zero) means consider all windows on all visible and
2362 iconified frames.
2363
2364 - A frame means consider all windows on that frame only.
2365
2366 Anything else means consider all windows on WINDOW's frame and no
2367 others.
2368
2369 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2370 `next-window' to iterate through the entire cycle of acceptable
2371 windows, eventually ending up back at the window you started with.
2372 `previous-window' traverses the same cycle, in the reverse order. */)
2373 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2374 {
2375 return next_window (window, minibuf, all_frames, 1);
2376 }
2377
2378
2379 DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0,
2380 doc: /* Return live window before WINDOW in the cyclic ordering of windows.
2381 WINDOW must be a live window and defaults to the selected one. The
2382 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2383 consider.
2384
2385 MINIBUF nil or omitted means consider the minibuffer window only if the
2386 minibuffer is active. MINIBUF t means consider the minibuffer window
2387 even if the minibuffer is not active. Any other value means do not
2388 consider the minibuffer window even if the minibuffer is active.
2389
2390 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2391 plus the minibuffer window if specified by the MINIBUF argument. If the
2392 minibuffer counts, consider all windows on all frames that share that
2393 minibuffer too. The following non-nil values of ALL-FRAMES have special
2394 meanings:
2395
2396 - t means consider all windows on all existing frames.
2397
2398 - `visible' means consider all windows on all visible frames.
2399
2400 - 0 (the number zero) means consider all windows on all visible and
2401 iconified frames.
2402
2403 - A frame means consider all windows on that frame only.
2404
2405 Anything else means consider all windows on WINDOW's frame and no
2406 others.
2407
2408 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2409 use `previous-window' to iterate through the entire cycle of
2410 acceptable windows, eventually ending up back at the window you
2411 started with. `next-window' traverses the same cycle, in the
2412 reverse order. */)
2413 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2414 {
2415 return next_window (window, minibuf, all_frames, 0);
2416 }
2417
2418
2419 /* Return a list of windows in cyclic ordering. Arguments are like
2420 for `next-window'. */
2421
2422 static Lisp_Object
2423 window_list_1 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2424 {
2425 Lisp_Object tail, list, rest;
2426
2427 decode_next_window_args (&window, &minibuf, &all_frames);
2428 list = Qnil;
2429
2430 for (tail = window_list (); CONSP (tail); tail = XCDR (tail))
2431 if (candidate_window_p (XCAR (tail), window, minibuf, all_frames))
2432 list = Fcons (XCAR (tail), list);
2433
2434 /* Rotate the list to start with WINDOW. */
2435 list = Fnreverse (list);
2436 rest = Fmemq (window, list);
2437 if (!NILP (rest) && !EQ (rest, list))
2438 {
2439 for (tail = list; !EQ (XCDR (tail), rest); tail = XCDR (tail))
2440 ;
2441 XSETCDR (tail, Qnil);
2442 list = nconc2 (rest, list);
2443 }
2444 return list;
2445 }
2446
2447
2448 DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0,
2449 doc: /* Return a list of windows on FRAME, starting with WINDOW.
2450 FRAME nil or omitted means use the selected frame.
2451 WINDOW nil or omitted means use the window selected within FRAME.
2452 MINIBUF t means include the minibuffer window, even if it isn't active.
2453 MINIBUF nil or omitted means include the minibuffer window only
2454 if it's active.
2455 MINIBUF neither nil nor t means never include the minibuffer window. */)
2456 (Lisp_Object frame, Lisp_Object minibuf, Lisp_Object window)
2457 {
2458 if (NILP (window))
2459 window = FRAMEP (frame) ? XFRAME (frame)->selected_window : selected_window;
2460 CHECK_WINDOW (window);
2461 if (NILP (frame))
2462 frame = selected_frame;
2463
2464 if (!EQ (frame, XWINDOW (window)->frame))
2465 error ("Window is on a different frame");
2466
2467 return window_list_1 (window, minibuf, frame);
2468 }
2469
2470
2471 DEFUN ("window-list-1", Fwindow_list_1, Swindow_list_1, 0, 3, 0,
2472 doc: /* Return a list of all live windows.
2473 WINDOW specifies the first window to list and defaults to the selected
2474 window.
2475
2476 Optional argument MINIBUF nil or omitted means consider the minibuffer
2477 window only if the minibuffer is active. MINIBUF t means consider the
2478 minibuffer window even if the minibuffer is not active. Any other value
2479 means do not consider the minibuffer window even if the minibuffer is
2480 active.
2481
2482 Optional argument ALL-FRAMES nil or omitted means consider all windows
2483 on WINDOW's frame, plus the minibuffer window if specified by the
2484 MINIBUF argument. If the minibuffer counts, consider all windows on all
2485 frames that share that minibuffer too. The following non-nil values of
2486 ALL-FRAMES have special meanings:
2487
2488 - t means consider all windows on all existing frames.
2489
2490 - `visible' means consider all windows on all visible frames.
2491
2492 - 0 (the number zero) means consider all windows on all visible and
2493 iconified frames.
2494
2495 - A frame means consider all windows on that frame only.
2496
2497 Anything else means consider all windows on WINDOW's frame and no
2498 others.
2499
2500 If WINDOW is not on the list of windows returned, some other window will
2501 be listed first but no error is signaled. */)
2502 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2503 {
2504 return window_list_1 (window, minibuf, all_frames);
2505 }
2506 \f
2507 /* Look at all windows, performing an operation specified by TYPE
2508 with argument OBJ.
2509 If FRAMES is Qt, look at all frames;
2510 Qnil, look at just the selected frame;
2511 Qvisible, look at visible frames;
2512 a frame, just look at windows on that frame.
2513 If MINI is non-zero, perform the operation on minibuffer windows too. */
2514
2515 enum window_loop
2516 {
2517 WINDOW_LOOP_UNUSED,
2518 GET_BUFFER_WINDOW, /* Arg is buffer */
2519 REPLACE_BUFFER_IN_WINDOWS_SAFELY, /* Arg is buffer */
2520 REDISPLAY_BUFFER_WINDOWS, /* Arg is buffer */
2521 CHECK_ALL_WINDOWS
2522 };
2523
2524 static Lisp_Object
2525 window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frames)
2526 {
2527 Lisp_Object window, windows, best_window, frame_arg;
2528 int frame_best_window_flag = 0;
2529 struct frame *f;
2530 struct gcpro gcpro1;
2531
2532 /* If we're only looping through windows on a particular frame,
2533 frame points to that frame. If we're looping through windows
2534 on all frames, frame is 0. */
2535 if (FRAMEP (frames))
2536 f = XFRAME (frames);
2537 else if (NILP (frames))
2538 f = SELECTED_FRAME ();
2539 else
2540 f = NULL;
2541
2542 if (f)
2543 frame_arg = Qlambda;
2544 else if (EQ (frames, make_number (0)))
2545 frame_arg = frames;
2546 else if (EQ (frames, Qvisible))
2547 frame_arg = frames;
2548 else
2549 frame_arg = Qt;
2550
2551 /* frame_arg is Qlambda to stick to one frame,
2552 Qvisible to consider all visible frames,
2553 or Qt otherwise. */
2554
2555 /* Pick a window to start with. */
2556 if (WINDOWP (obj))
2557 window = obj;
2558 else if (f)
2559 window = FRAME_SELECTED_WINDOW (f);
2560 else
2561 window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2562
2563 windows = window_list_1 (window, mini ? Qt : Qnil, frame_arg);
2564 GCPRO1 (windows);
2565 best_window = Qnil;
2566
2567 for (; CONSP (windows); windows = XCDR (windows))
2568 {
2569 struct window *w;
2570
2571 window = XCAR (windows);
2572 w = XWINDOW (window);
2573
2574 /* Note that we do not pay attention here to whether the frame
2575 is visible, since Fwindow_list skips non-visible frames if
2576 that is desired, under the control of frame_arg. */
2577 if (!MINI_WINDOW_P (w)
2578 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2579 consider all windows. */
2580 || type == REPLACE_BUFFER_IN_WINDOWS_SAFELY
2581 || (mini && minibuf_level > 0))
2582 switch (type)
2583 {
2584 case GET_BUFFER_WINDOW:
2585 if (EQ (w->buffer, obj)
2586 /* Don't find any minibuffer window except the one that
2587 is currently in use. */
2588 && (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))
2589 {
2590 if (EQ (window, selected_window))
2591 /* Preferably return the selected window. */
2592 RETURN_UNGCPRO (window);
2593 else if (EQ (XWINDOW (window)->frame, selected_frame)
2594 && !frame_best_window_flag)
2595 /* Prefer windows on the current frame (but don't
2596 choose another one if we have one already). */
2597 {
2598 best_window = window;
2599 frame_best_window_flag = 1;
2600 }
2601 else if (NILP (best_window))
2602 best_window = window;
2603 }
2604 break;
2605
2606 case REPLACE_BUFFER_IN_WINDOWS_SAFELY:
2607 /* We could simply check whether the buffer shown by window
2608 is live, and show another buffer in case it isn't. */
2609 if (EQ (w->buffer, obj))
2610 {
2611 /* Undedicate WINDOW. */
2612 wset_dedicated (w, Qnil);
2613 /* Make WINDOW show the buffer returned by
2614 other_buffer_safely, don't run any hooks. */
2615 set_window_buffer
2616 (window, other_buffer_safely (w->buffer), 0, 0);
2617 /* If WINDOW is the selected window, make its buffer
2618 current. But do so only if the window shows the
2619 current buffer (Bug#6454). */
2620 if (EQ (window, selected_window)
2621 && XBUFFER (w->buffer) == current_buffer)
2622 Fset_buffer (w->buffer);
2623 }
2624 break;
2625
2626 case REDISPLAY_BUFFER_WINDOWS:
2627 if (EQ (w->buffer, obj))
2628 {
2629 mark_window_display_accurate (window, 0);
2630 w->update_mode_line = 1;
2631 XBUFFER (obj)->prevent_redisplay_optimizations_p = 1;
2632 ++update_mode_lines;
2633 best_window = window;
2634 }
2635 break;
2636
2637 /* Check for a window that has a killed buffer. */
2638 case CHECK_ALL_WINDOWS:
2639 if (! NILP (w->buffer)
2640 && !BUFFER_LIVE_P (XBUFFER (w->buffer)))
2641 emacs_abort ();
2642 break;
2643
2644 case WINDOW_LOOP_UNUSED:
2645 break;
2646 }
2647 }
2648
2649 UNGCPRO;
2650 return best_window;
2651 }
2652
2653 /* Used for debugging. Abort if any window has a dead buffer. */
2654
2655 extern void check_all_windows (void) EXTERNALLY_VISIBLE;
2656 void
2657 check_all_windows (void)
2658 {
2659 window_loop (CHECK_ALL_WINDOWS, Qnil, 1, Qt);
2660 }
2661
2662 DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 0, 2, 0,
2663 doc: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2664 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2665 the current buffer.
2666
2667 The optional argument ALL-FRAMES specifies the frames to consider:
2668
2669 - t means consider all windows on all existing frames.
2670
2671 - `visible' means consider all windows on all visible frames.
2672
2673 - 0 (the number zero) means consider all windows on all visible
2674 and iconified frames.
2675
2676 - A frame means consider all windows on that frame only.
2677
2678 Any other value of ALL-FRAMES means consider all windows on the
2679 selected frame and no others. */)
2680 (Lisp_Object buffer_or_name, Lisp_Object all_frames)
2681 {
2682 Lisp_Object buffer;
2683
2684 if (NILP (buffer_or_name))
2685 buffer = Fcurrent_buffer ();
2686 else
2687 buffer = Fget_buffer (buffer_or_name);
2688
2689 if (BUFFERP (buffer))
2690 return window_loop (GET_BUFFER_WINDOW, buffer, 1, all_frames);
2691 else
2692 return Qnil;
2693 }
2694
2695 static Lisp_Object
2696 resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizontal, Lisp_Object ignore)
2697 {
2698 return call4 (Qwindow_resize_root_window, window, delta, horizontal, ignore);
2699 }
2700
2701
2702 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal,
2703 Sdelete_other_windows_internal, 0, 2, "",
2704 doc: /* Make WINDOW fill its frame.
2705 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2706 and defaults to the selected one.
2707
2708 Optional argument ROOT, if non-nil, must specify an internal window such
2709 that WINDOW is in its window subtree. If this is the case, replace ROOT
2710 by WINDOW and leave alone any windows not part of ROOT's subtree.
2711
2712 When WINDOW is live try to reduce display jumps by keeping the text
2713 previously visible in WINDOW in the same place on the frame. Doing this
2714 depends on the value of (window-start WINDOW), so if calling this
2715 function in a program gives strange scrolling, make sure the
2716 window-start value is reasonable when this function is called. */)
2717 (Lisp_Object window, Lisp_Object root)
2718 {
2719 struct window *w, *r, *s;
2720 struct frame *f;
2721 Lisp_Object sibling, pwindow, swindow IF_LINT (= Qnil), delta;
2722 ptrdiff_t startpos IF_LINT (= 0);
2723 int top IF_LINT (= 0), new_top, resize_failed;
2724
2725 w = decode_valid_window (window);
2726 XSETWINDOW (window, w);
2727 f = XFRAME (w->frame);
2728
2729 if (NILP (root))
2730 /* ROOT is the frame's root window. */
2731 {
2732 root = FRAME_ROOT_WINDOW (f);
2733 r = XWINDOW (root);
2734 }
2735 else
2736 /* ROOT must be an ancestor of WINDOW. */
2737 {
2738 r = decode_valid_window (root);
2739 pwindow = XWINDOW (window)->parent;
2740 while (!NILP (pwindow))
2741 if (EQ (pwindow, root))
2742 break;
2743 else
2744 pwindow = XWINDOW (pwindow)->parent;
2745 if (!EQ (pwindow, root))
2746 error ("Specified root is not an ancestor of specified window");
2747 }
2748
2749 if (EQ (window, root))
2750 /* A noop. */
2751 return Qnil;
2752 /* I don't understand the "top > 0" part below. If we deal with a
2753 standalone minibuffer it would have been caught by the preceding
2754 test. */
2755 else if (MINI_WINDOW_P (w)) /* && top > 0) */
2756 error ("Can't expand minibuffer to full frame");
2757
2758 if (!NILP (w->buffer))
2759 {
2760 startpos = marker_position (w->start);
2761 top = WINDOW_TOP_EDGE_LINE (w)
2762 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
2763 /* Make sure WINDOW is the frame's selected window. */
2764 if (!EQ (window, FRAME_SELECTED_WINDOW (f)))
2765 {
2766 if (EQ (selected_frame, w->frame))
2767 Fselect_window (window, Qnil);
2768 else
2769 fset_selected_window (f, window);
2770 }
2771 }
2772 else
2773 {
2774 /* See if the frame's selected window is a part of the window
2775 subtree rooted at WINDOW, by finding all the selected window's
2776 parents and comparing each one with WINDOW. If it isn't we
2777 need a new selected window for this frame. */
2778 swindow = FRAME_SELECTED_WINDOW (f);
2779 while (1)
2780 {
2781 pwindow = swindow;
2782 while (!NILP (pwindow) && !EQ (window, pwindow))
2783 pwindow = XWINDOW (pwindow)->parent;
2784
2785 if (EQ (window, pwindow))
2786 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2787 as the new selected window. */
2788 break;
2789 else
2790 /* Else try the previous window of SWINDOW. */
2791 swindow = Fprevious_window (swindow, Qlambda, Qnil);
2792 }
2793
2794 if (!EQ (swindow, FRAME_SELECTED_WINDOW (f)))
2795 {
2796 if (EQ (selected_frame, w->frame))
2797 Fselect_window (swindow, Qnil);
2798 else
2799 fset_selected_window (f, swindow);
2800 }
2801 }
2802
2803 block_input ();
2804 if (!FRAME_INITIAL_P (f))
2805 {
2806 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
2807
2808 /* We are going to free the glyph matrices of WINDOW, and with
2809 that we might lose any information about glyph rows that have
2810 some of their glyphs highlighted in mouse face. (These rows
2811 are marked with a non-zero mouse_face_p flag.) If WINDOW
2812 indeed has some glyphs highlighted in mouse face, signal to
2813 frame's up-to-date hook that mouse highlight was overwritten,
2814 so that it will arrange for redisplaying the highlight. */
2815 if (EQ (hlinfo->mouse_face_window, window))
2816 {
2817 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
2818 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
2819 hlinfo->mouse_face_window = Qnil;
2820 }
2821 }
2822 free_window_matrices (r);
2823
2824 windows_or_buffers_changed++;
2825 Vwindow_list = Qnil;
2826 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
2827 resize_failed = 0;
2828
2829 if (NILP (w->buffer))
2830 {
2831 /* Resize child windows vertically. */
2832 XSETINT (delta, XINT (r->total_lines)
2833 - XINT (w->total_lines));
2834 wset_top_line (w, r->top_line);
2835 resize_root_window (window, delta, Qnil, Qnil);
2836 if (window_resize_check (w, 0))
2837 window_resize_apply (w, 0);
2838 else
2839 {
2840 resize_root_window (window, delta, Qnil, Qt);
2841 if (window_resize_check (w, 0))
2842 window_resize_apply (w, 0);
2843 else
2844 resize_failed = 1;
2845 }
2846
2847 /* Resize child windows horizontally. */
2848 if (!resize_failed)
2849 {
2850 wset_left_col (w, r->left_col);
2851 XSETINT (delta,
2852 XINT (r->total_cols) - XINT (w->total_cols));
2853 wset_left_col (w, r->left_col);
2854 resize_root_window (window, delta, Qt, Qnil);
2855 if (window_resize_check (w, 1))
2856 window_resize_apply (w, 1);
2857 else
2858 {
2859 resize_root_window (window, delta, Qt, Qt);
2860 if (window_resize_check (w, 1))
2861 window_resize_apply (w, 1);
2862 else
2863 resize_failed = 1;
2864 }
2865 }
2866
2867 if (resize_failed)
2868 /* Play safe, if we still can ... */
2869 {
2870 window = swindow;
2871 w = XWINDOW (window);
2872 }
2873 }
2874
2875 /* Cleanly unlink WINDOW from window-tree. */
2876 if (!NILP (w->prev))
2877 /* Get SIBLING above (on the left of) WINDOW. */
2878 {
2879 sibling = w->prev;
2880 s = XWINDOW (sibling);
2881 wset_next (s, w->next);
2882 if (!NILP (s->next))
2883 wset_prev (XWINDOW (s->next), sibling);
2884 }
2885 else
2886 /* Get SIBLING below (on the right of) WINDOW. */
2887 {
2888 sibling = w->next;
2889 s = XWINDOW (sibling);
2890 wset_prev (s, Qnil);
2891 if (!NILP (XWINDOW (w->parent)->vchild))
2892 wset_vchild (XWINDOW (w->parent), sibling);
2893 else
2894 wset_hchild (XWINDOW (w->parent), sibling);
2895 }
2896
2897 /* Delete ROOT and all child windows of ROOT. */
2898 if (!NILP (r->vchild))
2899 {
2900 delete_all_child_windows (r->vchild);
2901 wset_vchild (r, Qnil);
2902 }
2903 else if (!NILP (r->hchild))
2904 {
2905 delete_all_child_windows (r->hchild);
2906 wset_hchild (r, Qnil);
2907 }
2908
2909 replace_window (root, window, 1);
2910
2911 /* This must become SWINDOW anyway ....... */
2912 if (!NILP (w->buffer) && !resize_failed)
2913 {
2914 /* Try to minimize scrolling, by setting the window start to the
2915 point will cause the text at the old window start to be at the
2916 same place on the frame. But don't try to do this if the
2917 window start is outside the visible portion (as might happen
2918 when the display is not current, due to typeahead). */
2919 new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
2920 if (new_top != top
2921 && startpos >= BUF_BEGV (XBUFFER (w->buffer))
2922 && startpos <= BUF_ZV (XBUFFER (w->buffer)))
2923 {
2924 struct position pos;
2925 struct buffer *obuf = current_buffer;
2926
2927 Fset_buffer (w->buffer);
2928 /* This computation used to temporarily move point, but that
2929 can have unwanted side effects due to text properties. */
2930 pos = *vmotion (startpos, -top, w);
2931
2932 set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
2933 wset_window_end_valid (w, Qnil);
2934 w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
2935 || FETCH_BYTE (pos.bytepos - 1) == '\n');
2936 /* We need to do this, so that the window-scroll-functions
2937 get called. */
2938 w->optional_new_start = 1;
2939
2940 set_buffer_internal (obuf);
2941 }
2942 }
2943
2944 adjust_glyphs (f);
2945 unblock_input ();
2946
2947 run_window_configuration_change_hook (f);
2948
2949 return Qnil;
2950 }
2951
2952
2953 void
2954 replace_buffer_in_windows (Lisp_Object buffer)
2955 {
2956 call1 (Qreplace_buffer_in_windows, buffer);
2957 }
2958
2959
2960 /* Safely replace BUFFER with some other buffer in all windows of all
2961 frames, even those on other keyboards. */
2962
2963 void
2964 replace_buffer_in_windows_safely (Lisp_Object buffer)
2965 {
2966 Lisp_Object tail, frame;
2967
2968 /* A single call to window_loop won't do the job because it only
2969 considers frames on the current keyboard. So loop manually over
2970 frames, and handle each one. */
2971 FOR_EACH_FRAME (tail, frame)
2972 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
2973 }
2974 \f
2975 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2976 minimum allowable size. */
2977
2978 void
2979 check_frame_size (FRAME_PTR frame, int *rows, int *cols)
2980 {
2981 /* For height, we have to see:
2982 how many windows the frame has at minimum (one or two),
2983 and whether it has a menu bar or other special stuff at the top. */
2984 int min_height
2985 = ((FRAME_MINIBUF_ONLY_P (frame) || ! FRAME_HAS_MINIBUF_P (frame))
2986 ? MIN_SAFE_WINDOW_HEIGHT
2987 : 2 * MIN_SAFE_WINDOW_HEIGHT);
2988
2989 if (FRAME_TOP_MARGIN (frame) > 0)
2990 min_height += FRAME_TOP_MARGIN (frame);
2991
2992 if (*rows < min_height)
2993 *rows = min_height;
2994 if (*cols < MIN_SAFE_WINDOW_WIDTH)
2995 *cols = MIN_SAFE_WINDOW_WIDTH;
2996 }
2997
2998 /* Adjust the margins of window W if text area is too small.
2999 Return 1 if window width is ok after adjustment; 0 if window
3000 is still too narrow. */
3001
3002 static int
3003 adjust_window_margins (struct window *w)
3004 {
3005 int box_cols = (WINDOW_TOTAL_COLS (w)
3006 - WINDOW_FRINGE_COLS (w)
3007 - WINDOW_SCROLL_BAR_COLS (w));
3008 int margin_cols = (WINDOW_LEFT_MARGIN_COLS (w)
3009 + WINDOW_RIGHT_MARGIN_COLS (w));
3010
3011 if (box_cols - margin_cols >= MIN_SAFE_WINDOW_WIDTH)
3012 return 1;
3013
3014 if (margin_cols < 0 || box_cols < MIN_SAFE_WINDOW_WIDTH)
3015 return 0;
3016
3017 /* Window's text area is too narrow, but reducing the window
3018 margins will fix that. */
3019 margin_cols = box_cols - MIN_SAFE_WINDOW_WIDTH;
3020 if (WINDOW_RIGHT_MARGIN_COLS (w) > 0)
3021 {
3022 if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
3023 {
3024 wset_left_margin_cols (w, make_number (margin_cols / 2));
3025 wset_right_margin_cols (w, make_number (margin_cols / 2));
3026 }
3027 else
3028 wset_right_margin_cols (w, make_number (margin_cols));
3029 }
3030 else
3031 wset_left_margin_cols (w, make_number (margin_cols));
3032 return 1;
3033 }
3034 \f
3035 /* The following three routines are needed for running a window's
3036 configuration change hook. */
3037 static void
3038 run_funs (Lisp_Object funs)
3039 {
3040 for (; CONSP (funs); funs = XCDR (funs))
3041 if (!EQ (XCAR (funs), Qt))
3042 call0 (XCAR (funs));
3043 }
3044
3045 static Lisp_Object
3046 select_window_norecord (Lisp_Object window)
3047 {
3048 return WINDOW_LIVE_P (window)
3049 ? Fselect_window (window, Qt) : selected_window;
3050 }
3051
3052 static Lisp_Object
3053 select_frame_norecord (Lisp_Object frame)
3054 {
3055 return FRAME_LIVE_P (XFRAME (frame))
3056 ? Fselect_frame (frame, Qt) : selected_frame;
3057 }
3058
3059 void
3060 run_window_configuration_change_hook (struct frame *f)
3061 {
3062 ptrdiff_t count = SPECPDL_INDEX ();
3063 Lisp_Object frame, global_wcch
3064 = Fdefault_value (Qwindow_configuration_change_hook);
3065 XSETFRAME (frame, f);
3066
3067 if (NILP (Vrun_hooks) || !NILP (inhibit_lisp_code))
3068 return;
3069
3070 /* Use the right buffer. Matters when running the local hooks. */
3071 if (current_buffer != XBUFFER (Fwindow_buffer (Qnil)))
3072 {
3073 record_unwind_current_buffer ();
3074 Fset_buffer (Fwindow_buffer (Qnil));
3075 }
3076
3077 if (SELECTED_FRAME () != f)
3078 {
3079 record_unwind_protect (select_frame_norecord, Fselected_frame ());
3080 select_frame_norecord (frame);
3081 }
3082
3083 /* Look for buffer-local values. */
3084 {
3085 Lisp_Object windows = Fwindow_list (frame, Qlambda, Qnil);
3086 for (; CONSP (windows); windows = XCDR (windows))
3087 {
3088 Lisp_Object window = XCAR (windows);
3089 Lisp_Object buffer = Fwindow_buffer (window);
3090 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook,
3091 buffer)))
3092 {
3093 ptrdiff_t inner_count = SPECPDL_INDEX ();
3094 record_unwind_protect (select_window_norecord, Fselected_window ());
3095 select_window_norecord (window);
3096 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook,
3097 buffer));
3098 unbind_to (inner_count, Qnil);
3099 }
3100 }
3101 }
3102
3103 run_funs (global_wcch);
3104 unbind_to (count, Qnil);
3105 }
3106
3107 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook,
3108 Srun_window_configuration_change_hook, 0, 1, 0,
3109 doc: /* Run `window-configuration-change-hook' for FRAME.
3110 If FRAME is omitted or nil, it defaults to the selected frame. */)
3111 (Lisp_Object frame)
3112 {
3113 run_window_configuration_change_hook (decode_live_frame (frame));
3114 return Qnil;
3115 }
3116
3117 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3118 means it's allowed to run hooks. See make_frame for a case where
3119 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3120 margins, fringes, and scroll-bar settings of the window are not
3121 reset from the buffer's local settings. */
3122
3123 void
3124 set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int keep_margins_p)
3125 {
3126 struct window *w = XWINDOW (window);
3127 struct buffer *b = XBUFFER (buffer);
3128 ptrdiff_t count = SPECPDL_INDEX ();
3129 int samebuf = EQ (buffer, w->buffer);
3130
3131 wset_buffer (w, buffer);
3132
3133 if (EQ (window, selected_window))
3134 bset_last_selected_window (b, window);
3135
3136 /* Let redisplay errors through. */
3137 b->display_error_modiff = 0;
3138
3139 /* Update time stamps of buffer display. */
3140 if (INTEGERP (BVAR (b, display_count)))
3141 bset_display_count (b, make_number (XINT (BVAR (b, display_count)) + 1));
3142 bset_display_time (b, Fcurrent_time ());
3143
3144 wset_window_end_pos (w, make_number (0));
3145 wset_window_end_vpos (w, make_number (0));
3146 memset (&w->last_cursor, 0, sizeof w->last_cursor);
3147 wset_window_end_valid (w, Qnil);
3148 if (!(keep_margins_p && samebuf))
3149 { /* If we're not actually changing the buffer, don't reset hscroll and
3150 vscroll. This case happens for example when called from
3151 change_frame_size_1, where we use a dummy call to
3152 Fset_window_buffer on the frame's selected window (and no other)
3153 just in order to run window-configuration-change-hook.
3154 Resetting hscroll and vscroll here is problematic for things like
3155 image-mode and doc-view-mode since it resets the image's position
3156 whenever we resize the frame. */
3157 w->hscroll = w->min_hscroll = 0;
3158 w->vscroll = 0;
3159 set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
3160 set_marker_restricted (w->start,
3161 make_number (b->last_window_start),
3162 buffer);
3163 w->start_at_line_beg = 0;
3164 w->force_start = 0;
3165 w->last_modified = 0;
3166 w->last_overlay_modified = 0;
3167 }
3168 /* Maybe we could move this into the `if' but it's not obviously safe and
3169 I doubt it's worth the trouble. */
3170 windows_or_buffers_changed++;
3171
3172 /* We must select BUFFER for running the window-scroll-functions. */
3173 /* We can't check ! NILP (Vwindow_scroll_functions) here
3174 because that might itself be a local variable. */
3175 if (window_initialized)
3176 {
3177 record_unwind_current_buffer ();
3178 Fset_buffer (buffer);
3179 }
3180
3181 XMARKER (w->pointm)->insertion_type = !NILP (Vwindow_point_insertion_type);
3182
3183 if (!keep_margins_p)
3184 {
3185 /* Set left and right marginal area width etc. from buffer. */
3186
3187 /* This may call adjust_window_margins three times, so
3188 temporarily disable window margins. */
3189 Lisp_Object save_left = w->left_margin_cols;
3190 Lisp_Object save_right = w->right_margin_cols;
3191
3192 wset_left_margin_cols (w, Qnil);
3193 wset_right_margin_cols (w, Qnil);
3194
3195 Fset_window_fringes (window,
3196 BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
3197 BVAR (b, fringes_outside_margins));
3198
3199 Fset_window_scroll_bars (window,
3200 BVAR (b, scroll_bar_width),
3201 BVAR (b, vertical_scroll_bar_type), Qnil);
3202
3203 wset_left_margin_cols (w, save_left);
3204 wset_right_margin_cols (w, save_right);
3205
3206 Fset_window_margins (window,
3207 BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
3208 }
3209
3210 if (run_hooks_p)
3211 {
3212 if (! NILP (Vwindow_scroll_functions))
3213 run_hook_with_args_2 (Qwindow_scroll_functions, window,
3214 Fmarker_position (w->start));
3215 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
3216 }
3217
3218 unbind_to (count, Qnil);
3219 }
3220
3221 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
3222 doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3223 WINDOW must be a live window and defaults to the selected one.
3224 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3225
3226 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3227 display margins, fringe widths, and scroll bar settings are preserved;
3228 the default is to reset these from the local settings for BUFFER-OR-NAME
3229 or the frame defaults. Return nil.
3230
3231 This function throws an error when WINDOW is strongly dedicated to its
3232 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3233 already display BUFFER-OR-NAME.
3234
3235 This function runs `window-scroll-functions' before running
3236 `window-configuration-change-hook'. */)
3237 (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
3238 {
3239 register Lisp_Object tem, buffer;
3240 register struct window *w = decode_live_window (window);
3241
3242 XSETWINDOW (window, w);
3243 buffer = Fget_buffer (buffer_or_name);
3244 CHECK_BUFFER (buffer);
3245 if (!BUFFER_LIVE_P (XBUFFER (buffer)))
3246 error ("Attempt to display deleted buffer");
3247
3248 tem = w->buffer;
3249 if (NILP (tem))
3250 error ("Window is deleted");
3251 else if (!EQ (tem, Qt))
3252 /* w->buffer is t when the window is first being set up. */
3253 {
3254 if (!EQ (tem, buffer))
3255 {
3256 if (EQ (w->dedicated, Qt))
3257 /* WINDOW is strongly dedicated to its buffer, signal an
3258 error. */
3259 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
3260 else
3261 /* WINDOW is weakly dedicated to its buffer, reset
3262 dedication. */
3263 wset_dedicated (w, Qnil);
3264
3265 call1 (Qrecord_window_buffer, window);
3266 }
3267
3268 unshow_buffer (w);
3269 }
3270
3271 set_window_buffer (window, buffer, 1, !NILP (keep_margins));
3272
3273 return Qnil;
3274 }
3275 \f
3276 static Lisp_Object
3277 display_buffer (Lisp_Object buffer, Lisp_Object not_this_window_p, Lisp_Object override_frame)
3278 {
3279 return call3 (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
3280 }
3281
3282 DEFUN ("force-window-update", Fforce_window_update, Sforce_window_update,
3283 0, 1, 0,
3284 doc: /* Force all windows to be updated on next redisplay.
3285 If optional arg OBJECT is a window, force redisplay of that window only.
3286 If OBJECT is a buffer or buffer name, force redisplay of all windows
3287 displaying that buffer. */)
3288 (Lisp_Object object)
3289 {
3290 if (NILP (object))
3291 {
3292 windows_or_buffers_changed++;
3293 update_mode_lines++;
3294 return Qt;
3295 }
3296
3297 if (WINDOWP (object))
3298 {
3299 struct window *w = XWINDOW (object);
3300 mark_window_display_accurate (object, 0);
3301 w->update_mode_line = 1;
3302 if (BUFFERP (w->buffer))
3303 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
3304 ++update_mode_lines;
3305 return Qt;
3306 }
3307
3308 if (STRINGP (object))
3309 object = Fget_buffer (object);
3310 if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))
3311 {
3312 /* Walk all windows looking for buffer, and force update
3313 of each of those windows. */
3314
3315 object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, 0, Qvisible);
3316 return NILP (object) ? Qnil : Qt;
3317 }
3318
3319 /* If nothing suitable was found, just return.
3320 We could signal an error, but this feature will typically be used
3321 asynchronously in timers or process sentinels, so we don't. */
3322 return Qnil;
3323 }
3324
3325 /* Obsolete since 24.3. */
3326 void
3327 temp_output_buffer_show (register Lisp_Object buf)
3328 {
3329 register struct buffer *old = current_buffer;
3330 register Lisp_Object window;
3331 register struct window *w;
3332
3333 bset_directory (XBUFFER (buf), BVAR (current_buffer, directory));
3334
3335 Fset_buffer (buf);
3336 BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
3337 BEGV = BEG;
3338 ZV = Z;
3339 SET_PT (BEG);
3340 set_buffer_internal (old);
3341
3342 if (!NILP (Vtemp_buffer_show_function))
3343 call1 (Vtemp_buffer_show_function, buf);
3344 else
3345 {
3346 window = display_buffer (buf, Qnil, Qnil);
3347
3348 if (!EQ (XWINDOW (window)->frame, selected_frame))
3349 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
3350 Vminibuf_scroll_window = window;
3351 w = XWINDOW (window);
3352 w->hscroll = 0;
3353 w->min_hscroll = 0;
3354 set_marker_restricted_both (w->start, buf, BEG, BEG);
3355 set_marker_restricted_both (w->pointm, buf, BEG, BEG);
3356
3357 /* Run temp-buffer-show-hook, with the chosen window selected
3358 and its buffer current. */
3359 {
3360 ptrdiff_t count = SPECPDL_INDEX ();
3361 Lisp_Object prev_window, prev_buffer;
3362 prev_window = selected_window;
3363 XSETBUFFER (prev_buffer, old);
3364
3365 /* Select the window that was chosen, for running the hook.
3366 Note: Both Fselect_window and select_window_norecord may
3367 set-buffer to the buffer displayed in the window,
3368 so we need to save the current buffer. --stef */
3369 record_unwind_protect (Fset_buffer, prev_buffer);
3370 record_unwind_protect (select_window_norecord, prev_window);
3371 Fselect_window (window, Qt);
3372 Fset_buffer (w->buffer);
3373 Frun_hooks (1, &Qtemp_buffer_show_hook);
3374 unbind_to (count, Qnil);
3375 }
3376 }
3377 }
3378 \f
3379 /* Make new window, have it replace WINDOW in window-tree, and make
3380 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3381 horizontal child). */
3382 static void
3383 make_parent_window (Lisp_Object window, int horflag)
3384 {
3385 Lisp_Object parent;
3386 register struct window *o, *p;
3387
3388 o = XWINDOW (window);
3389 p = allocate_window ();
3390 memcpy ((char *) p + sizeof (struct vectorlike_header),
3391 (char *) o + sizeof (struct vectorlike_header),
3392 word_size * VECSIZE (struct window));
3393 XSETWINDOW (parent, p);
3394
3395 p->sequence_number = ++sequence_number;
3396
3397 replace_window (window, parent, 1);
3398
3399 wset_next (o, Qnil);
3400 wset_prev (o, Qnil);
3401 wset_parent (o, parent);
3402
3403 wset_hchild (p, horflag ? window : Qnil);
3404 wset_vchild (p, horflag ? Qnil : window);
3405 wset_start (p, Qnil);
3406 wset_pointm (p, Qnil);
3407 wset_buffer (p, Qnil);
3408 wset_combination_limit (p, Qnil);
3409 wset_window_parameters (p, Qnil);
3410 }
3411
3412 /* Make new window from scratch. */
3413 Lisp_Object
3414 make_window (void)
3415 {
3416 Lisp_Object window;
3417 register struct window *w;
3418
3419 w = allocate_window ();
3420 /* Initialize Lisp data. Note that allocate_window initializes all
3421 Lisp data to nil, so do it only for slots which should not be nil. */
3422 wset_left_col (w, make_number (0));
3423 wset_top_line (w, make_number (0));
3424 wset_total_lines (w, make_number (0));
3425 wset_total_cols (w, make_number (0));
3426 wset_normal_lines (w, make_float (1.0));
3427 wset_normal_cols (w, make_float (1.0));
3428 wset_new_total (w, make_number (0));
3429 wset_new_normal (w, make_number (0));
3430 wset_start (w, Fmake_marker ());
3431 wset_pointm (w, Fmake_marker ());
3432 wset_vertical_scroll_bar_type (w, Qt);
3433 wset_window_end_pos (w, make_number (0));
3434 wset_window_end_vpos (w, make_number (0));
3435 /* These Lisp fields are marked specially so they're not set to nil by
3436 allocate_window. */
3437 wset_prev_buffers (w, Qnil);
3438 wset_next_buffers (w, Qnil);
3439
3440 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3441 non-Lisp data, so do it only for slots which should not be zero. */
3442 w->nrows_scale_factor = w->ncols_scale_factor = 1;
3443 w->phys_cursor_type = -1;
3444 w->phys_cursor_width = -1;
3445 w->sequence_number = ++sequence_number;
3446
3447 /* Reset window_list. */
3448 Vwindow_list = Qnil;
3449 /* Return window. */
3450 XSETWINDOW (window, w);
3451 return window;
3452 }
3453 \f
3454 DEFUN ("set-window-new-total", Fset_window_new_total, Sset_window_new_total, 2, 3, 0,
3455 doc: /* Set new total size of WINDOW to SIZE.
3456 WINDOW must be a valid window and defaults to the selected one.
3457 Return SIZE.
3458
3459 Optional argument ADD non-nil means add SIZE to the new total size of
3460 WINDOW and return the sum.
3461
3462 Note: This function does not operate on any child windows of WINDOW. */)
3463 (Lisp_Object window, Lisp_Object size, Lisp_Object add)
3464 {
3465 struct window *w = decode_valid_window (window);
3466
3467 CHECK_NUMBER (size);
3468 if (NILP (add))
3469 wset_new_total (w, size);
3470 else
3471 wset_new_total (w, make_number (XINT (w->new_total) + XINT (size)));
3472
3473 return w->new_total;
3474 }
3475
3476 DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal, 1, 2, 0,
3477 doc: /* Set new normal size of WINDOW to SIZE.
3478 WINDOW must be a valid window and defaults to the selected one.
3479 Return SIZE.
3480
3481 Note: This function does not operate on any child windows of WINDOW. */)
3482 (Lisp_Object window, Lisp_Object size)
3483 {
3484 wset_new_normal (decode_valid_window (window), size);
3485 return size;
3486 }
3487
3488 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3489 non-zero) to w->new_total would result in correct heights (widths)
3490 for window W and recursively all child windows of W.
3491
3492 Note: This function does not check any of `window-fixed-size-p',
3493 `window-min-height' or `window-min-width'. It does check that window
3494 sizes do not drop below one line (two columns). */
3495 static int
3496 window_resize_check (struct window *w, int horflag)
3497 {
3498 struct window *c;
3499
3500 if (!NILP (w->vchild))
3501 /* W is a vertical combination. */
3502 {
3503 c = XWINDOW (w->vchild);
3504 if (horflag)
3505 /* All child windows of W must have the same width as W. */
3506 {
3507 while (c)
3508 {
3509 if ((XINT (c->new_total) != XINT (w->new_total))
3510 || !window_resize_check (c, horflag))
3511 return 0;
3512 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3513 }
3514 return 1;
3515 }
3516 else
3517 /* The sum of the heights of the child windows of W must equal
3518 W's height. */
3519 {
3520 int sum_of_sizes = 0;
3521 while (c)
3522 {
3523 if (!window_resize_check (c, horflag))
3524 return 0;
3525 sum_of_sizes = sum_of_sizes + XINT (c->new_total);
3526 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3527 }
3528 return (sum_of_sizes == XINT (w->new_total));
3529 }
3530 }
3531 else if (!NILP (w->hchild))
3532 /* W is a horizontal combination. */
3533 {
3534 c = XWINDOW (w->hchild);
3535 if (horflag)
3536 /* The sum of the widths of the child windows of W must equal W's
3537 width. */
3538 {
3539 int sum_of_sizes = 0;
3540 while (c)
3541 {
3542 if (!window_resize_check (c, horflag))
3543 return 0;
3544 sum_of_sizes = sum_of_sizes + XINT (c->new_total);
3545 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3546 }
3547 return (sum_of_sizes == XINT (w->new_total));
3548 }
3549 else
3550 /* All child windows of W must have the same height as W. */
3551 {
3552 while (c)
3553 {
3554 if ((XINT (c->new_total) != XINT (w->new_total))
3555 || !window_resize_check (c, horflag))
3556 return 0;
3557 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3558 }
3559 return 1;
3560 }
3561 }
3562 else
3563 /* A leaf window. Make sure it's not too small. The following
3564 hardcodes the values of `window-safe-min-width' (2) and
3565 `window-safe-min-height' (1) which are defined in window.el. */
3566 return XINT (w->new_total) >= (horflag ? 2 : 1);
3567 }
3568
3569 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3570 w->new_total for window W and recursively all child windows of W.
3571 Also calculate and assign the new vertical (horizontal) start
3572 positions of each of these windows.
3573
3574 This function does not perform any error checks. Make sure you have
3575 run window_resize_check on W before applying this function. */
3576 static void
3577 window_resize_apply (struct window *w, int horflag)
3578 {
3579 struct window *c;
3580 int pos;
3581
3582 /* Note: Assigning new_normal requires that the new total size of the
3583 parent window has been set *before*. */
3584 if (horflag)
3585 {
3586 wset_total_cols (w, w->new_total);
3587 if (NUMBERP (w->new_normal))
3588 wset_normal_cols (w, w->new_normal);
3589
3590 pos = XINT (w->left_col);
3591 }
3592 else
3593 {
3594 wset_total_lines (w, w->new_total);
3595 if (NUMBERP (w->new_normal))
3596 wset_normal_lines (w, w->new_normal);
3597
3598 pos = XINT (w->top_line);
3599 }
3600
3601 if (!NILP (w->vchild))
3602 /* W is a vertical combination. */
3603 {
3604 c = XWINDOW (w->vchild);
3605 while (c)
3606 {
3607 if (horflag)
3608 wset_left_col (c, make_number (pos));
3609 else
3610 wset_top_line (c, make_number (pos));
3611 window_resize_apply (c, horflag);
3612 if (!horflag)
3613 pos = pos + XINT (c->total_lines);
3614 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3615 }
3616 }
3617 else if (!NILP (w->hchild))
3618 /* W is a horizontal combination. */
3619 {
3620 c = XWINDOW (w->hchild);
3621 while (c)
3622 {
3623 if (horflag)
3624 wset_left_col (c, make_number (pos));
3625 else
3626 wset_top_line (c, make_number (pos));
3627 window_resize_apply (c, horflag);
3628 if (horflag)
3629 pos = pos + XINT (c->total_cols);
3630 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3631 }
3632 }
3633
3634 /* Clear out some redisplay caches. */
3635 w->last_modified = 0;
3636 w->last_overlay_modified = 0;
3637 }
3638
3639
3640 DEFUN ("window-resize-apply", Fwindow_resize_apply, Swindow_resize_apply, 0, 2, 0,
3641 doc: /* Apply requested size values for window-tree of FRAME.
3642 If FRAME is omitted or nil, it defaults to the selected frame.
3643
3644 Optional argument HORIZONTAL omitted or nil means apply requested
3645 height values. HORIZONTAL non-nil means apply requested width values.
3646
3647 This function checks whether the requested values sum up to a valid
3648 window layout, recursively assigns the new sizes of all child windows
3649 and calculates and assigns the new start positions of these windows.
3650
3651 Note: This function does not check any of `window-fixed-size-p',
3652 `window-min-height' or `window-min-width'. All these checks have to
3653 be applied on the Elisp level. */)
3654 (Lisp_Object frame, Lisp_Object horizontal)
3655 {
3656 struct frame *f = decode_live_frame (frame);
3657 struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
3658 int horflag = !NILP (horizontal);
3659
3660 if (!window_resize_check (r, horflag)
3661 || ! EQ (r->new_total,
3662 (horflag ? r->total_cols : r->total_lines)))
3663 return Qnil;
3664
3665 block_input ();
3666 window_resize_apply (r, horflag);
3667
3668 windows_or_buffers_changed++;
3669 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
3670
3671 adjust_glyphs (f);
3672 unblock_input ();
3673
3674 run_window_configuration_change_hook (f);
3675
3676 return Qt;
3677 }
3678
3679
3680 /* Resize frame F's windows when number of lines of F is set to SIZE.
3681 HORFLAG 1 means resize windows when number of columns of F is set to
3682 SIZE.
3683
3684 This function can delete all windows but the selected one in order to
3685 satisfy the request. The result will be meaningful if and only if
3686 F's windows have meaningful sizes when you call this. */
3687 void
3688 resize_frame_windows (struct frame *f, int size, int horflag)
3689 {
3690 Lisp_Object root = f->root_window;
3691 struct window *r = XWINDOW (root);
3692 Lisp_Object mini = f->minibuffer_window;
3693 struct window *m;
3694 /* new_size is the new size of the frame's root window. */
3695 int new_size = (horflag
3696 ? size
3697 : (size
3698 - FRAME_TOP_MARGIN (f)
3699 - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
3700 ? 1 : 0)));
3701
3702 wset_top_line (r, make_number (FRAME_TOP_MARGIN (f)));
3703 if (NILP (r->vchild) && NILP (r->hchild))
3704 /* For a leaf root window just set the size. */
3705 if (horflag)
3706 wset_total_cols (r, make_number (new_size));
3707 else
3708 wset_total_lines (r, make_number (new_size));
3709 else
3710 {
3711 /* old_size is the old size of the frame's root window. */
3712 int old_size = XFASTINT (horflag ? r->total_cols
3713 : r->total_lines);
3714 Lisp_Object delta;
3715
3716 XSETINT (delta, new_size - old_size);
3717 /* Try a "normal" resize first. */
3718 resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil);
3719 if (window_resize_check (r, horflag)
3720 && new_size == XINT (r->new_total))
3721 window_resize_apply (r, horflag);
3722 else
3723 {
3724 /* Try with "reasonable" minimum sizes next. */
3725 resize_root_window (root, delta, horflag ? Qt : Qnil, Qt);
3726 if (window_resize_check (r, horflag)
3727 && new_size == XINT (r->new_total))
3728 window_resize_apply (r, horflag);
3729 else
3730 {
3731 /* Finally, try with "safe" minimum sizes. */
3732 resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe);
3733 if (window_resize_check (r, horflag)
3734 && new_size == XINT (r->new_total))
3735 window_resize_apply (r, horflag);
3736 else
3737 {
3738 /* We lost. Delete all windows but the frame's
3739 selected one. */
3740 root = f->selected_window;
3741 Fdelete_other_windows_internal (root, Qnil);
3742 if (horflag)
3743 wset_total_cols (XWINDOW (root), make_number (new_size));
3744 else
3745 wset_total_lines (XWINDOW (root), make_number (new_size));
3746 }
3747 }
3748 }
3749 }
3750
3751 if (FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
3752 {
3753 m = XWINDOW (mini);
3754 if (horflag)
3755 wset_total_cols (m, make_number (size));
3756 else
3757 {
3758 /* Are we sure we always want 1 line here? */
3759 wset_total_lines (m, make_number (1));
3760 wset_top_line
3761 (m, make_number (XINT (r->top_line) + XINT (r->total_lines)));
3762 }
3763 }
3764
3765 windows_or_buffers_changed++;
3766 }
3767
3768
3769 DEFUN ("split-window-internal", Fsplit_window_internal, Ssplit_window_internal, 4, 4, 0,
3770 doc: /* Split window OLD.
3771 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3772 new window. In any case TOTAL-SIZE must be a positive integer.
3773
3774 Third argument SIDE nil (or `below') specifies that the new window shall
3775 be located below WINDOW. SIDE `above' means the new window shall be
3776 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3777 lines of the new window including space reserved for the mode and/or
3778 header line.
3779
3780 SIDE t (or `right') specifies that the new window shall be located on
3781 the right side of WINDOW. SIDE `left' means the new window shall be
3782 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3783 number of columns of the new window including space reserved for fringes
3784 and the scrollbar or a divider column.
3785
3786 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3787 according to the SIDE argument.
3788
3789 The new total and normal sizes of all involved windows must have been
3790 set correctly. See the code of `split-window' for how this is done. */)
3791 (Lisp_Object old, Lisp_Object total_size, Lisp_Object side, Lisp_Object normal_size)
3792 {
3793 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3794 parent window or an internal window we have to install as OLD's new
3795 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3796 provided OLD is a leaf window, or to the frame's selected window.
3797 NEW (*n) is the new window created with some parameters taken from
3798 REFERENCE (*r). */
3799 register Lisp_Object new, frame, reference;
3800 register struct window *o, *p, *n, *r;
3801 struct frame *f;
3802 int horflag
3803 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3804 = EQ (side, Qt) || EQ (side, Qleft) || EQ (side, Qright);
3805 int combination_limit = 0;
3806
3807 CHECK_WINDOW (old);
3808 o = XWINDOW (old);
3809 frame = WINDOW_FRAME (o);
3810 f = XFRAME (frame);
3811
3812 CHECK_NUMBER (total_size);
3813
3814 /* Set combination_limit to 1 if we have to make a new parent window.
3815 We do that if either `window-combination-limit' is t, or OLD has no
3816 parent, or OLD is ortho-combined. */
3817 combination_limit =
3818 EQ (Vwindow_combination_limit, Qt)
3819 || NILP (o->parent)
3820 || NILP (horflag
3821 ? (XWINDOW (o->parent)->hchild)
3822 : (XWINDOW (o->parent)->vchild));
3823
3824 /* We need a live reference window to initialize some parameters. */
3825 if (WINDOW_LIVE_P (old))
3826 /* OLD is live, use it as reference window. */
3827 reference = old;
3828 else
3829 /* Use the frame's selected window as reference window. */
3830 reference = FRAME_SELECTED_WINDOW (f);
3831 r = XWINDOW (reference);
3832
3833 /* The following bugs are caught by `split-window'. */
3834 if (MINI_WINDOW_P (o))
3835 error ("Attempt to split minibuffer window");
3836 else if (XINT (total_size) < (horflag ? 2 : 1))
3837 error ("Size of new window too small (after split)");
3838 else if (!combination_limit && !NILP (Vwindow_combination_resize))
3839 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3840 proportionally. */
3841 {
3842 p = XWINDOW (o->parent);
3843 /* Temporarily pretend we split the parent window. */
3844 wset_new_total
3845 (p, make_number (XINT (horflag ? p->total_cols : p->total_lines)
3846 - XINT (total_size)));
3847 if (!window_resize_check (p, horflag))
3848 error ("Window sizes don't fit");
3849 else
3850 /* Undo the temporary pretension. */
3851 wset_new_total (p, horflag ? p->total_cols : p->total_lines);
3852 }
3853 else
3854 {
3855 if (!window_resize_check (o, horflag))
3856 error ("Resizing old window failed");
3857 else if (XINT (total_size) + XINT (o->new_total)
3858 != XINT (horflag ? o->total_cols : o->total_lines))
3859 error ("Sum of sizes of old and new window don't fit");
3860 }
3861
3862 /* This is our point of no return. */
3863 if (combination_limit)
3864 {
3865 /* Save the old value of o->normal_cols/lines. It gets corrupted
3866 by make_parent_window and we need it below for assigning it to
3867 p->new_normal. */
3868 Lisp_Object new_normal
3869 = horflag ? o->normal_cols : o->normal_lines;
3870
3871 make_parent_window (old, horflag);
3872 p = XWINDOW (o->parent);
3873 /* Store t in the new parent's combination_limit slot to avoid
3874 that its children get merged into another window. */
3875 wset_combination_limit (p, Qt);
3876 /* These get applied below. */
3877 wset_new_total (p, horflag ? o->total_cols : o->total_lines);
3878 wset_new_normal (p, new_normal);
3879 }
3880 else
3881 p = XWINDOW (o->parent);
3882
3883 windows_or_buffers_changed++;
3884 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
3885 new = make_window ();
3886 n = XWINDOW (new);
3887 wset_frame (n, frame);
3888 wset_parent (n, o->parent);
3889 wset_vchild (n, Qnil);
3890 wset_hchild (n, Qnil);
3891
3892 if (EQ (side, Qabove) || EQ (side, Qleft))
3893 {
3894 wset_prev (n, o->prev);
3895 if (NILP (n->prev))
3896 if (horflag)
3897 wset_hchild (p, new);
3898 else
3899 wset_vchild (p, new);
3900 else
3901 wset_next (XWINDOW (n->prev), new);
3902 wset_next (n, old);
3903 wset_prev (o, new);
3904 }
3905 else
3906 {
3907 wset_next (n, o->next);
3908 if (!NILP (n->next))
3909 wset_prev (XWINDOW (n->next), new);
3910 wset_prev (n, old);
3911 wset_next (o, new);
3912 }
3913
3914 wset_buffer (n, Qt);
3915 wset_window_end_valid (n, Qnil);
3916 memset (&n->last_cursor, 0, sizeof n->last_cursor);
3917
3918 /* Get special geometry settings from reference window. */
3919 wset_left_margin_cols (n, r->left_margin_cols);
3920 wset_right_margin_cols (n, r->right_margin_cols);
3921 wset_left_fringe_width (n, r->left_fringe_width);
3922 wset_right_fringe_width (n, r->right_fringe_width);
3923 n->fringes_outside_margins = r->fringes_outside_margins;
3924 wset_scroll_bar_width (n, r->scroll_bar_width);
3925 wset_vertical_scroll_bar_type (n, r->vertical_scroll_bar_type);
3926
3927 /* Directly assign orthogonal coordinates and sizes. */
3928 if (horflag)
3929 {
3930 wset_top_line (n, o->top_line);
3931 wset_total_lines (n, o->total_lines);
3932 }
3933 else
3934 {
3935 wset_left_col (n, o->left_col);
3936 wset_total_cols (n, o->total_cols);
3937 }
3938
3939 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3940 get them ready here. */
3941 wset_new_total (n, total_size);
3942 wset_new_normal (n, normal_size);
3943
3944 block_input ();
3945 window_resize_apply (p, horflag);
3946 adjust_glyphs (f);
3947 /* Set buffer of NEW to buffer of reference window. Don't run
3948 any hooks. */
3949 set_window_buffer (new, r->buffer, 0, 1);
3950 unblock_input ();
3951
3952 /* Maybe we should run the scroll functions in Elisp (which already
3953 runs the configuration change hook). */
3954 if (! NILP (Vwindow_scroll_functions))
3955 run_hook_with_args_2 (Qwindow_scroll_functions, new,
3956 Fmarker_position (n->start));
3957 /* Return NEW. */
3958 return new;
3959 }
3960
3961
3962 DEFUN ("delete-window-internal", Fdelete_window_internal, Sdelete_window_internal, 1, 1, 0,
3963 doc: /* Remove WINDOW from its frame.
3964 WINDOW defaults to the selected window. Return nil.
3965 Signal an error when WINDOW is the only window on its frame. */)
3966 (register Lisp_Object window)
3967 {
3968 register Lisp_Object parent, sibling, frame, root;
3969 struct window *w, *p, *s, *r;
3970 struct frame *f;
3971 int horflag;
3972 int before_sibling = 0;
3973
3974 w = decode_any_window (window);
3975 XSETWINDOW (window, w);
3976 if (NILP (w->buffer)
3977 && NILP (w->hchild) && NILP (w->vchild))
3978 /* It's a no-op to delete an already deleted window. */
3979 return Qnil;
3980
3981 parent = w->parent;
3982 if (NILP (parent))
3983 /* Never delete a minibuffer or frame root window. */
3984 error ("Attempt to delete minibuffer or sole ordinary window");
3985 else if (NILP (w->prev) && NILP (w->next))
3986 /* Rather bow out here, this case should be handled on the Elisp
3987 level. */
3988 error ("Attempt to delete sole window of parent");
3989
3990 p = XWINDOW (parent);
3991 horflag = NILP (p->vchild);
3992
3993 frame = WINDOW_FRAME (w);
3994 f = XFRAME (frame);
3995
3996 root = FRAME_ROOT_WINDOW (f);
3997 r = XWINDOW (root);
3998
3999 /* Unlink WINDOW from window tree. */
4000 if (NILP (w->prev))
4001 /* Get SIBLING below (on the right of) WINDOW. */
4002 {
4003 /* before_sibling 1 means WINDOW is the first child of its
4004 parent and thus before the sibling. */
4005 before_sibling = 1;
4006 sibling = w->next;
4007 s = XWINDOW (sibling);
4008 wset_prev (s, Qnil);
4009 if (horflag)
4010 wset_hchild (p, sibling);
4011 else
4012 wset_vchild (p, sibling);
4013 }
4014 else
4015 /* Get SIBLING above (on the left of) WINDOW. */
4016 {
4017 sibling = w->prev;
4018 s = XWINDOW (sibling);
4019 wset_next (s, w->next);
4020 if (!NILP (s->next))
4021 wset_prev (XWINDOW (s->next), sibling);
4022 }
4023
4024 if (window_resize_check (r, horflag)
4025 && EQ (r->new_total,
4026 (horflag ? r->total_cols : r->total_lines)))
4027 /* We can delete WINDOW now. */
4028 {
4029
4030 /* Block input. */
4031 block_input ();
4032 #ifdef HAVE_XWIDGETS
4033 xwidget_view_delete_all_in_window(w);
4034 #endif
4035 window_resize_apply (p, horflag);
4036
4037 /* If this window is referred to by the dpyinfo's mouse
4038 highlight, invalidate that slot to be safe (Bug#9904). */
4039 if (!FRAME_INITIAL_P (f))
4040 {
4041 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
4042
4043 if (EQ (hlinfo->mouse_face_window, window))
4044 hlinfo->mouse_face_window = Qnil;
4045 }
4046
4047 windows_or_buffers_changed++;
4048 Vwindow_list = Qnil;
4049 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
4050
4051 wset_next (w, Qnil); /* Don't delete w->next too. */
4052 free_window_matrices (w);
4053
4054 if (!NILP (w->vchild))
4055 {
4056 delete_all_child_windows (w->vchild);
4057 wset_vchild (w, Qnil);
4058 }
4059 else if (!NILP (w->hchild))
4060 {
4061 delete_all_child_windows (w->hchild);
4062 wset_hchild (w, Qnil);
4063 }
4064 else if (!NILP (w->buffer))
4065 {
4066 unshow_buffer (w);
4067 unchain_marker (XMARKER (w->pointm));
4068 unchain_marker (XMARKER (w->start));
4069 wset_buffer (w, Qnil);
4070 }
4071
4072 if (NILP (s->prev) && NILP (s->next))
4073 /* A matrjoshka where SIBLING has become the only child of
4074 PARENT. */
4075 {
4076 /* Put SIBLING into PARENT's place. */
4077 replace_window (parent, sibling, 0);
4078 /* Have SIBLING inherit the following three slot values from
4079 PARENT (the combination_limit slot is not inherited). */
4080 wset_normal_cols (s, p->normal_cols);
4081 wset_normal_lines (s, p->normal_lines);
4082 /* Mark PARENT as deleted. */
4083 wset_vchild (p, Qnil);
4084 wset_hchild (p, Qnil);
4085 /* Try to merge SIBLING into its new parent. */
4086 recombine_windows (sibling);
4087 }
4088
4089 adjust_glyphs (f);
4090
4091 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f)))
4092 /* We deleted the frame's selected window. */
4093 {
4094 /* Use the frame's first window as fallback ... */
4095 Lisp_Object new_selected_window = Fframe_first_window (frame);
4096 /* ... but preferably use its most recently used window. */
4097 Lisp_Object mru_window;
4098
4099 /* `get-mru-window' might fail for some reason so play it safe
4100 - promote the first window _without recording it_ first. */
4101 if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
4102 Fselect_window (new_selected_window, Qt);
4103 else
4104 fset_selected_window (f, new_selected_window);
4105
4106 unblock_input ();
4107
4108 /* Now look whether `get-mru-window' gets us something. */
4109 mru_window = call1 (Qget_mru_window, frame);
4110 if (WINDOW_LIVE_P (mru_window)
4111 && EQ (XWINDOW (mru_window)->frame, frame))
4112 new_selected_window = mru_window;
4113
4114 /* If all ended up well, we now promote the mru window. */
4115 if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
4116 Fselect_window (new_selected_window, Qnil);
4117 else
4118 fset_selected_window (f, new_selected_window);
4119 }
4120 else
4121 unblock_input ();
4122
4123 /* Must be run by the caller:
4124 run_window_configuration_change_hook (f); */
4125 }
4126 else
4127 /* We failed: Relink WINDOW into window tree. */
4128 {
4129 if (before_sibling)
4130 {
4131 wset_prev (s, window);
4132 if (horflag)
4133 wset_hchild (p, window);
4134 else
4135 wset_vchild (p, window);
4136 }
4137 else
4138 {
4139 wset_next (s, window);
4140 if (!NILP (w->next))
4141 wset_prev (XWINDOW (w->next), window);
4142 }
4143 error ("Deletion failed");
4144 }
4145
4146 return Qnil;
4147 }
4148 \f
4149 /***********************************************************************
4150 Resizing Mini-Windows
4151 ***********************************************************************/
4152
4153 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4154 can. */
4155 void
4156 grow_mini_window (struct window *w, int delta)
4157 {
4158 struct frame *f = XFRAME (w->frame);
4159 struct window *r;
4160 Lisp_Object root, value;
4161
4162 eassert (MINI_WINDOW_P (w));
4163 eassert (delta >= 0);
4164
4165 root = FRAME_ROOT_WINDOW (f);
4166 r = XWINDOW (root);
4167 value = call2 (Qwindow_resize_root_window_vertically,
4168 root, make_number (- delta));
4169 if (INTEGERP (value) && window_resize_check (r, 0))
4170 {
4171 block_input ();
4172 window_resize_apply (r, 0);
4173
4174 /* Grow the mini-window. */
4175 wset_top_line
4176 (w, make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
4177 wset_total_lines
4178 (w, make_number (XFASTINT (w->total_lines) - XINT (value)));
4179 w->last_modified = 0;
4180 w->last_overlay_modified = 0;
4181
4182 windows_or_buffers_changed++;
4183 adjust_glyphs (f);
4184 unblock_input ();
4185 }
4186 }
4187
4188
4189 /* Shrink mini-window W. */
4190 void
4191 shrink_mini_window (struct window *w)
4192 {
4193 struct frame *f = XFRAME (w->frame);
4194 struct window *r;
4195 Lisp_Object root, value;
4196 EMACS_INT size;
4197
4198 eassert (MINI_WINDOW_P (w));
4199
4200 size = XINT (w->total_lines);
4201 if (size > 1)
4202 {
4203 root = FRAME_ROOT_WINDOW (f);
4204 r = XWINDOW (root);
4205 value = call2 (Qwindow_resize_root_window_vertically,
4206 root, make_number (size - 1));
4207 if (INTEGERP (value) && window_resize_check (r, 0))
4208 {
4209 block_input ();
4210 window_resize_apply (r, 0);
4211
4212 /* Shrink the mini-window. */
4213 wset_top_line (w, make_number (XFASTINT (r->top_line)
4214 + XFASTINT (r->total_lines)));
4215 wset_total_lines (w, make_number (1));
4216
4217 w->last_modified = 0;
4218 w->last_overlay_modified = 0;
4219
4220 windows_or_buffers_changed++;
4221 adjust_glyphs (f);
4222 unblock_input ();
4223 }
4224 /* If the above failed for whatever strange reason we must make a
4225 one window frame here. The same routine will be needed when
4226 shrinking the frame (and probably when making the initial
4227 *scratch* window). For the moment leave things as they are. */
4228 }
4229 }
4230
4231 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini_window_internal, 1, 1, 0,
4232 doc: /* Resize minibuffer window WINDOW. */)
4233 (Lisp_Object window)
4234 {
4235 struct window *w = XWINDOW (window);
4236 struct window *r;
4237 struct frame *f;
4238 int height;
4239
4240 CHECK_WINDOW (window);
4241 f = XFRAME (w->frame);
4242
4243 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w->frame)), window))
4244 error ("Not a valid minibuffer window");
4245 else if (FRAME_MINIBUF_ONLY_P (f))
4246 error ("Cannot resize a minibuffer-only frame");
4247
4248 r = XWINDOW (FRAME_ROOT_WINDOW (f));
4249 height = XINT (r->total_lines) + XINT (w->total_lines);
4250 if (window_resize_check (r, 0)
4251 && XINT (w->new_total) > 0
4252 && height == XINT (r->new_total) + XINT (w->new_total))
4253 {
4254 block_input ();
4255 window_resize_apply (r, 0);
4256
4257 wset_total_lines (w, w->new_total);
4258 wset_top_line (w, make_number (XINT (r->top_line)
4259 + XINT (r->total_lines)));
4260
4261 windows_or_buffers_changed++;
4262 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
4263 adjust_glyphs (f);
4264 unblock_input ();
4265
4266 run_window_configuration_change_hook (f);
4267 return Qt;
4268 }
4269 else error ("Failed to resize minibuffer window");
4270 }
4271 \f
4272 /* Mark window cursors off for all windows in the window tree rooted
4273 at W by setting their phys_cursor_on_p flag to zero. Called from
4274 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4275 the frame are cleared. */
4276
4277 void
4278 mark_window_cursors_off (struct window *w)
4279 {
4280 while (w)
4281 {
4282 if (!NILP (w->hchild))
4283 mark_window_cursors_off (XWINDOW (w->hchild));
4284 else if (!NILP (w->vchild))
4285 mark_window_cursors_off (XWINDOW (w->vchild));
4286 else
4287 w->phys_cursor_on_p = 0;
4288
4289 w = NILP (w->next) ? 0 : XWINDOW (w->next);
4290 }
4291 }
4292
4293
4294 /* Return number of lines of text (not counting mode lines) in W. */
4295
4296 int
4297 window_internal_height (struct window *w)
4298 {
4299 int ht = XFASTINT (w->total_lines);
4300
4301 if (!MINI_WINDOW_P (w))
4302 {
4303 if (!NILP (w->parent)
4304 || !NILP (w->vchild)
4305 || !NILP (w->hchild)
4306 || !NILP (w->next)
4307 || !NILP (w->prev)
4308 || WINDOW_WANTS_MODELINE_P (w))
4309 --ht;
4310
4311 if (WINDOW_WANTS_HEADER_LINE_P (w))
4312 --ht;
4313 }
4314
4315 return ht;
4316 }
4317 \f
4318 /************************************************************************
4319 Window Scrolling
4320 ***********************************************************************/
4321
4322 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4323 N screen-fulls, which is defined as the height of the window minus
4324 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4325 instead. Negative values of N mean scroll down. NOERROR non-zero
4326 means don't signal an error if we try to move over BEGV or ZV,
4327 respectively. */
4328
4329 static void
4330 window_scroll (Lisp_Object window, EMACS_INT n, int whole, int noerror)
4331 {
4332 immediate_quit = 1;
4333 n = clip_to_bounds (INT_MIN, n, INT_MAX);
4334
4335 /* If we must, use the pixel-based version which is much slower than
4336 the line-based one but can handle varying line heights. */
4337 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window)->frame)))
4338 window_scroll_pixel_based (window, n, whole, noerror);
4339 else
4340 window_scroll_line_based (window, n, whole, noerror);
4341
4342 immediate_quit = 0;
4343 }
4344
4345
4346 /* Implementation of window_scroll that works based on pixel line
4347 heights. See the comment of window_scroll for parameter
4348 descriptions. */
4349
4350 static void
4351 window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
4352 {
4353 struct it it;
4354 struct window *w = XWINDOW (window);
4355 struct text_pos start;
4356 int this_scroll_margin;
4357 /* True if we fiddled the window vscroll field without really scrolling. */
4358 int vscrolled = 0;
4359 int x, y, rtop, rbot, rowh, vpos;
4360 void *itdata = NULL;
4361
4362 SET_TEXT_POS_FROM_MARKER (start, w->start);
4363 /* Scrolling a minibuffer window via scroll bar when the echo area
4364 shows long text sometimes resets the minibuffer contents behind
4365 our backs. */
4366 if (CHARPOS (start) > ZV)
4367 SET_TEXT_POS (start, BEGV, BEGV_BYTE);
4368
4369 /* If PT is not visible in WINDOW, move back one half of
4370 the screen. Allow PT to be partially visible, otherwise
4371 something like (scroll-down 1) with PT in the line before
4372 the partially visible one would recenter. */
4373
4374 if (!pos_visible_p (w, PT, &x, &y, &rtop, &rbot, &rowh, &vpos))
4375 {
4376 itdata = bidi_shelve_cache ();
4377 /* Move backward half the height of the window. Performance note:
4378 vmotion used here is about 10% faster, but would give wrong
4379 results for variable height lines. */
4380 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
4381 it.current_y = it.last_visible_y;
4382 move_it_vertically_backward (&it, window_box_height (w) / 2);
4383
4384 /* The function move_iterator_vertically may move over more than
4385 the specified y-distance. If it->w is small, e.g. a
4386 mini-buffer window, we may end up in front of the window's
4387 display area. This is the case when Start displaying at the
4388 start of the line containing PT in this case. */
4389 if (it.current_y <= 0)
4390 {
4391 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
4392 move_it_vertically_backward (&it, 0);
4393 it.current_y = 0;
4394 }
4395
4396 start = it.current.pos;
4397 bidi_unshelve_cache (itdata, 0);
4398 }
4399 else if (auto_window_vscroll_p)
4400 {
4401 if (rtop || rbot) /* partially visible */
4402 {
4403 int px;
4404 int dy = WINDOW_FRAME_LINE_HEIGHT (w);
4405 if (whole)
4406 dy = max ((window_box_height (w)
4407 - next_screen_context_lines * dy),
4408 dy);
4409 dy *= n;
4410
4411 if (n < 0)
4412 {
4413 /* Only vscroll backwards if already vscrolled forwards. */
4414 if (w->vscroll < 0 && rtop > 0)
4415 {
4416 px = max (0, -w->vscroll - min (rtop, -dy));
4417 Fset_window_vscroll (window, make_number (px), Qt);
4418 return;
4419 }
4420 }
4421 if (n > 0)
4422 {
4423 /* Do vscroll if already vscrolled or only display line. */
4424 if (rbot > 0 && (w->vscroll < 0 || vpos == 0))
4425 {
4426 px = max (0, -w->vscroll + min (rbot, dy));
4427 Fset_window_vscroll (window, make_number (px), Qt);
4428 return;
4429 }
4430
4431 /* Maybe modify window start instead of scrolling. */
4432 if (rbot > 0 || w->vscroll < 0)
4433 {
4434 ptrdiff_t spos;
4435
4436 Fset_window_vscroll (window, make_number (0), Qt);
4437 /* If there are other text lines above the current row,
4438 move window start to current row. Else to next row. */
4439 if (rbot > 0)
4440 spos = XINT (Fline_beginning_position (Qnil));
4441 else
4442 spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
4443 set_marker_restricted (w->start, make_number (spos),
4444 w->buffer);
4445 w->start_at_line_beg = 1;
4446 w->update_mode_line = 1;
4447 w->last_modified = 0;
4448 w->last_overlay_modified = 0;
4449 /* Set force_start so that redisplay_window will run the
4450 window-scroll-functions. */
4451 w->force_start = 1;
4452 return;
4453 }
4454 }
4455 }
4456 /* Cancel previous vscroll. */
4457 Fset_window_vscroll (window, make_number (0), Qt);
4458 }
4459
4460 itdata = bidi_shelve_cache ();
4461 /* If scroll_preserve_screen_position is non-nil, we try to set
4462 point in the same window line as it is now, so get that line. */
4463 if (!NILP (Vscroll_preserve_screen_position))
4464 {
4465 /* We preserve the goal pixel coordinate across consecutive
4466 calls to scroll-up, scroll-down and other commands that
4467 have the `scroll-command' property. This avoids the
4468 possibility of point becoming "stuck" on a tall line when
4469 scrolling by one line. */
4470 if (window_scroll_pixel_based_preserve_y < 0
4471 || !SYMBOLP (KVAR (current_kboard, Vlast_command))
4472 || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
4473 {
4474 start_display (&it, w, start);
4475 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
4476 window_scroll_pixel_based_preserve_y = it.current_y;
4477 window_scroll_pixel_based_preserve_x = it.current_x;
4478 }
4479 }
4480 else
4481 window_scroll_pixel_based_preserve_y
4482 = window_scroll_pixel_based_preserve_x = -1;
4483
4484 /* Move iterator it from start the specified distance forward or
4485 backward. The result is the new window start. */
4486 start_display (&it, w, start);
4487 if (whole)
4488 {
4489 ptrdiff_t start_pos = IT_CHARPOS (it);
4490 int dy = WINDOW_FRAME_LINE_HEIGHT (w);
4491 dy = max ((window_box_height (w)
4492 - next_screen_context_lines * dy),
4493 dy) * n;
4494
4495 /* Note that move_it_vertically always moves the iterator to the
4496 start of a line. So, if the last line doesn't have a newline,
4497 we would end up at the start of the line ending at ZV. */
4498 if (dy <= 0)
4499 {
4500 move_it_vertically_backward (&it, -dy);
4501 /* Ensure we actually do move, e.g. in case we are currently
4502 looking at an image that is taller that the window height. */
4503 while (start_pos == IT_CHARPOS (it)
4504 && start_pos > BEGV)
4505 move_it_by_lines (&it, -1);
4506 }
4507 else if (dy > 0)
4508 {
4509 move_it_to (&it, ZV, -1, it.current_y + dy, -1,
4510 MOVE_TO_POS | MOVE_TO_Y);
4511 /* Ensure we actually do move, e.g. in case we are currently
4512 looking at an image that is taller that the window height. */
4513 while (start_pos == IT_CHARPOS (it)
4514 && start_pos < ZV)
4515 move_it_by_lines (&it, 1);
4516 }
4517 }
4518 else
4519 move_it_by_lines (&it, n);
4520
4521 /* We failed if we find ZV is already on the screen (scrolling up,
4522 means there's nothing past the end), or if we can't start any
4523 earlier (scrolling down, means there's nothing past the top). */
4524 if ((n > 0 && IT_CHARPOS (it) == ZV)
4525 || (n < 0 && IT_CHARPOS (it) == CHARPOS (start)))
4526 {
4527 if (IT_CHARPOS (it) == ZV)
4528 {
4529 if (it.current_y < it.last_visible_y
4530 && (it.current_y + it.max_ascent + it.max_descent
4531 > it.last_visible_y))
4532 {
4533 /* The last line was only partially visible, make it fully
4534 visible. */
4535 w->vscroll = (it.last_visible_y
4536 - it.current_y + it.max_ascent + it.max_descent);
4537 adjust_glyphs (it.f);
4538 }
4539 else
4540 {
4541 bidi_unshelve_cache (itdata, 0);
4542 if (noerror)
4543 return;
4544 else if (n < 0) /* could happen with empty buffers */
4545 xsignal0 (Qbeginning_of_buffer);
4546 else
4547 xsignal0 (Qend_of_buffer);
4548 }
4549 }
4550 else
4551 {
4552 if (w->vscroll != 0)
4553 /* The first line was only partially visible, make it fully
4554 visible. */
4555 w->vscroll = 0;
4556 else
4557 {
4558 bidi_unshelve_cache (itdata, 0);
4559 if (noerror)
4560 return;
4561 else
4562 xsignal0 (Qbeginning_of_buffer);
4563 }
4564 }
4565
4566 /* If control gets here, then we vscrolled. */
4567
4568 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
4569
4570 /* Don't try to change the window start below. */
4571 vscrolled = 1;
4572 }
4573
4574 if (! vscrolled)
4575 {
4576 ptrdiff_t pos = IT_CHARPOS (it);
4577 ptrdiff_t bytepos;
4578
4579 /* If in the middle of a multi-glyph character move forward to
4580 the next character. */
4581 if (in_display_vector_p (&it))
4582 {
4583 ++pos;
4584 move_it_to (&it, pos, -1, -1, -1, MOVE_TO_POS);
4585 }
4586
4587 /* Set the window start, and set up the window for redisplay. */
4588 set_marker_restricted (w->start, make_number (pos),
4589 w->buffer);
4590 bytepos = XMARKER (w->start)->bytepos;
4591 w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
4592 w->update_mode_line = 1;
4593 w->last_modified = 0;
4594 w->last_overlay_modified = 0;
4595 /* Set force_start so that redisplay_window will run the
4596 window-scroll-functions. */
4597 w->force_start = 1;
4598 }
4599
4600 /* The rest of this function uses current_y in a nonstandard way,
4601 not including the height of the header line if any. */
4602 it.current_y = it.vpos = 0;
4603
4604 /* Move PT out of scroll margins.
4605 This code wants current_y to be zero at the window start position
4606 even if there is a header line. */
4607 this_scroll_margin = max (0, scroll_margin);
4608 this_scroll_margin
4609 = min (this_scroll_margin, XFASTINT (w->total_lines) / 4);
4610 this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
4611
4612 if (n > 0)
4613 {
4614 /* We moved the window start towards ZV, so PT may be now
4615 in the scroll margin at the top. */
4616 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
4617 if (IT_CHARPOS (it) == PT && it.current_y >= this_scroll_margin
4618 && (NILP (Vscroll_preserve_screen_position)
4619 || EQ (Vscroll_preserve_screen_position, Qt)))
4620 /* We found PT at a legitimate height. Leave it alone. */
4621 ;
4622 else if (window_scroll_pixel_based_preserve_y >= 0)
4623 {
4624 /* If we have a header line, take account of it.
4625 This is necessary because we set it.current_y to 0, above. */
4626 move_it_to (&it, -1,
4627 window_scroll_pixel_based_preserve_x,
4628 window_scroll_pixel_based_preserve_y
4629 - (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0 ),
4630 -1, MOVE_TO_Y | MOVE_TO_X);
4631 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
4632 }
4633 else
4634 {
4635 while (it.current_y < this_scroll_margin)
4636 {
4637 int prev = it.current_y;
4638 move_it_by_lines (&it, 1);
4639 if (prev == it.current_y)
4640 break;
4641 }
4642 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
4643 }
4644 }
4645 else if (n < 0)
4646 {
4647 ptrdiff_t charpos, bytepos;
4648 int partial_p;
4649
4650 /* Save our position, for the
4651 window_scroll_pixel_based_preserve_y case. */
4652 charpos = IT_CHARPOS (it);
4653 bytepos = IT_BYTEPOS (it);
4654
4655 /* We moved the window start towards BEGV, so PT may be now
4656 in the scroll margin at the bottom. */
4657 move_it_to (&it, PT, -1,
4658 (it.last_visible_y - CURRENT_HEADER_LINE_HEIGHT (w)
4659 - this_scroll_margin - 1),
4660 -1,
4661 MOVE_TO_POS | MOVE_TO_Y);
4662
4663 /* Save our position, in case it's correct. */
4664 charpos = IT_CHARPOS (it);
4665 bytepos = IT_BYTEPOS (it);
4666
4667 /* See if point is on a partially visible line at the end. */
4668 if (it.what == IT_EOB)
4669 partial_p = it.current_y + it.ascent + it.descent > it.last_visible_y;
4670 else
4671 {
4672 move_it_by_lines (&it, 1);
4673 partial_p = it.current_y > it.last_visible_y;
4674 }
4675
4676 if (charpos == PT && !partial_p
4677 && (NILP (Vscroll_preserve_screen_position)
4678 || EQ (Vscroll_preserve_screen_position, Qt)))
4679 /* We found PT before we found the display margin, so PT is ok. */
4680 ;
4681 else if (window_scroll_pixel_based_preserve_y >= 0)
4682 {
4683 SET_TEXT_POS_FROM_MARKER (start, w->start);
4684 start_display (&it, w, start);
4685 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4686 here because we called start_display again and did not
4687 alter it.current_y this time. */
4688 move_it_to (&it, -1, window_scroll_pixel_based_preserve_x,
4689 window_scroll_pixel_based_preserve_y, -1,
4690 MOVE_TO_Y | MOVE_TO_X);
4691 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
4692 }
4693 else
4694 {
4695 if (partial_p)
4696 /* The last line was only partially visible, so back up two
4697 lines to make sure we're on a fully visible line. */
4698 {
4699 move_it_by_lines (&it, -2);
4700 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
4701 }
4702 else
4703 /* No, the position we saved is OK, so use it. */
4704 SET_PT_BOTH (charpos, bytepos);
4705 }
4706 }
4707 bidi_unshelve_cache (itdata, 0);
4708 }
4709
4710
4711 /* Implementation of window_scroll that works based on screen lines.
4712 See the comment of window_scroll for parameter descriptions. */
4713
4714 static void
4715 window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
4716 {
4717 register struct window *w = XWINDOW (window);
4718 /* Fvertical_motion enters redisplay, which can trigger
4719 fontification, which in turn can modify buffer text (e.g., if the
4720 fontification functions replace escape sequences with faces, as
4721 in `grep-mode-font-lock-keywords'). So we use a marker to record
4722 the old point position, to prevent crashes in SET_PT_BOTH. */
4723 Lisp_Object opoint_marker = Fpoint_marker ();
4724 register ptrdiff_t pos, pos_byte;
4725 register int ht = window_internal_height (w);
4726 register Lisp_Object tem;
4727 int lose;
4728 Lisp_Object bolp;
4729 ptrdiff_t startpos;
4730 Lisp_Object original_pos = Qnil;
4731
4732 /* If scrolling screen-fulls, compute the number of lines to
4733 scroll from the window's height. */
4734 if (whole)
4735 n *= max (1, ht - next_screen_context_lines);
4736
4737 startpos = marker_position (w->start);
4738
4739 if (!NILP (Vscroll_preserve_screen_position))
4740 {
4741 if (window_scroll_preserve_vpos <= 0
4742 || !SYMBOLP (KVAR (current_kboard, Vlast_command))
4743 || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
4744 {
4745 struct position posit
4746 = *compute_motion (startpos, 0, 0, 0,
4747 PT, ht, 0,
4748 -1, w->hscroll,
4749 0, w);
4750 window_scroll_preserve_vpos = posit.vpos;
4751 window_scroll_preserve_hpos = posit.hpos + w->hscroll;
4752 }
4753
4754 original_pos = Fcons (make_number (window_scroll_preserve_hpos),
4755 make_number (window_scroll_preserve_vpos));
4756 }
4757
4758 XSETFASTINT (tem, PT);
4759 tem = Fpos_visible_in_window_p (tem, window, Qnil);
4760
4761 if (NILP (tem))
4762 {
4763 Fvertical_motion (make_number (- (ht / 2)), window);
4764 startpos = PT;
4765 }
4766
4767 SET_PT (startpos);
4768 lose = n < 0 && PT == BEGV;
4769 Fvertical_motion (make_number (n), window);
4770 pos = PT;
4771 pos_byte = PT_BYTE;
4772 bolp = Fbolp ();
4773 SET_PT_BOTH (marker_position (opoint_marker),
4774 marker_byte_position (opoint_marker));
4775
4776 if (lose)
4777 {
4778 if (noerror)
4779 return;
4780 else
4781 xsignal0 (Qbeginning_of_buffer);
4782 }
4783
4784 if (pos < ZV)
4785 {
4786 /* Don't use a scroll margin that is negative or too large. */
4787 int this_scroll_margin =
4788 max (0, min (scroll_margin, XINT (w->total_lines) / 4));
4789
4790 set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
4791 w->start_at_line_beg = !NILP (bolp);
4792 w->update_mode_line = 1;
4793 w->last_modified = 0;
4794 w->last_overlay_modified = 0;
4795 /* Set force_start so that redisplay_window will run
4796 the window-scroll-functions. */
4797 w->force_start = 1;
4798
4799 if (!NILP (Vscroll_preserve_screen_position)
4800 && (whole || !EQ (Vscroll_preserve_screen_position, Qt)))
4801 {
4802 SET_PT_BOTH (pos, pos_byte);
4803 Fvertical_motion (original_pos, window);
4804 }
4805 /* If we scrolled forward, put point enough lines down
4806 that it is outside the scroll margin. */
4807 else if (n > 0)
4808 {
4809 int top_margin;
4810
4811 if (this_scroll_margin > 0)
4812 {
4813 SET_PT_BOTH (pos, pos_byte);
4814 Fvertical_motion (make_number (this_scroll_margin), window);
4815 top_margin = PT;
4816 }
4817 else
4818 top_margin = pos;
4819
4820 if (top_margin <= marker_position (opoint_marker))
4821 SET_PT_BOTH (marker_position (opoint_marker),
4822 marker_byte_position (opoint_marker));
4823 else if (!NILP (Vscroll_preserve_screen_position))
4824 {
4825 SET_PT_BOTH (pos, pos_byte);
4826 Fvertical_motion (original_pos, window);
4827 }
4828 else
4829 SET_PT (top_margin);
4830 }
4831 else if (n < 0)
4832 {
4833 int bottom_margin;
4834
4835 /* If we scrolled backward, put point near the end of the window
4836 but not within the scroll margin. */
4837 SET_PT_BOTH (pos, pos_byte);
4838 tem = Fvertical_motion (make_number (ht - this_scroll_margin), window);
4839 if (XFASTINT (tem) == ht - this_scroll_margin)
4840 bottom_margin = PT;
4841 else
4842 bottom_margin = PT + 1;
4843
4844 if (bottom_margin > marker_position (opoint_marker))
4845 SET_PT_BOTH (marker_position (opoint_marker),
4846 marker_byte_position (opoint_marker));
4847 else
4848 {
4849 if (!NILP (Vscroll_preserve_screen_position))
4850 {
4851 SET_PT_BOTH (pos, pos_byte);
4852 Fvertical_motion (original_pos, window);
4853 }
4854 else
4855 Fvertical_motion (make_number (-1), window);
4856 }
4857 }
4858 }
4859 else
4860 {
4861 if (noerror)
4862 return;
4863 else
4864 xsignal0 (Qend_of_buffer);
4865 }
4866 }
4867
4868
4869 /* Scroll selected_window up or down. If N is nil, scroll a
4870 screen-full which is defined as the height of the window minus
4871 next_screen_context_lines. If N is the symbol `-', scroll.
4872 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4873 up. This is the guts of Fscroll_up and Fscroll_down. */
4874
4875 static void
4876 scroll_command (Lisp_Object n, int direction)
4877 {
4878 ptrdiff_t count = SPECPDL_INDEX ();
4879
4880 eassert (eabs (direction) == 1);
4881
4882 /* If selected window's buffer isn't current, make it current for
4883 the moment. But don't screw up if window_scroll gets an error. */
4884 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
4885 {
4886 record_unwind_protect (save_excursion_restore, save_excursion_save ());
4887 Fset_buffer (XWINDOW (selected_window)->buffer);
4888
4889 /* Make redisplay consider other windows than just selected_window. */
4890 ++windows_or_buffers_changed;
4891 }
4892
4893 if (NILP (n))
4894 window_scroll (selected_window, direction, 1, 0);
4895 else if (EQ (n, Qminus))
4896 window_scroll (selected_window, -direction, 1, 0);
4897 else
4898 {
4899 n = Fprefix_numeric_value (n);
4900 window_scroll (selected_window, XINT (n) * direction, 0, 0);
4901 }
4902
4903 unbind_to (count, Qnil);
4904 }
4905
4906 DEFUN ("scroll-up", Fscroll_up, Sscroll_up, 0, 1, "^P",
4907 doc: /* Scroll text of selected window upward ARG lines.
4908 If ARG is omitted or nil, scroll upward by a near full screen.
4909 A near full screen is `next-screen-context-lines' less than a full screen.
4910 Negative ARG means scroll downward.
4911 If ARG is the atom `-', scroll downward by nearly full screen.
4912 When calling from a program, supply as argument a number, nil, or `-'. */)
4913 (Lisp_Object arg)
4914 {
4915 scroll_command (arg, 1);
4916 return Qnil;
4917 }
4918
4919 DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "^P",
4920 doc: /* Scroll text of selected window down ARG lines.
4921 If ARG is omitted or nil, scroll down by a near full screen.
4922 A near full screen is `next-screen-context-lines' less than a full screen.
4923 Negative ARG means scroll upward.
4924 If ARG is the atom `-', scroll upward by nearly full screen.
4925 When calling from a program, supply as argument a number, nil, or `-'. */)
4926 (Lisp_Object arg)
4927 {
4928 scroll_command (arg, -1);
4929 return Qnil;
4930 }
4931 \f
4932 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, Sother_window_for_scrolling, 0, 0, 0,
4933 doc: /* Return the other window for \"other window scroll\" commands.
4934 If `other-window-scroll-buffer' is non-nil, a window
4935 showing that buffer is used.
4936 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4937 specifies the window. This takes precedence over
4938 `other-window-scroll-buffer'. */)
4939 (void)
4940 {
4941 Lisp_Object window;
4942
4943 if (MINI_WINDOW_P (XWINDOW (selected_window))
4944 && !NILP (Vminibuf_scroll_window))
4945 window = Vminibuf_scroll_window;
4946 /* If buffer is specified, scroll that buffer. */
4947 else if (!NILP (Vother_window_scroll_buffer))
4948 {
4949 window = Fget_buffer_window (Vother_window_scroll_buffer, Qnil);
4950 if (NILP (window))
4951 window = display_buffer (Vother_window_scroll_buffer, Qt, Qnil);
4952 }
4953 else
4954 {
4955 /* Nothing specified; look for a neighboring window on the same
4956 frame. */
4957 window = Fnext_window (selected_window, Qnil, Qnil);
4958
4959 if (EQ (window, selected_window))
4960 /* That didn't get us anywhere; look for a window on another
4961 visible frame. */
4962 do
4963 window = Fnext_window (window, Qnil, Qt);
4964 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window))))
4965 && ! EQ (window, selected_window));
4966 }
4967
4968 CHECK_LIVE_WINDOW (window);
4969
4970 if (EQ (window, selected_window))
4971 error ("There is no other window");
4972
4973 return window;
4974 }
4975
4976 DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "P",
4977 doc: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4978 A near full screen is `next-screen-context-lines' less than a full screen.
4979 The next window is the one below the current one; or the one at the top
4980 if the current one is at the bottom. Negative ARG means scroll downward.
4981 If ARG is the atom `-', scroll downward by nearly full screen.
4982 When calling from a program, supply as argument a number, nil, or `-'.
4983
4984 If `other-window-scroll-buffer' is non-nil, scroll the window
4985 showing that buffer, popping the buffer up if necessary.
4986 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4987 specifies the window to scroll. This takes precedence over
4988 `other-window-scroll-buffer'. */)
4989 (Lisp_Object arg)
4990 {
4991 Lisp_Object window;
4992 struct window *w;
4993 ptrdiff_t count = SPECPDL_INDEX ();
4994
4995 window = Fother_window_for_scrolling ();
4996 w = XWINDOW (window);
4997
4998 /* Don't screw up if window_scroll gets an error. */
4999 record_unwind_protect (save_excursion_restore, save_excursion_save ());
5000 ++windows_or_buffers_changed;
5001
5002 Fset_buffer (w->buffer);
5003 SET_PT (marker_position (w->pointm));
5004
5005 if (NILP (arg))
5006 window_scroll (window, 1, 1, 1);
5007 else if (EQ (arg, Qminus))
5008 window_scroll (window, -1, 1, 1);
5009 else
5010 {
5011 if (CONSP (arg))
5012 arg = XCAR (arg);
5013 CHECK_NUMBER (arg);
5014 window_scroll (window, XINT (arg), 0, 1);
5015 }
5016
5017 set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
5018 unbind_to (count, Qnil);
5019
5020 return Qnil;
5021 }
5022 \f
5023 DEFUN ("scroll-left", Fscroll_left, Sscroll_left, 0, 2, "^P\np",
5024 doc: /* Scroll selected window display ARG columns left.
5025 Default for ARG is window width minus 2.
5026 Value is the total amount of leftward horizontal scrolling in
5027 effect after the change.
5028 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5029 lower bound for automatic scrolling, i.e. automatic scrolling
5030 will not scroll a window to a column less than the value returned
5031 by this function. This happens in an interactive call. */)
5032 (register Lisp_Object arg, Lisp_Object set_minimum)
5033 {
5034 struct window *w = XWINDOW (selected_window);
5035 EMACS_INT requested_arg = (NILP (arg)
5036 ? window_body_cols (w) - 2
5037 : XINT (Fprefix_numeric_value (arg)));
5038 Lisp_Object result = set_window_hscroll (w, w->hscroll + requested_arg);
5039
5040 if (!NILP (set_minimum))
5041 w->min_hscroll = w->hscroll;
5042
5043 return result;
5044 }
5045
5046 DEFUN ("scroll-right", Fscroll_right, Sscroll_right, 0, 2, "^P\np",
5047 doc: /* Scroll selected window display ARG columns right.
5048 Default for ARG is window width minus 2.
5049 Value is the total amount of leftward horizontal scrolling in
5050 effect after the change.
5051 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5052 lower bound for automatic scrolling, i.e. automatic scrolling
5053 will not scroll a window to a column less than the value returned
5054 by this function. This happens in an interactive call. */)
5055 (register Lisp_Object arg, Lisp_Object set_minimum)
5056 {
5057 struct window *w = XWINDOW (selected_window);
5058 EMACS_INT requested_arg = (NILP (arg)
5059 ? window_body_cols (w) - 2
5060 : XINT (Fprefix_numeric_value (arg)));
5061 Lisp_Object result = set_window_hscroll (w, w->hscroll - requested_arg);
5062
5063 if (!NILP (set_minimum))
5064 w->min_hscroll = w->hscroll;
5065
5066 return result;
5067 }
5068
5069 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window, Sminibuffer_selected_window, 0, 0, 0,
5070 doc: /* Return the window which was selected when entering the minibuffer.
5071 Returns nil, if selected window is not a minibuffer window. */)
5072 (void)
5073 {
5074 if (minibuf_level > 0
5075 && MINI_WINDOW_P (XWINDOW (selected_window))
5076 && WINDOW_LIVE_P (minibuf_selected_window))
5077 return minibuf_selected_window;
5078
5079 return Qnil;
5080 }
5081
5082 /* Value is the number of lines actually displayed in window W,
5083 as opposed to its height. */
5084
5085 static int
5086 displayed_window_lines (struct window *w)
5087 {
5088 struct it it;
5089 struct text_pos start;
5090 int height = window_box_height (w);
5091 struct buffer *old_buffer;
5092 int bottom_y;
5093 void *itdata = NULL;
5094
5095 if (XBUFFER (w->buffer) != current_buffer)
5096 {
5097 old_buffer = current_buffer;
5098 set_buffer_internal (XBUFFER (w->buffer));
5099 }
5100 else
5101 old_buffer = NULL;
5102
5103 /* In case W->start is out of the accessible range, do something
5104 reasonable. This happens in Info mode when Info-scroll-down
5105 calls (recenter -1) while W->start is 1. */
5106 if (XMARKER (w->start)->charpos < BEGV)
5107 SET_TEXT_POS (start, BEGV, BEGV_BYTE);
5108 else if (XMARKER (w->start)->charpos > ZV)
5109 SET_TEXT_POS (start, ZV, ZV_BYTE);
5110 else
5111 SET_TEXT_POS_FROM_MARKER (start, w->start);
5112
5113 itdata = bidi_shelve_cache ();
5114 start_display (&it, w, start);
5115 move_it_vertically (&it, height);
5116 bottom_y = line_bottom_y (&it);
5117 bidi_unshelve_cache (itdata, 0);
5118
5119 /* rms: On a non-window display,
5120 the value of it.vpos at the bottom of the screen
5121 seems to be 1 larger than window_box_height (w).
5122 This kludge fixes a bug whereby (move-to-window-line -1)
5123 when ZV is on the last screen line
5124 moves to the previous screen line instead of the last one. */
5125 if (! FRAME_WINDOW_P (XFRAME (w->frame)))
5126 height++;
5127
5128 /* Add in empty lines at the bottom of the window. */
5129 if (bottom_y < height)
5130 {
5131 int uy = FRAME_LINE_HEIGHT (it.f);
5132 it.vpos += (height - bottom_y + uy - 1) / uy;
5133 }
5134
5135 if (old_buffer)
5136 set_buffer_internal (old_buffer);
5137
5138 return it.vpos;
5139 }
5140
5141
5142 DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
5143 doc: /* Center point in selected window and maybe redisplay frame.
5144 With prefix argument ARG, recenter putting point on screen line ARG
5145 relative to the selected window. If ARG is negative, it counts up from the
5146 bottom of the window. (ARG should be less than the height of the window.)
5147
5148 If ARG is omitted or nil, then recenter with point on the middle line of
5149 the selected window; if the variable `recenter-redisplay' is non-nil,
5150 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5151 is set to `grow-only', this resets the tool-bar's height to the minimum
5152 height needed); if `recenter-redisplay' has the special value `tty',
5153 then only tty frames are redrawn.
5154
5155 Just C-u as prefix means put point in the center of the window
5156 and redisplay normally--don't erase and redraw the frame. */)
5157 (register Lisp_Object arg)
5158 {
5159 struct window *w = XWINDOW (selected_window);
5160 struct buffer *buf = XBUFFER (w->buffer);
5161 struct buffer *obuf = current_buffer;
5162 int center_p = 0;
5163 ptrdiff_t charpos, bytepos;
5164 EMACS_INT iarg IF_LINT (= 0);
5165 int this_scroll_margin;
5166
5167 /* If redisplay is suppressed due to an error, try again. */
5168 obuf->display_error_modiff = 0;
5169
5170 if (NILP (arg))
5171 {
5172 if (!NILP (Vrecenter_redisplay)
5173 && (!EQ (Vrecenter_redisplay, Qtty)
5174 || !NILP (Ftty_type (selected_frame))))
5175 {
5176 ptrdiff_t i;
5177
5178 /* Invalidate pixel data calculated for all compositions. */
5179 for (i = 0; i < n_compositions; i++)
5180 composition_table[i]->font = NULL;
5181
5182 WINDOW_XFRAME (w)->minimize_tool_bar_window_p = 1;
5183
5184 Fredraw_frame (WINDOW_FRAME (w));
5185 SET_FRAME_GARBAGED (WINDOW_XFRAME (w));
5186 }
5187
5188 center_p = 1;
5189 }
5190 else if (CONSP (arg)) /* Just C-u. */
5191 center_p = 1;
5192 else
5193 {
5194 arg = Fprefix_numeric_value (arg);
5195 CHECK_NUMBER (arg);
5196 iarg = XINT (arg);
5197 }
5198
5199 set_buffer_internal (buf);
5200
5201 /* Do this after making BUF current
5202 in case scroll_margin is buffer-local. */
5203 this_scroll_margin =
5204 max (0, min (scroll_margin, XFASTINT (w->total_lines) / 4));
5205
5206 /* Handle centering on a graphical frame specially. Such frames can
5207 have variable-height lines and centering point on the basis of
5208 line counts would lead to strange effects. */
5209 if (FRAME_WINDOW_P (XFRAME (w->frame)))
5210 {
5211 if (center_p)
5212 {
5213 struct it it;
5214 struct text_pos pt;
5215 void *itdata = bidi_shelve_cache ();
5216
5217 SET_TEXT_POS (pt, PT, PT_BYTE);
5218 start_display (&it, w, pt);
5219 move_it_vertically_backward (&it, window_box_height (w) / 2);
5220 charpos = IT_CHARPOS (it);
5221 bytepos = IT_BYTEPOS (it);
5222 bidi_unshelve_cache (itdata, 0);
5223 }
5224 else if (iarg < 0)
5225 {
5226 struct it it;
5227 struct text_pos pt;
5228 ptrdiff_t nlines = min (PTRDIFF_MAX, -iarg);
5229 int extra_line_spacing;
5230 int h = window_box_height (w);
5231 void *itdata = bidi_shelve_cache ();
5232
5233 iarg = - max (-iarg, this_scroll_margin);
5234
5235 SET_TEXT_POS (pt, PT, PT_BYTE);
5236 start_display (&it, w, pt);
5237
5238 /* Be sure we have the exact height of the full line containing PT. */
5239 move_it_by_lines (&it, 0);
5240
5241 /* The amount of pixels we have to move back is the window
5242 height minus what's displayed in the line containing PT,
5243 and the lines below. */
5244 it.current_y = 0;
5245 it.vpos = 0;
5246 move_it_by_lines (&it, nlines);
5247
5248 if (it.vpos == nlines)
5249 h -= it.current_y;
5250 else
5251 {
5252 /* Last line has no newline */
5253 h -= line_bottom_y (&it);
5254 it.vpos++;
5255 }
5256
5257 /* Don't reserve space for extra line spacing of last line. */
5258 extra_line_spacing = it.max_extra_line_spacing;
5259
5260 /* If we can't move down NLINES lines because we hit
5261 the end of the buffer, count in some empty lines. */
5262 if (it.vpos < nlines)
5263 {
5264 nlines -= it.vpos;
5265 extra_line_spacing = it.extra_line_spacing;
5266 h -= nlines * (FRAME_LINE_HEIGHT (it.f) + extra_line_spacing);
5267 }
5268 if (h <= 0)
5269 {
5270 bidi_unshelve_cache (itdata, 0);
5271 return Qnil;
5272 }
5273
5274 /* Now find the new top line (starting position) of the window. */
5275 start_display (&it, w, pt);
5276 it.current_y = 0;
5277 move_it_vertically_backward (&it, h);
5278
5279 /* If extra line spacing is present, we may move too far
5280 back. This causes the last line to be only partially
5281 visible (which triggers redisplay to recenter that line
5282 in the middle), so move forward.
5283 But ignore extra line spacing on last line, as it is not
5284 considered to be part of the visible height of the line.
5285 */
5286 h += extra_line_spacing;
5287 while (-it.current_y > h)
5288 move_it_by_lines (&it, 1);
5289
5290 charpos = IT_CHARPOS (it);
5291 bytepos = IT_BYTEPOS (it);
5292
5293 bidi_unshelve_cache (itdata, 0);
5294 }
5295 else
5296 {
5297 struct position pos;
5298
5299 iarg = max (iarg, this_scroll_margin);
5300
5301 pos = *vmotion (PT, -iarg, w);
5302 charpos = pos.bufpos;
5303 bytepos = pos.bytepos;
5304 }
5305 }
5306 else
5307 {
5308 struct position pos;
5309 int ht = window_internal_height (w);
5310
5311 if (center_p)
5312 iarg = ht / 2;
5313 else if (iarg < 0)
5314 iarg += ht;
5315
5316 /* Don't let it get into the margin at either top or bottom. */
5317 iarg = max (iarg, this_scroll_margin);
5318 iarg = min (iarg, ht - this_scroll_margin - 1);
5319
5320 pos = *vmotion (PT, - iarg, w);
5321 charpos = pos.bufpos;
5322 bytepos = pos.bytepos;
5323 }
5324
5325 /* Set the new window start. */
5326 set_marker_both (w->start, w->buffer, charpos, bytepos);
5327 wset_window_end_valid (w, Qnil);
5328
5329 w->optional_new_start = 1;
5330
5331 w->start_at_line_beg = (bytepos == BEGV_BYTE ||
5332 FETCH_BYTE (bytepos - 1) == '\n');
5333
5334 set_buffer_internal (obuf);
5335 return Qnil;
5336 }
5337
5338 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
5339 0, 1, 0,
5340 doc: /* Return the height in lines of the text display area of WINDOW.
5341 WINDOW must be a live window and defaults to the selected one.
5342
5343 The returned height does not include the mode line, any header line,
5344 nor any partial-height lines at the bottom of the text area. */)
5345 (Lisp_Object window)
5346 {
5347 struct window *w = decode_live_window (window);
5348 int pixel_height = window_box_height (w);
5349 int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (w->frame));
5350 return make_number (line_height);
5351 }
5352
5353
5354 \f
5355 DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
5356 1, 1, "P",
5357 doc: /* Position point relative to window.
5358 ARG nil means position point at center of window.
5359 Else, ARG specifies vertical position within the window;
5360 zero means top of window, negative means relative to bottom of window. */)
5361 (Lisp_Object arg)
5362 {
5363 struct window *w = XWINDOW (selected_window);
5364 int lines, start;
5365 Lisp_Object window;
5366 #if 0
5367 int this_scroll_margin;
5368 #endif
5369
5370 if (!(BUFFERP (w->buffer)
5371 && XBUFFER (w->buffer) == current_buffer))
5372 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5373 when passed below to set_marker_both. */
5374 error ("move-to-window-line called from unrelated buffer");
5375
5376 window = selected_window;
5377 start = marker_position (w->start);
5378 if (start < BEGV || start > ZV)
5379 {
5380 int height = window_internal_height (w);
5381 Fvertical_motion (make_number (- (height / 2)), window);
5382 set_marker_both (w->start, w->buffer, PT, PT_BYTE);
5383 w->start_at_line_beg = !NILP (Fbolp ());
5384 w->force_start = 1;
5385 }
5386 else
5387 Fgoto_char (w->start);
5388
5389 lines = displayed_window_lines (w);
5390
5391 #if 0
5392 this_scroll_margin = max (0, min (scroll_margin, lines / 4));
5393 #endif
5394
5395 if (NILP (arg))
5396 XSETFASTINT (arg, lines / 2);
5397 else
5398 {
5399 EMACS_INT iarg = XINT (Fprefix_numeric_value (arg));
5400
5401 if (iarg < 0)
5402 iarg = iarg + lines;
5403
5404 #if 0 /* This code would prevent move-to-window-line from moving point
5405 to a place inside the scroll margins (which would cause the
5406 next redisplay to scroll). I wrote this code, but then concluded
5407 it is probably better not to install it. However, it is here
5408 inside #if 0 so as not to lose it. -- rms. */
5409
5410 /* Don't let it get into the margin at either top or bottom. */
5411 iarg = max (iarg, this_scroll_margin);
5412 iarg = min (iarg, lines - this_scroll_margin - 1);
5413 #endif
5414
5415 arg = make_number (iarg);
5416 }
5417
5418 /* Skip past a partially visible first line. */
5419 if (w->vscroll)
5420 XSETINT (arg, XINT (arg) + 1);
5421
5422 return Fvertical_motion (arg, window);
5423 }
5424
5425
5426 \f
5427 /***********************************************************************
5428 Window Configuration
5429 ***********************************************************************/
5430
5431 struct save_window_data
5432 {
5433 struct vectorlike_header header;
5434 Lisp_Object selected_frame;
5435 Lisp_Object current_window;
5436 Lisp_Object current_buffer;
5437 Lisp_Object minibuf_scroll_window;
5438 Lisp_Object minibuf_selected_window;
5439 Lisp_Object root_window;
5440 Lisp_Object focus_frame;
5441 /* A vector, each of whose elements is a struct saved_window
5442 for one window. */
5443 Lisp_Object saved_windows;
5444
5445 /* All fields above are traced by the GC.
5446 From `fame-cols' down, the fields are ignored by the GC. */
5447
5448 int frame_cols, frame_lines, frame_menu_bar_lines;
5449 int frame_tool_bar_lines;
5450 };
5451
5452 /* This is saved as a Lisp_Vector */
5453 struct saved_window
5454 {
5455 struct vectorlike_header header;
5456
5457 Lisp_Object window, buffer, start, pointm, mark;
5458 Lisp_Object left_col, top_line, total_cols, total_lines;
5459 Lisp_Object normal_cols, normal_lines;
5460 Lisp_Object hscroll, min_hscroll;
5461 Lisp_Object parent, prev;
5462 Lisp_Object start_at_line_beg;
5463 Lisp_Object display_table;
5464 Lisp_Object left_margin_cols, right_margin_cols;
5465 Lisp_Object left_fringe_width, right_fringe_width, fringes_outside_margins;
5466 Lisp_Object scroll_bar_width, vertical_scroll_bar_type, dedicated;
5467 Lisp_Object combination_limit, window_parameters;
5468 };
5469
5470 #define SAVED_WINDOW_N(swv,n) \
5471 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5472
5473 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
5474 doc: /* Return t if OBJECT is a window-configuration object. */)
5475 (Lisp_Object object)
5476 {
5477 return WINDOW_CONFIGURATIONP (object) ? Qt : Qnil;
5478 }
5479
5480 DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_configuration_frame, 1, 1, 0,
5481 doc: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5482 (Lisp_Object config)
5483 {
5484 register struct save_window_data *data;
5485 struct Lisp_Vector *saved_windows;
5486
5487 CHECK_WINDOW_CONFIGURATION (config);
5488
5489 data = (struct save_window_data *) XVECTOR (config);
5490 saved_windows = XVECTOR (data->saved_windows);
5491 return XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
5492 }
5493
5494 DEFUN ("set-window-configuration", Fset_window_configuration,
5495 Sset_window_configuration, 1, 1, 0,
5496 doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5497 CONFIGURATION must be a value previously returned
5498 by `current-window-configuration' (which see).
5499 If CONFIGURATION was made from a frame that is now deleted,
5500 only frame-independent values can be restored. In this case,
5501 the return value is nil. Otherwise the value is t. */)
5502 (Lisp_Object configuration)
5503 {
5504 register struct save_window_data *data;
5505 struct Lisp_Vector *saved_windows;
5506 Lisp_Object new_current_buffer;
5507 Lisp_Object frame;
5508 FRAME_PTR f;
5509 ptrdiff_t old_point = -1;
5510
5511 CHECK_WINDOW_CONFIGURATION (configuration);
5512
5513 data = (struct save_window_data *) XVECTOR (configuration);
5514 saved_windows = XVECTOR (data->saved_windows);
5515
5516 new_current_buffer = data->current_buffer;
5517 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer)))
5518 new_current_buffer = Qnil;
5519 else
5520 {
5521 if (XBUFFER (new_current_buffer) == current_buffer)
5522 /* The code further down "preserves point" by saving here PT in
5523 old_point and then setting it later back into PT. When the
5524 current-selected-window and the final-selected-window both show
5525 the current buffer, this suffers from the problem that the
5526 current PT is the window-point of the current-selected-window,
5527 while the final PT is the point of the final-selected-window, so
5528 this copy from one PT to the other would end up moving the
5529 window-point of the final-selected-window to the window-point of
5530 the current-selected-window. So we have to be careful which
5531 point of the current-buffer we copy into old_point. */
5532 if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)
5533 && WINDOWP (selected_window)
5534 && EQ (XWINDOW (selected_window)->buffer, new_current_buffer)
5535 && !EQ (selected_window, data->current_window))
5536 old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;
5537 else
5538 old_point = PT;
5539 else
5540 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5541 point in new_current_buffer as of the last time this buffer was
5542 used. This can be non-deterministic since it can be changed by
5543 things like jit-lock by mere temporary selection of some random
5544 window that happens to show this buffer.
5545 So if possible we want this arbitrary choice of "which point" to
5546 be the one from the to-be-selected-window so as to prevent this
5547 window's cursor from being copied from another window. */
5548 if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)
5549 /* If current_window = selected_window, its point is in BUF_PT. */
5550 && !EQ (selected_window, data->current_window))
5551 old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;
5552 else
5553 old_point = BUF_PT (XBUFFER (new_current_buffer));
5554 }
5555
5556 frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
5557 f = XFRAME (frame);
5558
5559 /* If f is a dead frame, don't bother rebuilding its window tree.
5560 However, there is other stuff we should still try to do below. */
5561 if (FRAME_LIVE_P (f))
5562 {
5563 Lisp_Object window;
5564 Lisp_Object dead_windows = Qnil;
5565 register Lisp_Object tem, par, pers;
5566 register struct window *w;
5567 register struct saved_window *p;
5568 struct window *root_window;
5569 struct window **leaf_windows;
5570 int n_leaf_windows;
5571 ptrdiff_t k;
5572 int i, n;
5573
5574 /* If the frame has been resized since this window configuration was
5575 made, we change the frame to the size specified in the
5576 configuration, restore the configuration, and then resize it
5577 back. We keep track of the prevailing height in these variables. */
5578 int previous_frame_lines = FRAME_LINES (f);
5579 int previous_frame_cols = FRAME_COLS (f);
5580 int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
5581 int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
5582
5583 /* Don't do this within the main loop below: This may call Lisp
5584 code and is thus potentially unsafe while input is blocked. */
5585 for (k = 0; k < saved_windows->header.size; k++)
5586 {
5587 p = SAVED_WINDOW_N (saved_windows, k);
5588 window = p->window;
5589 w = XWINDOW (window);
5590 if (!NILP (w->buffer)
5591 && !EQ (w->buffer, p->buffer)
5592 && BUFFER_LIVE_P (XBUFFER (p->buffer)))
5593 /* If a window we restore gets another buffer, record the
5594 window's old buffer. */
5595 call1 (Qrecord_window_buffer, window);
5596 }
5597
5598 /* The mouse highlighting code could get screwed up
5599 if it runs during this. */
5600 block_input ();
5601
5602 if (data->frame_lines != previous_frame_lines
5603 || data->frame_cols != previous_frame_cols)
5604 change_frame_size (f, data->frame_lines,
5605 data->frame_cols, 0, 0, 0);
5606 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5607 if (data->frame_menu_bar_lines
5608 != previous_frame_menu_bar_lines)
5609 x_set_menu_bar_lines (f, make_number (data->frame_menu_bar_lines),
5610 make_number (0));
5611 #ifdef HAVE_WINDOW_SYSTEM
5612 if (data->frame_tool_bar_lines
5613 != previous_frame_tool_bar_lines)
5614 x_set_tool_bar_lines (f, make_number (data->frame_tool_bar_lines),
5615 make_number (0));
5616 #endif
5617 #endif
5618
5619 /* "Swap out" point from the selected window's buffer
5620 into the window itself. (Normally the pointm of the selected
5621 window holds garbage.) We do this now, before
5622 restoring the window contents, and prevent it from
5623 being done later on when we select a new window. */
5624 if (! NILP (XWINDOW (selected_window)->buffer))
5625 {
5626 w = XWINDOW (selected_window);
5627 set_marker_both (w->pointm,
5628 w->buffer,
5629 BUF_PT (XBUFFER (w->buffer)),
5630 BUF_PT_BYTE (XBUFFER (w->buffer)));
5631 }
5632
5633 windows_or_buffers_changed++;
5634 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
5635
5636 /* Problem: Freeing all matrices and later allocating them again
5637 is a serious redisplay flickering problem. What we would
5638 really like to do is to free only those matrices not reused
5639 below. */
5640 root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
5641 leaf_windows = alloca (count_windows (root_window)
5642 * sizeof *leaf_windows);
5643 n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
5644
5645 /* Kludge Alert!
5646 Mark all windows now on frame as "deleted".
5647 Restoring the new configuration "undeletes" any that are in it.
5648
5649 Save their current buffers in their height fields, since we may
5650 need it later, if a buffer saved in the configuration is now
5651 dead. */
5652 delete_all_child_windows (FRAME_ROOT_WINDOW (f));
5653
5654 for (k = 0; k < saved_windows->header.size; k++)
5655 {
5656 p = SAVED_WINDOW_N (saved_windows, k);
5657 window = p->window;
5658 w = XWINDOW (window);
5659 wset_next (w, Qnil);
5660
5661 if (!NILP (p->parent))
5662 wset_parent
5663 (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);
5664 else
5665 wset_parent (w, Qnil);
5666
5667 if (!NILP (p->prev))
5668 {
5669 wset_prev
5670 (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
5671 wset_next (XWINDOW (w->prev), p->window);
5672 }
5673 else
5674 {
5675 wset_prev (w, Qnil);
5676 if (!NILP (w->parent))
5677 {
5678 if (EQ (p->total_cols, XWINDOW (w->parent)->total_cols))
5679 {
5680 wset_vchild (XWINDOW (w->parent), p->window);
5681 wset_hchild (XWINDOW (w->parent), Qnil);
5682 }
5683 else
5684 {
5685 wset_hchild (XWINDOW (w->parent), p->window);
5686 wset_vchild (XWINDOW (w->parent), Qnil);
5687 }
5688 }
5689 }
5690
5691 /* If we squirreled away the buffer in the window's height,
5692 restore it now. */
5693 if (BUFFERP (w->total_lines))
5694 wset_buffer (w, w->total_lines);
5695 wset_left_col (w, p->left_col);
5696 wset_top_line (w, p->top_line);
5697 wset_total_cols (w, p->total_cols);
5698 wset_total_lines (w, p->total_lines);
5699 wset_normal_cols (w, p->normal_cols);
5700 wset_normal_lines (w, p->normal_lines);
5701 w->hscroll = XFASTINT (p->hscroll);
5702 w->min_hscroll = XFASTINT (p->min_hscroll);
5703 wset_display_table (w, p->display_table);
5704 wset_left_margin_cols (w, p->left_margin_cols);
5705 wset_right_margin_cols (w, p->right_margin_cols);
5706 wset_left_fringe_width (w, p->left_fringe_width);
5707 wset_right_fringe_width (w, p->right_fringe_width);
5708 w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
5709 wset_scroll_bar_width (w, p->scroll_bar_width);
5710 wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
5711 wset_dedicated (w, p->dedicated);
5712 wset_combination_limit (w, p->combination_limit);
5713 /* Restore any window parameters that have been saved.
5714 Parameters that have not been saved are left alone. */
5715 for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
5716 {
5717 pers = XCAR (tem);
5718 if (CONSP (pers))
5719 {
5720 if (NILP (XCDR (pers)))
5721 {
5722 par = Fassq (XCAR (pers), w->window_parameters);
5723 if (CONSP (par) && !NILP (XCDR (par)))
5724 /* Reset a parameter to nil if and only if it
5725 has a non-nil association. Don't make new
5726 associations. */
5727 Fsetcdr (par, Qnil);
5728 }
5729 else
5730 /* Always restore a non-nil value. */
5731 Fset_window_parameter (window, XCAR (pers), XCDR (pers));
5732 }
5733 }
5734
5735 w->last_modified = 0;
5736 w->last_overlay_modified = 0;
5737
5738 /* Reinstall the saved buffer and pointers into it. */
5739 if (NILP (p->buffer))
5740 /* An internal window. */
5741 wset_buffer (w, p->buffer);
5742 else if (BUFFER_LIVE_P (XBUFFER (p->buffer)))
5743 /* If saved buffer is alive, install it. */
5744 {
5745 wset_buffer (w, p->buffer);
5746 w->start_at_line_beg = !NILP (p->start_at_line_beg);
5747 set_marker_restricted (w->start, p->start, w->buffer);
5748 set_marker_restricted (w->pointm, p->pointm,
5749 w->buffer);
5750 Fset_marker (BVAR (XBUFFER (w->buffer), mark),
5751 p->mark, w->buffer);
5752
5753 /* As documented in Fcurrent_window_configuration, don't
5754 restore the location of point in the buffer which was
5755 current when the window configuration was recorded. */
5756 if (!EQ (p->buffer, new_current_buffer)
5757 && XBUFFER (p->buffer) == current_buffer)
5758 Fgoto_char (w->pointm);
5759 }
5760 else if (!NILP (w->buffer)
5761 && BUFFER_LIVE_P (XBUFFER (w->buffer)))
5762 /* Keep window's old buffer; make sure the markers are
5763 real. */
5764 {
5765 /* Set window markers at start of visible range. */
5766 if (XMARKER (w->start)->buffer == 0)
5767 set_marker_restricted (w->start, make_number (0),
5768 w->buffer);
5769 if (XMARKER (w->pointm)->buffer == 0)
5770 set_marker_restricted_both
5771 (w->pointm, w->buffer,
5772 BUF_PT (XBUFFER (w->buffer)),
5773 BUF_PT_BYTE (XBUFFER (w->buffer)));
5774 w->start_at_line_beg = 1;
5775 }
5776 else
5777 /* Window has no live buffer, get one. */
5778 {
5779 /* Get the buffer via other_buffer_safely in order to
5780 avoid showing an unimportant buffer and, if necessary, to
5781 recreate *scratch* in the course (part of Juanma's bs-show
5782 scenario from March 2011). */
5783 wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
5784 /* This will set the markers to beginning of visible
5785 range. */
5786 set_marker_restricted (w->start,
5787 make_number (0), w->buffer);
5788 set_marker_restricted (w->pointm,
5789 make_number (0), w->buffer);
5790 w->start_at_line_beg = 1;
5791 if (!NILP (w->dedicated))
5792 /* Record this window as dead. */
5793 dead_windows = Fcons (window, dead_windows);
5794 /* Make sure window is no more dedicated. */
5795 wset_dedicated (w, Qnil);
5796 }
5797 }
5798
5799 fset_root_window (f, data->root_window);
5800 /* Arrange *not* to restore point in the buffer that was
5801 current when the window configuration was saved. */
5802 if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
5803 set_marker_restricted (XWINDOW (data->current_window)->pointm,
5804 make_number (old_point),
5805 XWINDOW (data->current_window)->buffer);
5806
5807 /* In the following call to `select-window', prevent "swapping out
5808 point" in the old selected window using the buffer that has
5809 been restored into it. We already swapped out that point from
5810 that window's old buffer. */
5811 select_window (data->current_window, Qnil, 1);
5812 BVAR (XBUFFER (XWINDOW (selected_window)->buffer), last_selected_window)
5813 = selected_window;
5814
5815 if (NILP (data->focus_frame)
5816 || (FRAMEP (data->focus_frame)
5817 && FRAME_LIVE_P (XFRAME (data->focus_frame))))
5818 Fredirect_frame_focus (frame, data->focus_frame);
5819
5820 /* Set the screen height to the value it had before this function. */
5821 if (previous_frame_lines != FRAME_LINES (f)
5822 || previous_frame_cols != FRAME_COLS (f))
5823 change_frame_size (f, previous_frame_lines, previous_frame_cols,
5824 0, 0, 0);
5825 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5826 if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
5827 x_set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
5828 make_number (0));
5829 #ifdef HAVE_WINDOW_SYSTEM
5830 if (previous_frame_tool_bar_lines != FRAME_TOOL_BAR_LINES (f))
5831 x_set_tool_bar_lines (f, make_number (previous_frame_tool_bar_lines),
5832 make_number (0));
5833 #endif
5834 #endif
5835
5836 /* Now, free glyph matrices in windows that were not reused. */
5837 for (i = n = 0; i < n_leaf_windows; ++i)
5838 {
5839 if (NILP (leaf_windows[i]->buffer))
5840 {
5841 /* Assert it's not reused as a combination. */
5842 eassert (NILP (leaf_windows[i]->hchild)
5843 && NILP (leaf_windows[i]->vchild));
5844 free_window_matrices (leaf_windows[i]);
5845 }
5846 else if (EQ (leaf_windows[i]->buffer, new_current_buffer))
5847 ++n;
5848 }
5849
5850 adjust_glyphs (f);
5851 unblock_input ();
5852
5853 /* Scan dead buffer windows. */
5854 for (; CONSP (dead_windows); dead_windows = XCDR (dead_windows))
5855 {
5856 window = XCAR (dead_windows);
5857 if (WINDOW_LIVE_P (window) && !EQ (window, FRAME_ROOT_WINDOW (f)))
5858 delete_deletable_window (window);
5859 }
5860
5861 /* Fselect_window will have made f the selected frame, so we
5862 reselect the proper frame here. Fhandle_switch_frame will change the
5863 selected window too, but that doesn't make the call to
5864 Fselect_window above totally superfluous; it still sets f's
5865 selected window. */
5866 if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
5867 do_switch_frame (data->selected_frame, 0, 0, Qnil);
5868
5869 run_window_configuration_change_hook (f);
5870 }
5871
5872 if (!NILP (new_current_buffer))
5873 {
5874 Fset_buffer (new_current_buffer);
5875 /* If the new current buffer doesn't appear in the selected
5876 window, go to its old point (see bug#12208). */
5877 if (!EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
5878 Fgoto_char (make_number (old_point));
5879 }
5880
5881 Vminibuf_scroll_window = data->minibuf_scroll_window;
5882 minibuf_selected_window = data->minibuf_selected_window;
5883
5884 return (FRAME_LIVE_P (f) ? Qt : Qnil);
5885 }
5886
5887
5888 /* Recursively delete all child windows reachable via the next, vchild,
5889 and hchild slots of WINDOW. */
5890 void
5891 delete_all_child_windows (Lisp_Object window)
5892 {
5893 register struct window *w;
5894
5895 w = XWINDOW (window);
5896
5897 if (!NILP (w->next))
5898 /* Delete WINDOW's siblings (we traverse postorderly). */
5899 delete_all_child_windows (w->next);
5900
5901 /* See Fset_window_configuration for excuse. */
5902 wset_total_lines (w, w->buffer);
5903
5904 if (!NILP (w->vchild))
5905 {
5906 delete_all_child_windows (w->vchild);
5907 wset_vchild (w, Qnil);
5908 }
5909 else if (!NILP (w->hchild))
5910 {
5911 delete_all_child_windows (w->hchild);
5912 wset_hchild (w, Qnil);
5913 }
5914 else if (!NILP (w->buffer))
5915 {
5916 unshow_buffer (w);
5917 unchain_marker (XMARKER (w->pointm));
5918 unchain_marker (XMARKER (w->start));
5919 wset_buffer (w, Qnil);
5920 }
5921
5922 Vwindow_list = Qnil;
5923 }
5924 \f
5925 static int
5926 count_windows (register struct window *window)
5927 {
5928 register int count = 1;
5929 if (!NILP (window->next))
5930 count += count_windows (XWINDOW (window->next));
5931 if (!NILP (window->vchild))
5932 count += count_windows (XWINDOW (window->vchild));
5933 if (!NILP (window->hchild))
5934 count += count_windows (XWINDOW (window->hchild));
5935 return count;
5936 }
5937
5938
5939 /* Fill vector FLAT with leaf windows under W, starting at index I.
5940 Value is last index + 1. */
5941 static int
5942 get_leaf_windows (struct window *w, struct window **flat, int i)
5943 {
5944 while (w)
5945 {
5946 if (!NILP (w->hchild))
5947 i = get_leaf_windows (XWINDOW (w->hchild), flat, i);
5948 else if (!NILP (w->vchild))
5949 i = get_leaf_windows (XWINDOW (w->vchild), flat, i);
5950 else
5951 flat[i++] = w;
5952
5953 w = NILP (w->next) ? 0 : XWINDOW (w->next);
5954 }
5955
5956 return i;
5957 }
5958
5959
5960 /* Return a pointer to the glyph W's physical cursor is on. Value is
5961 null if W's current matrix is invalid, so that no meaningful glyph
5962 can be returned. */
5963 struct glyph *
5964 get_phys_cursor_glyph (struct window *w)
5965 {
5966 struct glyph_row *row;
5967 struct glyph *glyph;
5968 int hpos = w->phys_cursor.hpos;
5969
5970 if (!(w->phys_cursor.vpos >= 0
5971 && w->phys_cursor.vpos < w->current_matrix->nrows))
5972 return NULL;
5973
5974 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
5975 if (!row->enabled_p)
5976 return NULL;
5977
5978 if (w->hscroll)
5979 {
5980 /* When the window is hscrolled, cursor hpos can legitimately be
5981 out of bounds, but we draw the cursor at the corresponding
5982 window margin in that case. */
5983 if (!row->reversed_p && hpos < 0)
5984 hpos = 0;
5985 if (row->reversed_p && hpos >= row->used[TEXT_AREA])
5986 hpos = row->used[TEXT_AREA] - 1;
5987 }
5988
5989 if (row->used[TEXT_AREA] > hpos
5990 && 0 <= hpos)
5991 glyph = row->glyphs[TEXT_AREA] + hpos;
5992 else
5993 glyph = NULL;
5994
5995 return glyph;
5996 }
5997
5998
5999 static int
6000 save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
6001 {
6002 register struct saved_window *p;
6003 register struct window *w;
6004 register Lisp_Object tem, pers, par;
6005
6006 for (;!NILP (window); window = w->next)
6007 {
6008 p = SAVED_WINDOW_N (vector, i);
6009 w = XWINDOW (window);
6010
6011 wset_temslot (w, make_number (i)); i++;
6012 p->window = window;
6013 p->buffer = w->buffer;
6014 p->left_col = w->left_col;
6015 p->top_line = w->top_line;
6016 p->total_cols = w->total_cols;
6017 p->total_lines = w->total_lines;
6018 p->normal_cols = w->normal_cols;
6019 p->normal_lines = w->normal_lines;
6020 XSETFASTINT (p->hscroll, w->hscroll);
6021 XSETFASTINT (p->min_hscroll, w->min_hscroll);
6022 p->display_table = w->display_table;
6023 p->left_margin_cols = w->left_margin_cols;
6024 p->right_margin_cols = w->right_margin_cols;
6025 p->left_fringe_width = w->left_fringe_width;
6026 p->right_fringe_width = w->right_fringe_width;
6027 p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;
6028 p->scroll_bar_width = w->scroll_bar_width;
6029 p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
6030 p->dedicated = w->dedicated;
6031 p->combination_limit = w->combination_limit;
6032 p->window_parameters = Qnil;
6033
6034 if (!NILP (Vwindow_persistent_parameters))
6035 {
6036 /* Run cycle detection on Vwindow_persistent_parameters. */
6037 Lisp_Object tortoise, hare;
6038
6039 hare = tortoise = Vwindow_persistent_parameters;
6040 while (CONSP (hare))
6041 {
6042 hare = XCDR (hare);
6043 if (!CONSP (hare))
6044 break;
6045
6046 hare = XCDR (hare);
6047 tortoise = XCDR (tortoise);
6048
6049 if (EQ (hare, tortoise))
6050 /* Reset Vwindow_persistent_parameters to Qnil. */
6051 {
6052 Vwindow_persistent_parameters = Qnil;
6053 break;
6054 }
6055 }
6056
6057 for (tem = Vwindow_persistent_parameters; CONSP (tem);
6058 tem = XCDR (tem))
6059 {
6060 pers = XCAR (tem);
6061 /* Save values for persistent window parameters. */
6062 if (CONSP (pers) && !NILP (XCDR (pers)))
6063 {
6064 par = Fassq (XCAR (pers), w->window_parameters);
6065 if (NILP (par))
6066 /* If the window has no value for the parameter,
6067 make one. */
6068 p->window_parameters = Fcons (Fcons (XCAR (pers), Qnil),
6069 p->window_parameters);
6070 else
6071 /* If the window has a value for the parameter,
6072 save it. */
6073 p->window_parameters = Fcons (Fcons (XCAR (par),
6074 XCDR (par)),
6075 p->window_parameters);
6076 }
6077 }
6078 }
6079
6080 if (!NILP (w->buffer))
6081 {
6082 /* Save w's value of point in the window configuration. If w
6083 is the selected window, then get the value of point from
6084 the buffer; pointm is garbage in the selected window. */
6085 if (EQ (window, selected_window))
6086 p->pointm = build_marker (XBUFFER (w->buffer),
6087 BUF_PT (XBUFFER (w->buffer)),
6088 BUF_PT_BYTE (XBUFFER (w->buffer)));
6089 else
6090 p->pointm = Fcopy_marker (w->pointm, Qnil);
6091 XMARKER (p->pointm)->insertion_type
6092 = !NILP (Vwindow_point_insertion_type);
6093
6094 p->start = Fcopy_marker (w->start, Qnil);
6095 p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
6096
6097 tem = BVAR (XBUFFER (w->buffer), mark);
6098 p->mark = Fcopy_marker (tem, Qnil);
6099 }
6100 else
6101 {
6102 p->pointm = Qnil;
6103 p->start = Qnil;
6104 p->mark = Qnil;
6105 p->start_at_line_beg = Qnil;
6106 }
6107
6108 if (NILP (w->parent))
6109 p->parent = Qnil;
6110 else
6111 p->parent = XWINDOW (w->parent)->temslot;
6112
6113 if (NILP (w->prev))
6114 p->prev = Qnil;
6115 else
6116 p->prev = XWINDOW (w->prev)->temslot;
6117
6118 if (!NILP (w->vchild))
6119 i = save_window_save (w->vchild, vector, i);
6120 if (!NILP (w->hchild))
6121 i = save_window_save (w->hchild, vector, i);
6122 }
6123
6124 return i;
6125 }
6126
6127 DEFUN ("current-window-configuration", Fcurrent_window_configuration,
6128 Scurrent_window_configuration, 0, 1, 0,
6129 doc: /* Return an object representing the current window configuration of FRAME.
6130 If FRAME is nil or omitted, use the selected frame.
6131 This describes the number of windows, their sizes and current buffers,
6132 and for each displayed buffer, where display starts, and the positions of
6133 point and mark. An exception is made for point in the current buffer:
6134 its value is -not- saved.
6135 This also records the currently selected frame, and FRAME's focus
6136 redirection (see `redirect-frame-focus'). The variable
6137 `window-persistent-parameters' specifies which window parameters are
6138 saved by this function. */)
6139 (Lisp_Object frame)
6140 {
6141 register Lisp_Object tem;
6142 register int n_windows;
6143 register struct save_window_data *data;
6144 register int i;
6145 struct frame *f = decode_live_frame (frame);
6146
6147 n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
6148 data = ALLOCATE_PSEUDOVECTOR (struct save_window_data, frame_cols,
6149 PVEC_WINDOW_CONFIGURATION);
6150
6151 data->frame_cols = FRAME_COLS (f);
6152 data->frame_lines = FRAME_LINES (f);
6153 data->frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
6154 data->frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
6155 data->selected_frame = selected_frame;
6156 data->current_window = FRAME_SELECTED_WINDOW (f);
6157 XSETBUFFER (data->current_buffer, current_buffer);
6158 data->minibuf_scroll_window = minibuf_level > 0 ? Vminibuf_scroll_window : Qnil;
6159 data->minibuf_selected_window = minibuf_level > 0 ? minibuf_selected_window : Qnil;
6160 data->root_window = FRAME_ROOT_WINDOW (f);
6161 data->focus_frame = FRAME_FOCUS_FRAME (f);
6162 tem = Fmake_vector (make_number (n_windows), Qnil);
6163 data->saved_windows = tem;
6164 for (i = 0; i < n_windows; i++)
6165 ASET (tem, i,
6166 Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
6167 save_window_save (FRAME_ROOT_WINDOW (f), XVECTOR (tem), 0);
6168 XSETWINDOW_CONFIGURATION (tem, data);
6169 return (tem);
6170 }
6171 \f
6172 /***********************************************************************
6173 Marginal Areas
6174 ***********************************************************************/
6175
6176 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
6177 2, 3, 0,
6178 doc: /* Set width of marginal areas of window WINDOW.
6179 WINDOW must be a live window and defaults to the selected one.
6180
6181 Second arg LEFT-WIDTH specifies the number of character cells to
6182 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6183 does the same for the right marginal area. A nil width parameter
6184 means no margin. */)
6185 (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
6186 {
6187 struct window *w = decode_live_window (window);
6188
6189 /* Translate negative or zero widths to nil.
6190 Margins that are too wide have to be checked elsewhere. */
6191
6192 if (!NILP (left_width))
6193 {
6194 CHECK_NUMBER (left_width);
6195 if (XINT (left_width) <= 0)
6196 left_width = Qnil;
6197 }
6198
6199 if (!NILP (right_width))
6200 {
6201 CHECK_NUMBER (right_width);
6202 if (XINT (right_width) <= 0)
6203 right_width = Qnil;
6204 }
6205
6206 if (!EQ (w->left_margin_cols, left_width)
6207 || !EQ (w->right_margin_cols, right_width))
6208 {
6209 wset_left_margin_cols (w, left_width);
6210 wset_right_margin_cols (w, right_width);
6211
6212 adjust_window_margins (w);
6213
6214 ++windows_or_buffers_changed;
6215 adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
6216 }
6217
6218 return Qnil;
6219 }
6220
6221
6222 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
6223 0, 1, 0,
6224 doc: /* Get width of marginal areas of window WINDOW.
6225 WINDOW must be a live window and defaults to the selected one.
6226
6227 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6228 If a marginal area does not exist, its width will be returned
6229 as nil. */)
6230 (Lisp_Object window)
6231 {
6232 struct window *w = decode_live_window (window);
6233 return Fcons (w->left_margin_cols, w->right_margin_cols);
6234 }
6235
6236
6237 \f
6238 /***********************************************************************
6239 Fringes
6240 ***********************************************************************/
6241
6242 DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
6243 2, 4, 0,
6244 doc: /* Set the fringe widths of window WINDOW.
6245 WINDOW must be a live window and defaults to the selected one.
6246
6247 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6248 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6249 fringe width. If a fringe width arg is nil, that means to use the
6250 frame's default fringe width. Default fringe widths can be set with
6251 the command `set-fringe-style'.
6252 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6253 outside of the display margins. By default, fringes are drawn between
6254 display marginal areas and the text area. */)
6255 (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width, Lisp_Object outside_margins)
6256 {
6257 struct window *w = decode_live_window (window);
6258 int outside = !NILP (outside_margins);
6259
6260 if (!NILP (left_width))
6261 CHECK_NATNUM (left_width);
6262 if (!NILP (right_width))
6263 CHECK_NATNUM (right_width);
6264
6265 /* Do nothing on a tty. */
6266 if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
6267 && (!EQ (w->left_fringe_width, left_width)
6268 || !EQ (w->right_fringe_width, right_width)
6269 || w->fringes_outside_margins != outside))
6270 {
6271 wset_left_fringe_width (w, left_width);
6272 wset_right_fringe_width (w, right_width);
6273 w->fringes_outside_margins = outside;
6274
6275 adjust_window_margins (w);
6276
6277 clear_glyph_matrix (w->current_matrix);
6278 wset_window_end_valid (w, Qnil);
6279
6280 ++windows_or_buffers_changed;
6281 adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
6282 }
6283
6284 return Qnil;
6285 }
6286
6287
6288 DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
6289 0, 1, 0,
6290 doc: /* Get width of fringes of window WINDOW.
6291 WINDOW must be a live window and defaults to the selected one.
6292
6293 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6294 (Lisp_Object window)
6295 {
6296 struct window *w = decode_live_window (window);
6297
6298 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
6299 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
6300 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w) ? Qt : Qnil);
6301 }
6302
6303
6304 \f
6305 /***********************************************************************
6306 Scroll bars
6307 ***********************************************************************/
6308
6309 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
6310 Sset_window_scroll_bars, 2, 4, 0,
6311 doc: /* Set width and type of scroll bars of window WINDOW.
6312 WINDOW must be a live window and defaults to the selected one.
6313
6314 Second parameter WIDTH specifies the pixel width for the scroll bar;
6315 this is automatically adjusted to a multiple of the frame column width.
6316 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6317 bar: left, right, or nil.
6318 If WIDTH is nil, use the frame's scroll-bar width.
6319 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6320 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6321 (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type, Lisp_Object horizontal_type)
6322 {
6323 struct window *w = decode_live_window (window);
6324
6325 if (!NILP (width))
6326 {
6327 CHECK_RANGED_INTEGER (width, 0, INT_MAX);
6328
6329 if (XINT (width) == 0)
6330 vertical_type = Qnil;
6331 }
6332
6333 if (!(NILP (vertical_type)
6334 || EQ (vertical_type, Qleft)
6335 || EQ (vertical_type, Qright)
6336 || EQ (vertical_type, Qt)))
6337 error ("Invalid type of vertical scroll bar");
6338
6339 if (!EQ (w->scroll_bar_width, width)
6340 || !EQ (w->vertical_scroll_bar_type, vertical_type))
6341 {
6342 wset_scroll_bar_width (w, width);
6343 wset_vertical_scroll_bar_type (w, vertical_type);
6344
6345 adjust_window_margins (w);
6346
6347 clear_glyph_matrix (w->current_matrix);
6348 wset_window_end_valid (w, Qnil);
6349
6350 ++windows_or_buffers_changed;
6351 adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
6352 }
6353
6354 return Qnil;
6355 }
6356
6357
6358 DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
6359 0, 1, 0,
6360 doc: /* Get width and type of scroll bars of window WINDOW.
6361 WINDOW must be a live window and defaults to the selected one.
6362
6363 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6364 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6365 value. */)
6366 (Lisp_Object window)
6367 {
6368 struct window *w = decode_live_window (window);
6369
6370 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
6371 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
6372 : WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
6373 make_number (WINDOW_SCROLL_BAR_COLS (w)),
6374 w->vertical_scroll_bar_type, Qnil);
6375 }
6376
6377
6378 \f
6379 /***********************************************************************
6380 Smooth scrolling
6381 ***********************************************************************/
6382
6383 DEFUN ("window-vscroll", Fwindow_vscroll, Swindow_vscroll, 0, 2, 0,
6384 doc: /* Return the amount by which WINDOW is scrolled vertically.
6385 If WINDOW is omitted or nil, it defaults to the selected window.
6386 Normally, value is a multiple of the canonical character height of WINDOW;
6387 optional second arg PIXELS-P means value is measured in pixels. */)
6388 (Lisp_Object window, Lisp_Object pixels_p)
6389 {
6390 Lisp_Object result;
6391 struct window *w = decode_live_window (window);
6392 struct frame *f = XFRAME (w->frame);
6393
6394 if (FRAME_WINDOW_P (f))
6395 result = (NILP (pixels_p)
6396 ? FRAME_CANON_Y_FROM_PIXEL_Y (f, -w->vscroll)
6397 : make_number (-w->vscroll));
6398 else
6399 result = make_number (0);
6400 return result;
6401 }
6402
6403
6404 DEFUN ("set-window-vscroll", Fset_window_vscroll, Sset_window_vscroll,
6405 2, 3, 0,
6406 doc: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6407 WINDOW nil means use the selected window. Normally, VSCROLL is a
6408 non-negative multiple of the canonical character height of WINDOW;
6409 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6410 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6411 corresponds to an integral number of pixels. The return value is the
6412 result of this rounding.
6413 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6414 (Lisp_Object window, Lisp_Object vscroll, Lisp_Object pixels_p)
6415 {
6416 struct window *w = decode_live_window (window);
6417 struct frame *f = XFRAME (w->frame);
6418
6419 CHECK_NUMBER_OR_FLOAT (vscroll);
6420
6421 if (FRAME_WINDOW_P (f))
6422 {
6423 int old_dy = w->vscroll;
6424
6425 w->vscroll = - (NILP (pixels_p)
6426 ? FRAME_LINE_HEIGHT (f) * XFLOATINT (vscroll)
6427 : XFLOATINT (vscroll));
6428 w->vscroll = min (w->vscroll, 0);
6429
6430 if (w->vscroll != old_dy)
6431 {
6432 /* Adjust glyph matrix of the frame if the virtual display
6433 area becomes larger than before. */
6434 if (w->vscroll < 0 && w->vscroll < old_dy)
6435 adjust_glyphs (f);
6436
6437 /* Prevent redisplay shortcuts. */
6438 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
6439 }
6440 }
6441
6442 return Fwindow_vscroll (window, pixels_p);
6443 }
6444
6445 \f
6446 /* Call FN for all leaf windows on frame F. FN is called with the
6447 first argument being a pointer to the leaf window, and with
6448 additional argument USER_DATA. Stops when FN returns 0. */
6449
6450 static void
6451 foreach_window (struct frame *f, int (*fn) (struct window *, void *),
6452 void *user_data)
6453 {
6454 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6455 if (WINDOWP (FRAME_ROOT_WINDOW (f)))
6456 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f)), fn, user_data);
6457 }
6458
6459
6460 /* Helper function for foreach_window. Call FN for all leaf windows
6461 reachable from W. FN is called with the first argument being a
6462 pointer to the leaf window, and with additional argument USER_DATA.
6463 Stop when FN returns 0. Value is 0 if stopped by FN. */
6464
6465 static int
6466 foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *user_data)
6467 {
6468 int cont;
6469
6470 for (cont = 1; w && cont;)
6471 {
6472 if (!NILP (w->hchild))
6473 cont = foreach_window_1 (XWINDOW (w->hchild), fn, user_data);
6474 else if (!NILP (w->vchild))
6475 cont = foreach_window_1 (XWINDOW (w->vchild), fn, user_data);
6476 else
6477 cont = fn (w, user_data);
6478
6479 w = NILP (w->next) ? 0 : XWINDOW (w->next);
6480 }
6481
6482 return cont;
6483 }
6484
6485
6486 /* Freeze or unfreeze the window start of W unless it is a
6487 mini-window or the selected window. FREEZE_P non-null means freeze
6488 the window start. */
6489
6490 static int
6491 freeze_window_start (struct window *w, void *freeze_p)
6492 {
6493 if (MINI_WINDOW_P (w)
6494 || (WINDOWP (selected_window) /* Can be nil in corner cases. */
6495 && (w == XWINDOW (selected_window)
6496 || (MINI_WINDOW_P (XWINDOW (selected_window))
6497 && ! NILP (Vminibuf_scroll_window)
6498 && w == XWINDOW (Vminibuf_scroll_window)))))
6499 freeze_p = NULL;
6500
6501 w->frozen_window_start_p = freeze_p != NULL;
6502 return 1;
6503 }
6504
6505
6506 /* Freeze or unfreeze the window starts of all leaf windows on frame
6507 F, except the selected window and a mini-window. FREEZE_P non-zero
6508 means freeze the window start. */
6509
6510 void
6511 freeze_window_starts (struct frame *f, int freeze_p)
6512 {
6513 foreach_window (f, freeze_window_start, (void *) (freeze_p ? f : 0));
6514 }
6515
6516 \f
6517 /***********************************************************************
6518 Initialization
6519 ***********************************************************************/
6520
6521 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6522 describe the same state of affairs. This is used by Fequal.
6523
6524 IGNORE_POSITIONS means ignore non-matching scroll positions
6525 and the like.
6526
6527 This ignores a couple of things like the dedication status of
6528 window, combination_limit and the like. This might have to be
6529 fixed. */
6530
6531 bool
6532 compare_window_configurations (Lisp_Object configuration1,
6533 Lisp_Object configuration2,
6534 bool ignore_positions)
6535 {
6536 register struct save_window_data *d1, *d2;
6537 struct Lisp_Vector *sws1, *sws2;
6538 ptrdiff_t i;
6539
6540 CHECK_WINDOW_CONFIGURATION (configuration1);
6541 CHECK_WINDOW_CONFIGURATION (configuration2);
6542
6543 d1 = (struct save_window_data *) XVECTOR (configuration1);
6544 d2 = (struct save_window_data *) XVECTOR (configuration2);
6545 sws1 = XVECTOR (d1->saved_windows);
6546 sws2 = XVECTOR (d2->saved_windows);
6547
6548 /* Frame settings must match. */
6549 if (d1->frame_cols != d2->frame_cols
6550 || d1->frame_lines != d2->frame_lines
6551 || d1->frame_menu_bar_lines != d2->frame_menu_bar_lines
6552 || !EQ (d1->selected_frame, d2->selected_frame)
6553 || !EQ (d1->current_buffer, d2->current_buffer)
6554 || (!ignore_positions
6555 && (!EQ (d1->minibuf_scroll_window, d2->minibuf_scroll_window)
6556 || !EQ (d1->minibuf_selected_window, d2->minibuf_selected_window)))
6557 || !EQ (d1->focus_frame, d2->focus_frame)
6558 /* Verify that the two configurations have the same number of windows. */
6559 || sws1->header.size != sws2->header.size)
6560 return 0;
6561
6562 for (i = 0; i < sws1->header.size; i++)
6563 {
6564 struct saved_window *sw1, *sw2;
6565
6566 sw1 = SAVED_WINDOW_N (sws1, i);
6567 sw2 = SAVED_WINDOW_N (sws2, i);
6568
6569 if (
6570 /* The "current" windows in the two configurations must
6571 correspond to each other. */
6572 EQ (d1->current_window, sw1->window)
6573 != EQ (d2->current_window, sw2->window)
6574 /* Windows' buffers must match. */
6575 || !EQ (sw1->buffer, sw2->buffer)
6576 || !EQ (sw1->left_col, sw2->left_col)
6577 || !EQ (sw1->top_line, sw2->top_line)
6578 || !EQ (sw1->total_cols, sw2->total_cols)
6579 || !EQ (sw1->total_lines, sw2->total_lines)
6580 || !EQ (sw1->display_table, sw2->display_table)
6581 /* The next two disjuncts check the window structure for
6582 equality. */
6583 || !EQ (sw1->parent, sw2->parent)
6584 || !EQ (sw1->prev, sw2->prev)
6585 || (!ignore_positions
6586 && (!EQ (sw1->hscroll, sw2->hscroll)
6587 || !EQ (sw1->min_hscroll, sw2->min_hscroll)
6588 || !EQ (sw1->start_at_line_beg, sw2->start_at_line_beg)
6589 || NILP (Fequal (sw1->start, sw2->start))
6590 || NILP (Fequal (sw1->pointm, sw2->pointm))
6591 || NILP (Fequal (sw1->mark, sw2->mark))))
6592 || !EQ (sw1->left_margin_cols, sw2->left_margin_cols)
6593 || !EQ (sw1->right_margin_cols, sw2->right_margin_cols)
6594 || !EQ (sw1->left_fringe_width, sw2->left_fringe_width)
6595 || !EQ (sw1->right_fringe_width, sw2->right_fringe_width)
6596 || !EQ (sw1->fringes_outside_margins, sw2->fringes_outside_margins)
6597 || !EQ (sw1->scroll_bar_width, sw2->scroll_bar_width)
6598 || !EQ (sw1->vertical_scroll_bar_type, sw2->vertical_scroll_bar_type))
6599 return 0;
6600 }
6601
6602 return 1;
6603 }
6604
6605 DEFUN ("compare-window-configurations", Fcompare_window_configurations,
6606 Scompare_window_configurations, 2, 2, 0,
6607 doc: /* Compare two window configurations as regards the structure of windows.
6608 This function ignores details such as the values of point and mark
6609 and scrolling positions. */)
6610 (Lisp_Object x, Lisp_Object y)
6611 {
6612 if (compare_window_configurations (x, y, 1))
6613 return Qt;
6614 return Qnil;
6615 }
6616 \f
6617 void
6618 init_window_once (void)
6619 {
6620 struct frame *f = make_initial_frame ();
6621 XSETFRAME (selected_frame, f);
6622 Vterminal_frame = selected_frame;
6623 minibuf_window = f->minibuffer_window;
6624 selected_window = f->selected_window;
6625 last_nonminibuf_frame = f;
6626
6627 window_initialized = 1;
6628 }
6629
6630 void
6631 init_window (void)
6632 {
6633 Vwindow_list = Qnil;
6634 }
6635
6636 void
6637 syms_of_window (void)
6638 {
6639 DEFSYM (Qscroll_up, "scroll-up");
6640 DEFSYM (Qscroll_down, "scroll-down");
6641 DEFSYM (Qscroll_command, "scroll-command");
6642
6643 Fput (Qscroll_up, Qscroll_command, Qt);
6644 Fput (Qscroll_down, Qscroll_command, Qt);
6645
6646 DEFSYM (Qwindow_configuration_change_hook, "window-configuration-change-hook");
6647 DEFSYM (Qwindowp, "windowp");
6648 DEFSYM (Qwindow_configuration_p, "window-configuration-p");
6649 DEFSYM (Qwindow_live_p, "window-live-p");
6650 DEFSYM (Qwindow_valid_p, "window-valid-p");
6651 DEFSYM (Qwindow_deletable_p, "window-deletable-p");
6652 DEFSYM (Qdelete_window, "delete-window");
6653 DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");
6654 DEFSYM (Qwindow_resize_root_window_vertically, "window--resize-root-window-vertically");
6655 DEFSYM (Qsafe, "safe");
6656 DEFSYM (Qdisplay_buffer, "display-buffer");
6657 DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
6658 DEFSYM (Qrecord_window_buffer, "record-window-buffer");
6659 DEFSYM (Qget_mru_window, "get-mru-window");
6660 DEFSYM (Qwindow_size, "window-size");
6661 DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
6662 DEFSYM (Qabove, "above");
6663 DEFSYM (Qbelow, "below");
6664 DEFSYM (Qclone_of, "clone-of");
6665
6666 staticpro (&Vwindow_list);
6667
6668 minibuf_selected_window = Qnil;
6669 staticpro (&minibuf_selected_window);
6670
6671 window_scroll_pixel_based_preserve_x = -1;
6672 window_scroll_pixel_based_preserve_y = -1;
6673 window_scroll_preserve_hpos = -1;
6674 window_scroll_preserve_vpos = -1;
6675
6676 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function,
6677 doc: /* Non-nil means call as function to display a help buffer.
6678 The function is called with one argument, the buffer to be displayed.
6679 Used by `with-output-to-temp-buffer'.
6680 If this function is used, then it must do the entire job of showing
6681 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6682 Vtemp_buffer_show_function = Qnil;
6683
6684 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window,
6685 doc: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6686 Vminibuf_scroll_window = Qnil;
6687
6688 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows,
6689 doc: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6690 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6691 is displayed in the `mode-line' face. */);
6692 mode_line_in_non_selected_windows = 1;
6693
6694 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer,
6695 doc: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6696 Vother_window_scroll_buffer = Qnil;
6697
6698 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p,
6699 doc: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6700 auto_window_vscroll_p = 1;
6701
6702 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines,
6703 doc: /* Number of lines of continuity when scrolling by screenfuls. */);
6704 next_screen_context_lines = 2;
6705
6706 DEFVAR_LISP ("scroll-preserve-screen-position",
6707 Vscroll_preserve_screen_position,
6708 doc: /* Controls if scroll commands move point to keep its screen position unchanged.
6709 A value of nil means point does not keep its screen position except
6710 at the scroll margin or window boundary respectively.
6711 A value of t means point keeps its screen position if the scroll
6712 command moved it vertically out of the window, e.g. when scrolling
6713 by full screens.
6714 Any other value means point always keeps its screen position.
6715 Scroll commands should have the `scroll-command' property
6716 on their symbols to be controlled by this variable. */);
6717 Vscroll_preserve_screen_position = Qnil;
6718
6719 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type,
6720 doc: /* Type of marker to use for `window-point'. */);
6721 Vwindow_point_insertion_type = Qnil;
6722
6723 DEFVAR_LISP ("window-configuration-change-hook",
6724 Vwindow_configuration_change_hook,
6725 doc: /* Functions to call when window configuration changes.
6726 The buffer-local part is run once per window, with the relevant window
6727 selected; while the global part is run only once for the modified frame,
6728 with the relevant frame selected. */);
6729 Vwindow_configuration_change_hook = Qnil;
6730
6731 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay,
6732 doc: /* Non-nil means `recenter' redraws entire frame.
6733 If this option is non-nil, then the `recenter' command with a nil
6734 argument will redraw the entire frame; the special value `tty' causes
6735 the frame to be redrawn only if it is a tty frame. */);
6736 Vrecenter_redisplay = Qtty;
6737
6738 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize,
6739 doc: /* If t, resize window combinations proportionally.
6740 If this variable is nil, splitting a window gets the entire screen space
6741 for displaying the new window from the window to split. Deleting and
6742 resizing a window preferably resizes one adjacent window only.
6743
6744 If this variable is t, splitting a window tries to get the space
6745 proportionally from all windows in the same combination. This also
6746 allows to split a window that is otherwise too small or of fixed size.
6747 Resizing and deleting a window proportionally resize all windows in the
6748 same combination.
6749
6750 Other values are reserved for future use.
6751
6752 This variable takes no effect if `window-combination-limit' is non-nil. */);
6753 Vwindow_combination_resize = Qnil;
6754
6755 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,
6756 doc: /* If non-nil, splitting a window makes a new parent window.
6757 The following values are recognized:
6758
6759 nil means splitting a window will create a new parent window only if the
6760 window has no parent window or the window shall become part of a
6761 combination orthogonal to the one it is part of.
6762
6763 `window-size' means that splitting a window for displaying a buffer
6764 makes a new parent window provided `display-buffer' is supposed to
6765 explicitly set the window's size due to the presence of a
6766 `window-height' or `window-width' entry in the alist used by
6767 `display-buffer'. Otherwise, this value is handled like nil.
6768
6769 `temp-buffer' means that splitting a window for displaying a temporary
6770 buffer always makes a new parent window. Otherwise, this value is
6771 handled like nil.
6772
6773 `display-buffer' means that splitting a window for displaying a buffer
6774 always makes a new parent window. Since temporary buffers are
6775 displayed by the function `display-buffer', this value is stronger
6776 than `temp-buffer'. Splitting a window for other purpose makes a
6777 new parent window only if needed.
6778
6779 t means that splitting a window always creates a new parent window. If
6780 all splits behave this way, each frame's window tree is a binary
6781 tree and every window but the frame's root window has exactly one
6782 sibling.
6783
6784 Other values are reserved for future use. */);
6785 Vwindow_combination_limit = Qwindow_size;
6786
6787 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters,
6788 doc: /* Alist of persistent window parameters.
6789 This alist specifies which window parameters shall get saved by
6790 `current-window-configuration' and `window-state-get' and subsequently
6791 restored to their previous values by `set-window-configuration' and
6792 `window-state-put'.
6793
6794 The car of each entry of this alist is the symbol specifying the
6795 parameter. The cdr is one of the following:
6796
6797 nil means the parameter is neither saved by `window-state-get' nor by
6798 `current-window-configuration'.
6799
6800 t means the parameter is saved by `current-window-configuration' and,
6801 provided its WRITABLE argument is nil, by `window-state-get'.
6802
6803 The symbol `writable' means the parameter is saved unconditionally by
6804 both `current-window-configuration' and `window-state-get'. Do not use
6805 this value for parameters without read syntax (like windows or frames).
6806
6807 Parameters not saved by `current-window-configuration' or
6808 `window-state-get' are left alone by `set-window-configuration'
6809 respectively are not installed by `window-state-put'. */);
6810 Vwindow_persistent_parameters = list1 (Fcons (Qclone_of, Qt));
6811
6812 defsubr (&Sselected_window);
6813 defsubr (&Sminibuffer_window);
6814 defsubr (&Swindow_minibuffer_p);
6815 defsubr (&Swindowp);
6816 defsubr (&Swindow_valid_p);
6817 defsubr (&Swindow_live_p);
6818 defsubr (&Swindow_frame);
6819 defsubr (&Sframe_root_window);
6820 defsubr (&Sframe_first_window);
6821 defsubr (&Sframe_selected_window);
6822 defsubr (&Sset_frame_selected_window);
6823 defsubr (&Spos_visible_in_window_p);
6824 defsubr (&Swindow_line_height);
6825 defsubr (&Swindow_buffer);
6826 defsubr (&Swindow_parent);
6827 defsubr (&Swindow_top_child);
6828 defsubr (&Swindow_left_child);
6829 defsubr (&Swindow_next_sibling);
6830 defsubr (&Swindow_prev_sibling);
6831 defsubr (&Swindow_combination_limit);
6832 defsubr (&Sset_window_combination_limit);
6833 defsubr (&Swindow_use_time);
6834 defsubr (&Swindow_top_line);
6835 defsubr (&Swindow_left_column);
6836 defsubr (&Swindow_total_height);
6837 defsubr (&Swindow_total_width);
6838 defsubr (&Swindow_normal_size);
6839 defsubr (&Swindow_new_total);
6840 defsubr (&Swindow_new_normal);
6841 defsubr (&Sset_window_new_total);
6842 defsubr (&Sset_window_new_normal);
6843 defsubr (&Swindow_resize_apply);
6844 defsubr (&Swindow_body_height);
6845 defsubr (&Swindow_body_width);
6846 defsubr (&Swindow_hscroll);
6847 defsubr (&Sset_window_hscroll);
6848 defsubr (&Swindow_redisplay_end_trigger);
6849 defsubr (&Sset_window_redisplay_end_trigger);
6850 defsubr (&Swindow_edges);
6851 defsubr (&Swindow_pixel_edges);
6852 defsubr (&Swindow_absolute_pixel_edges);
6853 defsubr (&Swindow_inside_edges);
6854 defsubr (&Swindow_inside_pixel_edges);
6855 defsubr (&Swindow_inside_absolute_pixel_edges);
6856 defsubr (&Scoordinates_in_window_p);
6857 defsubr (&Swindow_at);
6858 defsubr (&Swindow_point);
6859 defsubr (&Swindow_start);
6860 defsubr (&Swindow_end);
6861 defsubr (&Sset_window_point);
6862 defsubr (&Sset_window_start);
6863 defsubr (&Swindow_dedicated_p);
6864 defsubr (&Sset_window_dedicated_p);
6865 defsubr (&Swindow_display_table);
6866 defsubr (&Sset_window_display_table);
6867 defsubr (&Snext_window);
6868 defsubr (&Sprevious_window);
6869 defsubr (&Sget_buffer_window);
6870 defsubr (&Sdelete_other_windows_internal);
6871 defsubr (&Sdelete_window_internal);
6872 defsubr (&Sresize_mini_window_internal);
6873 defsubr (&Sset_window_buffer);
6874 defsubr (&Srun_window_configuration_change_hook);
6875 defsubr (&Sselect_window);
6876 defsubr (&Sforce_window_update);
6877 defsubr (&Ssplit_window_internal);
6878 defsubr (&Sscroll_up);
6879 defsubr (&Sscroll_down);
6880 defsubr (&Sscroll_left);
6881 defsubr (&Sscroll_right);
6882 defsubr (&Sother_window_for_scrolling);
6883 defsubr (&Sscroll_other_window);
6884 defsubr (&Sminibuffer_selected_window);
6885 defsubr (&Srecenter);
6886 defsubr (&Swindow_text_height);
6887 defsubr (&Smove_to_window_line);
6888 defsubr (&Swindow_configuration_p);
6889 defsubr (&Swindow_configuration_frame);
6890 defsubr (&Sset_window_configuration);
6891 defsubr (&Scurrent_window_configuration);
6892 defsubr (&Sset_window_margins);
6893 defsubr (&Swindow_margins);
6894 defsubr (&Sset_window_fringes);
6895 defsubr (&Swindow_fringes);
6896 defsubr (&Sset_window_scroll_bars);
6897 defsubr (&Swindow_scroll_bars);
6898 defsubr (&Swindow_vscroll);
6899 defsubr (&Sset_window_vscroll);
6900 defsubr (&Scompare_window_configurations);
6901 defsubr (&Swindow_list);
6902 defsubr (&Swindow_list_1);
6903 defsubr (&Swindow_prev_buffers);
6904 defsubr (&Sset_window_prev_buffers);
6905 defsubr (&Swindow_next_buffers);
6906 defsubr (&Sset_window_next_buffers);
6907 defsubr (&Swindow_parameters);
6908 defsubr (&Swindow_parameter);
6909 defsubr (&Sset_window_parameter);
6910 }
6911
6912 void
6913 keys_of_window (void)
6914 {
6915 initial_define_key (control_x_map, '<', "scroll-left");
6916 initial_define_key (control_x_map, '>', "scroll-right");
6917
6918 initial_define_key (global_map, Ctl ('V'), "scroll-up-command");
6919 initial_define_key (meta_map, Ctl ('V'), "scroll-other-window");
6920 initial_define_key (meta_map, 'v', "scroll-down-command");
6921 }