Drop support for deprecated (since 23.1) forms of diary-display-function
[emacs.git] / src / window.c
blob0b0f2140a5821e757668c5b739cb0489a46f6225
1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2014 Free Software
4 Foundation, Inc.
6 This file is part of GNU Emacs.
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.
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.
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/>. */
21 #include <config.h>
23 #include <stdio.h>
25 #include "lisp.h"
26 #include "character.h"
27 #include "buffer.h"
28 #include "keyboard.h"
29 #include "keymap.h"
30 #include "menu.h"
31 #include "frame.h"
32 #include "window.h"
33 #include "commands.h"
34 #include "indent.h"
35 #include "termchar.h"
36 #include "disptab.h"
37 #include "dispextern.h"
38 #include "blockinput.h"
39 #include "intervals.h"
40 #include "termhooks.h" /* For FRAME_TERMINAL. */
41 #ifdef HAVE_WINDOW_SYSTEM
42 #include TERM_HEADER
43 #endif /* HAVE_WINDOW_SYSTEM */
44 #ifdef MSDOS
45 #include "msdos.h"
46 #endif
48 Lisp_Object Qwindowp, Qwindow_live_p;
49 static Lisp_Object Qwindow_valid_p;
50 static Lisp_Object Qwindow_configuration_p;
51 static Lisp_Object Qrecord_window_buffer;
52 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
53 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
54 static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically;
55 static Lisp_Object Qwindow_sanitize_window_sizes;
56 static Lisp_Object Qwindow_pixel_to_total;
57 static Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
58 static Lisp_Object Qsafe, Qabove, Qbelow, Qwindow_size, Qclone_of;
59 static Lisp_Object Qfloor, Qceiling;
60 static Lisp_Object Qwindow_point_insertion_type;
62 static int displayed_window_lines (struct window *);
63 static int count_windows (struct window *);
64 static int get_leaf_windows (struct window *, struct window **, int);
65 static void window_scroll (Lisp_Object, EMACS_INT, bool, int);
66 static void window_scroll_pixel_based (Lisp_Object, int, bool, int);
67 static void window_scroll_line_based (Lisp_Object, int, bool, int);
68 static int add_window_to_list (struct window *, void *);
69 static Lisp_Object next_window (Lisp_Object, Lisp_Object,
70 Lisp_Object, int);
71 static void decode_next_window_args (Lisp_Object *, Lisp_Object *,
72 Lisp_Object *);
73 static void foreach_window (struct frame *,
74 int (* fn) (struct window *, void *),
75 void *);
76 static int foreach_window_1 (struct window *,
77 int (* fn) (struct window *, void *),
78 void *);
79 static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
80 static int window_resize_check (struct window *, bool);
81 static void window_resize_apply (struct window *, bool);
82 static void window_resize_apply_total (struct window *, bool);
83 static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
84 static void select_window_1 (Lisp_Object, bool);
86 static struct window *set_window_fringes (struct window *, Lisp_Object,
87 Lisp_Object, Lisp_Object);
88 static struct window *set_window_margins (struct window *, Lisp_Object,
89 Lisp_Object);
90 static struct window *set_window_scroll_bars (struct window *, Lisp_Object,
91 Lisp_Object, Lisp_Object, Lisp_Object);
92 static void apply_window_adjustment (struct window *);
94 /* This is the window in which the terminal's cursor should
95 be left when nothing is being done with it. This must
96 always be a leaf window, and its buffer is selected by
97 the top level editing loop at the end of each command.
99 This value is always the same as
100 FRAME_SELECTED_WINDOW (selected_frame). */
101 Lisp_Object selected_window;
103 /* A list of all windows for use by next_window and Fwindow_list.
104 Functions creating or deleting windows should invalidate this cache
105 by setting it to nil. */
106 Lisp_Object Vwindow_list;
108 /* The mini-buffer window of the selected frame.
109 Note that you cannot test for mini-bufferness of an arbitrary window
110 by comparing against this; but you can test for mini-bufferness of
111 the selected window. */
112 Lisp_Object minibuf_window;
114 /* Non-nil means it is the window whose mode line should be
115 shown as the selected window when the minibuffer is selected. */
116 Lisp_Object minibuf_selected_window;
118 /* Hook run at end of temp_output_buffer_show. */
119 static Lisp_Object Qtemp_buffer_show_hook;
121 /* Incremented for each window created. */
122 static int sequence_number;
124 /* Hook to run when window config changes. */
125 static Lisp_Object Qwindow_configuration_change_hook;
127 /* Used by the function window_scroll_pixel_based. */
128 static int window_scroll_pixel_based_preserve_x;
129 static int window_scroll_pixel_based_preserve_y;
131 /* Same for window_scroll_line_based. */
132 static EMACS_INT window_scroll_preserve_hpos;
133 static EMACS_INT window_scroll_preserve_vpos;
135 static void
136 CHECK_WINDOW_CONFIGURATION (Lisp_Object x)
138 CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x);
141 /* These setters are used only in this file, so they can be private. */
142 static void
143 wset_combination_limit (struct window *w, Lisp_Object val)
145 w->combination_limit = val;
148 static void
149 wset_dedicated (struct window *w, Lisp_Object val)
151 w->dedicated = val;
154 static void
155 wset_display_table (struct window *w, Lisp_Object val)
157 w->display_table = val;
160 static void
161 wset_new_normal (struct window *w, Lisp_Object val)
163 w->new_normal = val;
166 static void
167 wset_new_total (struct window *w, Lisp_Object val)
169 w->new_total = val;
172 static void
173 wset_normal_cols (struct window *w, Lisp_Object val)
175 w->normal_cols = val;
178 static void
179 wset_normal_lines (struct window *w, Lisp_Object val)
181 w->normal_lines = val;
184 static void
185 wset_parent (struct window *w, Lisp_Object val)
187 w->parent = val;
190 static void
191 wset_pointm (struct window *w, Lisp_Object val)
193 w->pointm = val;
196 static void
197 wset_old_pointm (struct window *w, Lisp_Object val)
199 w->old_pointm = val;
202 static void
203 wset_start (struct window *w, Lisp_Object val)
205 w->start = val;
208 static void
209 wset_temslot (struct window *w, Lisp_Object val)
211 w->temslot = val;
214 static void
215 wset_vertical_scroll_bar_type (struct window *w, Lisp_Object val)
217 w->vertical_scroll_bar_type = val;
220 static void
221 wset_window_parameters (struct window *w, Lisp_Object val)
223 w->window_parameters = val;
226 static void
227 wset_combination (struct window *w, bool horflag, Lisp_Object val)
229 /* Since leaf windows never becomes non-leaf, there should
230 be no buffer and markers in start and pointm fields of W. */
231 eassert (!BUFFERP (w->contents) && NILP (w->start) && NILP (w->pointm));
232 w->contents = val;
233 /* When an internal window is deleted and VAL is nil, HORFLAG
234 is meaningless. */
235 if (!NILP (val))
236 w->horizontal = horflag;
239 /* Nonzero if leaf window W doesn't reflect the actual state
240 of displayed buffer due to its text or overlays change. */
242 bool
243 window_outdated (struct window *w)
245 struct buffer *b = XBUFFER (w->contents);
246 return (w->last_modified < BUF_MODIFF (b)
247 || w->last_overlay_modified < BUF_OVERLAY_MODIFF (b));
250 struct window *
251 decode_live_window (register Lisp_Object window)
253 if (NILP (window))
254 return XWINDOW (selected_window);
256 CHECK_LIVE_WINDOW (window);
257 return XWINDOW (window);
260 struct window *
261 decode_any_window (register Lisp_Object window)
263 struct window *w;
265 if (NILP (window))
266 return XWINDOW (selected_window);
268 CHECK_WINDOW (window);
269 w = XWINDOW (window);
270 return w;
273 static struct window *
274 decode_valid_window (register Lisp_Object window)
276 struct window *w;
278 if (NILP (window))
279 return XWINDOW (selected_window);
281 CHECK_VALID_WINDOW (window);
282 w = XWINDOW (window);
283 return w;
286 /* Called when W's buffer slot is changed. ARG -1 means that W is about to
287 cease its buffer, and 1 means that W is about to set up the new one. */
289 static void
290 adjust_window_count (struct window *w, int arg)
292 eassert (eabs (arg) == 1);
293 if (BUFFERP (w->contents))
295 struct buffer *b = XBUFFER (w->contents);
297 if (b->base_buffer)
298 b = b->base_buffer;
299 b->window_count += arg;
300 eassert (b->window_count >= 0);
301 /* These should be recalculated by redisplay code. */
302 w->window_end_valid = 0;
303 w->base_line_pos = 0;
307 /* Set W's buffer slot to VAL and recompute number
308 of windows showing VAL if it is a buffer. */
310 void
311 wset_buffer (struct window *w, Lisp_Object val)
313 adjust_window_count (w, -1);
314 if (BUFFERP (val))
315 /* Make sure that we do not assign the buffer
316 to an internal window. */
317 eassert (MARKERP (w->start) && MARKERP (w->pointm));
318 w->contents = val;
319 adjust_window_count (w, 1);
322 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
323 doc: /* Return t if OBJECT is a window and nil otherwise. */)
324 (Lisp_Object object)
326 return WINDOWP (object) ? Qt : Qnil;
329 DEFUN ("window-valid-p", Fwindow_valid_p, Swindow_valid_p, 1, 1, 0,
330 doc: /* Return t if OBJECT is a valid window and nil otherwise.
331 A valid window is either a window that displays a buffer or an internal
332 window. Windows that have been deleted are not valid. */)
333 (Lisp_Object object)
335 return WINDOW_VALID_P (object) ? Qt : Qnil;
338 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
339 doc: /* Return t if OBJECT is a live window and nil otherwise.
340 A live window is a window that displays a buffer.
341 Internal windows and deleted windows are not live. */)
342 (Lisp_Object object)
344 return WINDOW_LIVE_P (object) ? Qt : Qnil;
347 /* Frames and windows. */
348 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 0, 1, 0,
349 doc: /* Return the frame that window WINDOW is on.
350 WINDOW must be a valid window and defaults to the selected one. */)
351 (Lisp_Object window)
353 return decode_valid_window (window)->frame;
356 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
357 doc: /* Return the root window of FRAME-OR-WINDOW.
358 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
359 With a frame argument, return that frame's root window.
360 With a window argument, return the root window of that window's frame. */)
361 (Lisp_Object frame_or_window)
363 Lisp_Object window;
365 if (NILP (frame_or_window))
366 window = SELECTED_FRAME ()->root_window;
367 else if (WINDOW_VALID_P (frame_or_window))
368 window = XFRAME (XWINDOW (frame_or_window)->frame)->root_window;
369 else
371 CHECK_LIVE_FRAME (frame_or_window);
372 window = XFRAME (frame_or_window)->root_window;
375 return window;
378 DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
379 doc: /* Return the minibuffer window for frame FRAME.
380 If FRAME is omitted or nil, it defaults to the selected frame. */)
381 (Lisp_Object frame)
383 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame));
386 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
387 Swindow_minibuffer_p, 0, 1, 0,
388 doc: /* Return non-nil if WINDOW is a minibuffer window.
389 WINDOW must be a valid window and defaults to the selected one. */)
390 (Lisp_Object window)
392 return MINI_WINDOW_P (decode_valid_window (window)) ? Qt : Qnil;
395 /* Don't move this to window.el - this must be a safe routine. */
396 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
397 doc: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
398 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
399 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
400 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
401 the first window of that frame. */)
402 (Lisp_Object frame_or_window)
404 Lisp_Object window;
406 if (NILP (frame_or_window))
407 window = SELECTED_FRAME ()->root_window;
408 else if (WINDOW_VALID_P (frame_or_window))
409 window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
410 else
412 CHECK_LIVE_FRAME (frame_or_window);
413 window = XFRAME (frame_or_window)->root_window;
416 while (WINDOWP (XWINDOW (window)->contents))
417 window = XWINDOW (window)->contents;
419 return window;
422 DEFUN ("frame-selected-window", Fframe_selected_window,
423 Sframe_selected_window, 0, 1, 0,
424 doc: /* Return the selected window of FRAME-OR-WINDOW.
425 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
426 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
427 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
428 return the selected window of that frame. */)
429 (Lisp_Object frame_or_window)
431 Lisp_Object window;
433 if (NILP (frame_or_window))
434 window = SELECTED_FRAME ()->selected_window;
435 else if (WINDOW_VALID_P (frame_or_window))
436 window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->selected_window;
437 else
439 CHECK_LIVE_FRAME (frame_or_window);
440 window = XFRAME (frame_or_window)->selected_window;
443 return window;
446 DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
447 Sset_frame_selected_window, 2, 3, 0,
448 doc: /* Set selected window of FRAME to WINDOW.
449 FRAME must be a live frame and defaults to the selected one. If FRAME
450 is the selected frame, this makes WINDOW the selected window. Optional
451 argument NORECORD non-nil means to neither change the order of recently
452 selected windows nor the buffer list. WINDOW must denote a live window.
453 Return WINDOW. */)
454 (Lisp_Object frame, Lisp_Object window, Lisp_Object norecord)
456 if (NILP (frame))
457 frame = selected_frame;
459 CHECK_LIVE_FRAME (frame);
460 CHECK_LIVE_WINDOW (window);
462 if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
463 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
465 if (EQ (frame, selected_frame))
466 return Fselect_window (window, norecord);
467 else
469 fset_selected_window (XFRAME (frame), window);
470 return window;
474 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
475 doc: /* Return the selected window.
476 The selected window is the window in which the standard cursor for
477 selected windows appears and to which many commands apply. */)
478 (void)
480 return selected_window;
483 int window_select_count;
485 /* If select_window is called with inhibit_point_swap non-zero it will
486 not store point of the old selected window's buffer back into that
487 window's pointm slot. This is needed by Fset_window_configuration to
488 avoid that the display routine is called with selected_window set to
489 Qnil causing a subsequent crash. */
490 static Lisp_Object
491 select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
493 register struct window *w;
494 struct frame *sf;
496 CHECK_LIVE_WINDOW (window);
498 w = XWINDOW (window);
500 /* Make the selected window's buffer current. */
501 Fset_buffer (w->contents);
503 if (EQ (window, selected_window) && !inhibit_point_swap)
504 /* `switch-to-buffer' uses (select-window (selected-window)) as a "clever"
505 way to call record_buffer from Elisp, so it's important that we call
506 record_buffer before returning here. */
507 goto record_and_return;
509 if (NILP (norecord))
510 { /* Mark the window for redisplay since the selected-window has
511 a different mode-line. */
512 wset_redisplay (XWINDOW (selected_window));
513 wset_redisplay (w);
515 else
516 redisplay_other_windows ();
518 sf = SELECTED_FRAME ();
519 if (XFRAME (WINDOW_FRAME (w)) != sf)
521 fset_selected_window (XFRAME (WINDOW_FRAME (w)), window);
522 /* Use this rather than Fhandle_switch_frame
523 so that FRAME_FOCUS_FRAME is moved appropriately as we
524 move around in the state where a minibuffer in a separate
525 frame is active. */
526 Fselect_frame (WINDOW_FRAME (w), norecord);
527 /* Fselect_frame called us back so we've done all the work already. */
528 eassert (EQ (window, selected_window));
529 return window;
531 else
532 fset_selected_window (sf, window);
534 select_window_1 (window, inhibit_point_swap);
535 bset_last_selected_window (XBUFFER (w->contents), window);
537 record_and_return:
538 /* record_buffer can run QUIT, so make sure it is run only after we have
539 re-established the invariant between selected_window and selected_frame,
540 otherwise the temporary broken invariant might "escape" (bug#14161). */
541 if (NILP (norecord))
543 w->use_time = ++window_select_count;
544 record_buffer (w->contents);
547 return window;
550 /* Select window with a minimum of fuss, i.e. don't record the change anywhere
551 (not even for redisplay's benefit), and assume that the window's frame is
552 already selected. */
553 static void
554 select_window_1 (Lisp_Object window, bool inhibit_point_swap)
556 /* Store the old selected window's buffer's point in pointm of the old
557 selected window. It belongs to that window, and when the window is
558 not selected, must be in the window. */
559 if (!inhibit_point_swap)
561 struct window *ow = XWINDOW (selected_window);
562 if (BUFFERP (ow->contents))
563 set_marker_both (ow->pointm, ow->contents,
564 BUF_PT (XBUFFER (ow->contents)),
565 BUF_PT_BYTE (XBUFFER (ow->contents)));
568 selected_window = window;
570 /* Go to the point recorded in the window.
571 This is important when the buffer is in more
572 than one window. It also matters when
573 redisplay_window has altered point after scrolling,
574 because it makes the change only in the window. */
575 set_point_from_marker (XWINDOW (window)->pointm);
578 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
579 doc: /* Select WINDOW which must be a live window.
580 Also make WINDOW's frame the selected frame and WINDOW that frame's
581 selected window. In addition, make WINDOW's buffer current and set its
582 buffer's value of `point' to the value of WINDOW's `window-point'.
583 Return WINDOW.
585 Optional second arg NORECORD non-nil means do not put this buffer at the
586 front of the buffer list and do not make this window the most recently
587 selected one.
589 Run `buffer-list-update-hook' unless NORECORD is non-nil. Note that
590 applications and internal routines often select a window temporarily for
591 various purposes; mostly, to simplify coding. As a rule, such
592 selections should be not recorded and therefore will not pollute
593 `buffer-list-update-hook'. Selections that "really count" are those
594 causing a visible change in the next redisplay of WINDOW's frame and
595 should be always recorded. So if you think of running a function each
596 time a window gets selected put it on `buffer-list-update-hook'.
598 Also note that the main editor command loop sets the current buffer to
599 the buffer of the selected window before each command. */)
600 (register Lisp_Object window, Lisp_Object norecord)
602 return select_window (window, norecord, 0);
605 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
606 doc: /* Return the buffer displayed in window WINDOW.
607 If WINDOW is omitted or nil, it defaults to the selected window.
608 Return nil for an internal window or a deleted window. */)
609 (Lisp_Object window)
611 struct window *w = decode_any_window (window);
612 return WINDOW_LEAF_P (w) ? w->contents : Qnil;
615 DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
616 doc: /* Return the parent window of window WINDOW.
617 WINDOW must be a valid window and defaults to the selected one.
618 Return nil for a window with no parent (e.g. a root window). */)
619 (Lisp_Object window)
621 return decode_valid_window (window)->parent;
624 DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 0, 1, 0,
625 doc: /* Return the topmost child window of window WINDOW.
626 WINDOW must be a valid window and defaults to the selected one.
627 Return nil if WINDOW is a live window (live windows have no children).
628 Return nil if WINDOW is an internal window whose children form a
629 horizontal combination. */)
630 (Lisp_Object window)
632 struct window *w = decode_valid_window (window);
633 return WINDOW_VERTICAL_COMBINATION_P (w) ? w->contents : Qnil;
636 DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 0, 1, 0,
637 doc: /* Return the leftmost child window of window WINDOW.
638 WINDOW must be a valid window and defaults to the selected one.
639 Return nil if WINDOW is a live window (live windows have no children).
640 Return nil if WINDOW is an internal window whose children form a
641 vertical combination. */)
642 (Lisp_Object window)
644 struct window *w = decode_valid_window (window);
645 return WINDOW_HORIZONTAL_COMBINATION_P (w) ? w->contents : Qnil;
648 DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
649 doc: /* Return the next sibling window of window WINDOW.
650 WINDOW must be a valid window and defaults to the selected one.
651 Return nil if WINDOW has no next sibling. */)
652 (Lisp_Object window)
654 return decode_valid_window (window)->next;
657 DEFUN ("window-prev-sibling", Fwindow_prev_sibling, Swindow_prev_sibling, 0, 1, 0,
658 doc: /* Return the previous sibling window of window WINDOW.
659 WINDOW must be a valid window and defaults to the selected one.
660 Return nil if WINDOW has no previous sibling. */)
661 (Lisp_Object window)
663 return decode_valid_window (window)->prev;
666 DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
667 doc: /* Return combination limit of window WINDOW.
668 WINDOW must be a valid window used in horizontal or vertical combination.
669 If the return value is nil, child windows of WINDOW can be recombined with
670 WINDOW's siblings. A return value of t means that child windows of
671 WINDOW are never \(re-)combined with WINDOW's siblings. */)
672 (Lisp_Object window)
674 struct window *w;
676 CHECK_VALID_WINDOW (window);
677 w = XWINDOW (window);
678 if (WINDOW_LEAF_P (w))
679 error ("Combination limit is meaningful for internal windows only");
680 return w->combination_limit;
683 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
684 doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
685 WINDOW must be a valid window used in horizontal or vertical combination.
686 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
687 siblings. LIMIT t means that child windows of WINDOW are never
688 \(re-)combined with WINDOW's siblings. Other values are reserved for
689 future use. */)
690 (Lisp_Object window, Lisp_Object limit)
692 struct window *w;
694 CHECK_VALID_WINDOW (window);
695 w = XWINDOW (window);
696 if (WINDOW_LEAF_P (w))
697 error ("Combination limit is meaningful for internal windows only");
698 wset_combination_limit (w, limit);
699 return limit;
702 DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
703 doc: /* Return the use time of window WINDOW.
704 WINDOW must be a live window and defaults to the selected one.
705 The window with the highest use time is the most recently selected
706 one. The window with the lowest use time is the least recently
707 selected one. */)
708 (Lisp_Object window)
710 return make_number (decode_live_window (window)->use_time);
713 DEFUN ("window-pixel-width", Fwindow_pixel_width, Swindow_pixel_width, 0, 1, 0,
714 doc: /* Return the width of window WINDOW in pixels.
715 WINDOW must be a valid window and defaults to the selected one.
717 The return value includes the fringes and margins of WINDOW as well as
718 any vertical dividers or scroll bars belonging to WINDOW. If WINDOW is
719 an internal window, its pixel width is the width of the screen areas
720 spanned by its children. */)
721 (Lisp_Object window)
723 return make_number (decode_valid_window (window)->pixel_width);
726 DEFUN ("window-pixel-height", Fwindow_pixel_height, Swindow_pixel_height, 0, 1, 0,
727 doc: /* Return the height of window WINDOW in pixels.
728 WINDOW must be a valid window and defaults to the selected one.
730 The return value includes the mode line and header line and the bottom
731 divider, if any. If WINDOW is an internal window, its pixel height is
732 the height of the screen areas spanned by its children. */)
733 (Lisp_Object window)
735 return make_number (decode_valid_window (window)->pixel_height);
738 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 2, 0,
739 doc: /* Return the height of window WINDOW in lines.
740 WINDOW must be a valid window and defaults to the selected one.
742 The return value includes the heights of WINDOW's mode and header line
743 and its bottom divider, if any. If WINDOW is an internal window, the
744 total height is the height of the screen areas spanned by its children.
746 If WINDOW's pixel height is not an integral multiple of its frame's
747 character height, the number of lines occupied by WINDOW is rounded
748 internally. This is done in a way such that, if WINDOW is a parent
749 window, the sum of the total heights of all its children internally
750 equals the total height of WINDOW.
752 If the optional argument ROUND is `ceiling', return the smallest integer
753 larger than WINDOW's pixel height divided by the character height of
754 WINDOW's frame. ROUND `floor' means to return the largest integer
755 smaller than WINDOW's pixel height divided by the character height of
756 WINDOW's frame. Any other value of ROUND means to return the internal
757 total height of WINDOW. */)
758 (Lisp_Object window, Lisp_Object round)
760 struct window *w = decode_valid_window (window);
762 if (! EQ (round, Qfloor) && ! EQ (round, Qceiling))
763 return make_number (w->total_lines);
764 else
766 int unit = FRAME_LINE_HEIGHT (WINDOW_XFRAME (w));
768 return make_number (EQ (round, Qceiling)
769 ? ((w->pixel_height + unit - 1) /unit)
770 : (w->pixel_height / unit));
774 DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 2, 0,
775 doc: /* Return the total width of window WINDOW in columns.
776 WINDOW must be a valid window and defaults to the selected one.
778 The return value includes the widths of WINDOW's fringes, margins,
779 scroll bars and its right divider, if any. If WINDOW is an internal
780 window, the total width is the width of the screen areas spanned by its
781 children.
783 If WINDOW's pixel width is not an integral multiple of its frame's
784 character width, the number of lines occupied by WINDOW is rounded
785 internally. This is done in a way such that, if WINDOW is a parent
786 window, the sum of the total widths of all its children internally
787 equals the total width of WINDOW.
789 If the optional argument ROUND is `ceiling', return the smallest integer
790 larger than WINDOW's pixel width divided by the character width of
791 WINDOW's frame. ROUND `floor' means to return the largest integer
792 smaller than WINDOW's pixel width divided by the character width of
793 WINDOW's frame. Any other value of ROUND means to return the internal
794 total width of WINDOW. */)
795 (Lisp_Object window, Lisp_Object round)
797 struct window *w = decode_valid_window (window);
799 if (! EQ (round, Qfloor) && ! EQ (round, Qceiling))
800 return make_number (w->total_cols);
801 else
803 int unit = FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w));
805 return make_number (EQ (round, Qceiling)
806 ? ((w->pixel_width + unit - 1) /unit)
807 : (w->pixel_width / unit));
811 DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
812 doc: /* Return the new total size of window WINDOW.
813 WINDOW must be a valid window and defaults to the selected one.
815 The new total size of WINDOW is the value set by the last call of
816 `set-window-new-total' for WINDOW. If it is valid, it will be shortly
817 installed as WINDOW's total height (see `window-total-height') or total
818 width (see `window-total-width'). */)
819 (Lisp_Object window)
821 return decode_valid_window (window)->new_total;
824 DEFUN ("window-normal-size", Fwindow_normal_size, Swindow_normal_size, 0, 2, 0,
825 doc: /* Return the normal height of window WINDOW.
826 WINDOW must be a valid window and defaults to the selected one.
827 If HORIZONTAL is non-nil, return the normal width of WINDOW.
829 The normal height of a frame's root window or a window that is
830 horizontally combined (a window that has a left or right sibling) is
831 1.0. The normal height of a window that is vertically combined (has a
832 sibling above or below) is the fraction of the window's height with
833 respect to its parent. The sum of the normal heights of all windows in a
834 vertical combination equals 1.0.
836 Similarly, the normal width of a frame's root window or a window that is
837 vertically combined equals 1.0. The normal width of a window that is
838 horizontally combined is the fraction of the window's width with respect
839 to its parent. The sum of the normal widths of all windows in a
840 horizontal combination equals 1.0.
842 The normal sizes of windows are used to restore the proportional sizes
843 of windows after they have been shrunk to their minimum sizes; for
844 example when a frame is temporarily made very small and afterwards gets
845 re-enlarged to its previous size. */)
846 (Lisp_Object window, Lisp_Object horizontal)
848 struct window *w = decode_valid_window (window);
850 return NILP (horizontal) ? w->normal_lines : w->normal_cols;
853 DEFUN ("window-new-normal", Fwindow_new_normal, Swindow_new_normal, 0, 1, 0,
854 doc: /* Return new normal size of window WINDOW.
855 WINDOW must be a valid window and defaults to the selected one.
857 The new normal size of WINDOW is the value set by the last call of
858 `set-window-new-normal' for WINDOW. If valid, it will be shortly
859 installed as WINDOW's normal size (see `window-normal-size'). */)
860 (Lisp_Object window)
862 return decode_valid_window (window)->new_normal;
865 DEFUN ("window-new-pixel", Fwindow_new_pixel, Swindow_new_pixel, 0, 1, 0,
866 doc: /* Return new pixel size of window WINDOW.
867 WINDOW must be a valid window and defaults to the selected one.
869 The new pixel size of WINDOW is the value set by the last call of
870 `set-window-new-pixel' for WINDOW. If it is valid, it will be shortly
871 installed as WINDOW's pixel height (see `window-pixel-height') or pixel
872 width (see `window-pixel-width'). */)
873 (Lisp_Object window)
875 return decode_valid_window (window)->new_pixel;
878 DEFUN ("window-pixel-left", Fwindow_pixel_left, Swindow_pixel_left, 0, 1, 0,
879 doc: /* Return left pixel edge of window WINDOW.
880 WINDOW must be a valid window and defaults to the selected one. */)
881 (Lisp_Object window)
883 return make_number (decode_valid_window (window)->pixel_left);
886 DEFUN ("window-pixel-top", Fwindow_pixel_top, Swindow_pixel_top, 0, 1, 0,
887 doc: /* Return top pixel edge of window WINDOW.
888 WINDOW must be a valid window and defaults to the selected one. */)
889 (Lisp_Object window)
891 return make_number (decode_valid_window (window)->pixel_top);
894 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
895 doc: /* Return left column of window WINDOW.
896 This is the distance, in columns, between the left edge of WINDOW and
897 the left edge of the frame's window area. For instance, the return
898 value is 0 if there is no window to the left of WINDOW.
900 WINDOW must be a valid window and defaults to the selected one. */)
901 (Lisp_Object window)
903 return make_number (decode_valid_window (window)->left_col);
906 DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
907 doc: /* Return top line of window WINDOW.
908 This is the distance, in lines, between the top of WINDOW and the top
909 of the frame's window area. For instance, the return value is 0 if
910 there is no window above WINDOW.
912 WINDOW must be a valid window and defaults to the selected one. */)
913 (Lisp_Object window)
915 return make_number (decode_valid_window (window)->top_line);
918 /* Return the number of lines/pixels of W's body. Don't count any mode
919 or header line or horizontal divider of W. Rounds down to nearest
920 integer when not working pixelwise. */
921 static int
922 window_body_height (struct window *w, bool pixelwise)
924 int height = (w->pixel_height
925 - WINDOW_HEADER_LINE_HEIGHT (w)
926 - (WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w)
927 ? WINDOW_SCROLL_BAR_AREA_HEIGHT (w)
928 : 0)
929 - WINDOW_MODE_LINE_HEIGHT (w)
930 - WINDOW_BOTTOM_DIVIDER_WIDTH (w));
932 /* Don't return a negative value. */
933 return max (pixelwise
934 ? height
935 : height / FRAME_LINE_HEIGHT (WINDOW_XFRAME (w)),
939 /* Return the number of columns/pixels of W's body. Don't count columns
940 occupied by the scroll bar or the divider/vertical bar separating W
941 from its right sibling or margins. On window-systems don't count
942 fringes either. Round down to nearest integer when not working
943 pixelwise. */
945 window_body_width (struct window *w, bool pixelwise)
947 struct frame *f = XFRAME (WINDOW_FRAME (w));
949 int width = (w->pixel_width
950 - WINDOW_RIGHT_DIVIDER_WIDTH (w)
951 - (WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
952 ? WINDOW_SCROLL_BAR_AREA_WIDTH (w)
953 : ((!FRAME_WINDOW_P (f)
954 && !WINDOW_RIGHTMOST_P (w)
955 && !WINDOW_RIGHT_DIVIDER_WIDTH (w))
956 /* A vertical bar is either 1 or 0. */
957 ? 1 : 0))
958 - WINDOW_MARGINS_WIDTH (w)
959 - (FRAME_WINDOW_P (f)
960 ? WINDOW_FRINGES_WIDTH (w)
961 : 0));
963 /* Don't return a negative value. */
964 return max (pixelwise
965 ? width
966 : width / FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w)),
970 DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 2, 0,
971 doc: /* Return the height of WINDOW's text area.
972 WINDOW must be a live window and defaults to the selected one. Optional
973 argument PIXELWISE non-nil means return the height of WINDOW's text area
974 in pixels. The return value does not include the mode line or header
975 line or any horizontal divider.
977 If PIXELWISE is nil, return the largest integer smaller than WINDOW's
978 pixel height divided by the character height of WINDOW's frame. This
979 means that if a line at the bottom of the text area is only partially
980 visible, that line is not counted. */)
981 (Lisp_Object window, Lisp_Object pixelwise)
983 return make_number (window_body_height (decode_live_window (window),
984 NILP (pixelwise) ? 0 : 1));
987 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 2, 0,
988 doc: /* Return the width of WINDOW's text area.
989 WINDOW must be a live window and defaults to the selected one. Optional
990 argument PIXELWISE non-nil means return the width in pixels. The return
991 value does not include any vertical dividers, fringes or marginal areas,
992 or scroll bars.
994 If PIXELWISE is nil, return the largest integer smaller than WINDOW's
995 pixel width divided by the character width of WINDOW's frame. This
996 means that if a column at the right of the text area is only partially
997 visible, that column is not counted. */)
998 (Lisp_Object window, Lisp_Object pixelwise)
1000 return make_number (window_body_width (decode_live_window (window),
1001 NILP (pixelwise) ? 0 : 1));
1004 DEFUN ("window-mode-line-height", Fwindow_mode_line_height,
1005 Swindow_mode_line_height, 0, 1, 0,
1006 doc: /* Return the height in pixels of WINDOW's mode-line.
1007 WINDOW must be a live window and defaults to the selected one. */)
1008 (Lisp_Object window)
1010 return (make_number (WINDOW_MODE_LINE_HEIGHT (decode_live_window (window))));
1013 DEFUN ("window-header-line-height", Fwindow_header_line_height,
1014 Swindow_header_line_height, 0, 1, 0,
1015 doc: /* Return the height in pixels of WINDOW's header-line.
1016 WINDOW must be a live window and defaults to the selected one. */)
1017 (Lisp_Object window)
1019 return (make_number (WINDOW_HEADER_LINE_HEIGHT (decode_live_window (window))));
1022 DEFUN ("window-right-divider-width", Fwindow_right_divider_width,
1023 Swindow_right_divider_width, 0, 1, 0,
1024 doc: /* Return the width in pixels of WINDOW's right divider.
1025 WINDOW must be a live window and defaults to the selected one. */)
1026 (Lisp_Object window)
1028 return (make_number (WINDOW_RIGHT_DIVIDER_WIDTH (decode_live_window (window))));
1031 DEFUN ("window-bottom-divider-width", Fwindow_bottom_divider_width,
1032 Swindow_bottom_divider_width, 0, 1, 0,
1033 doc: /* Return the width in pixels of WINDOW's bottom divider.
1034 WINDOW must be a live window and defaults to the selected one. */)
1035 (Lisp_Object window)
1037 return (make_number (WINDOW_BOTTOM_DIVIDER_WIDTH (decode_live_window (window))));
1040 DEFUN ("window-scroll-bar-width", Fwindow_scroll_bar_width,
1041 Swindow_scroll_bar_width, 0, 1, 0,
1042 doc: /* Return the width in pixels of WINDOW's vertical scrollbar.
1043 WINDOW must be a live window and defaults to the selected one. */)
1044 (Lisp_Object window)
1046 return (make_number (WINDOW_SCROLL_BAR_AREA_WIDTH (decode_live_window (window))));
1049 DEFUN ("window-scroll-bar-height", Fwindow_scroll_bar_height,
1050 Swindow_scroll_bar_height, 0, 1, 0,
1051 doc: /* Return the height in pixels of WINDOW's horizontal scrollbar.
1052 WINDOW must be a live window and defaults to the selected one. */)
1053 (Lisp_Object window)
1055 return (make_number (WINDOW_SCROLL_BAR_AREA_HEIGHT (decode_live_window (window))));
1058 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
1059 doc: /* Return the number of columns by which WINDOW is scrolled from left margin.
1060 WINDOW must be a live window and defaults to the selected one. */)
1061 (Lisp_Object window)
1063 return make_number (decode_live_window (window)->hscroll);
1066 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
1067 range, returning the new amount as a fixnum. */
1068 static Lisp_Object
1069 set_window_hscroll (struct window *w, EMACS_INT hscroll)
1071 /* Horizontal scrolling has problems with large scroll amounts.
1072 It's too slow with long lines, and even with small lines the
1073 display can be messed up. For now, though, impose only the limits
1074 required by the internal representation: horizontal scrolling must
1075 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
1076 (since it's stored in a ptrdiff_t). */
1077 ptrdiff_t hscroll_max = min (MOST_POSITIVE_FIXNUM, PTRDIFF_MAX);
1078 ptrdiff_t new_hscroll = clip_to_bounds (0, hscroll, hscroll_max);
1080 /* Prevent redisplay shortcuts when changing the hscroll. */
1081 if (w->hscroll != new_hscroll)
1082 XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
1084 w->hscroll = new_hscroll;
1085 w->suspend_auto_hscroll = 1;
1087 return make_number (new_hscroll);
1090 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
1091 doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
1092 WINDOW must be a live window and defaults to the selected one.
1093 Clip the number to a reasonable value if out of range.
1094 Return the new number. NCOL should be zero or positive.
1096 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
1097 window so that the location of point moves off-window. */)
1098 (Lisp_Object window, Lisp_Object ncol)
1100 CHECK_NUMBER (ncol);
1101 return set_window_hscroll (decode_live_window (window), XINT (ncol));
1104 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
1105 Swindow_redisplay_end_trigger, 0, 1, 0,
1106 doc: /* Return WINDOW's redisplay end trigger value.
1107 WINDOW must be a live window and defaults to the selected one.
1108 See `set-window-redisplay-end-trigger' for more information. */)
1109 (Lisp_Object window)
1111 return decode_live_window (window)->redisplay_end_trigger;
1114 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
1115 Sset_window_redisplay_end_trigger, 2, 2, 0,
1116 doc: /* Set WINDOW's redisplay end trigger value to VALUE.
1117 WINDOW must be a live window and defaults to the selected one. VALUE
1118 should be a buffer position (typically a marker) or nil. If it is a
1119 buffer position, then if redisplay in WINDOW reaches a position beyond
1120 VALUE, the functions in `redisplay-end-trigger-functions' are called
1121 with two arguments: WINDOW, and the end trigger value. Afterwards the
1122 end-trigger value is reset to nil. */)
1123 (register Lisp_Object window, Lisp_Object value)
1125 wset_redisplay_end_trigger (decode_live_window (window), value);
1126 return value;
1129 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
1130 doc: /* Return a list of the edge coordinates of WINDOW.
1131 WINDOW must be a valid window and defaults to the selected one.
1133 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
1134 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
1135 0 at top left corner of frame.
1137 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
1138 is one more than the bottommost row occupied by WINDOW. The edges
1139 include the space used by WINDOW's scroll bar, display margins, fringes,
1140 header line, and/or mode line. For the edges of just the text area, use
1141 `window-inside-edges'. */)
1142 (Lisp_Object window)
1144 register struct window *w = decode_valid_window (window);
1146 return list4i (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
1147 WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
1150 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
1151 doc: /* Return a list of the edge pixel coordinates of WINDOW.
1152 WINDOW must be a valid window and defaults to the selected one.
1154 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1155 0, 0 at the top left corner of the frame.
1157 RIGHT is one more than the rightmost x position occupied by WINDOW.
1158 BOTTOM is one more than the bottommost y position occupied by WINDOW.
1159 The pixel edges include the space used by WINDOW's scroll bar, display
1160 margins, fringes, header line, and/or mode line. For the pixel edges
1161 of just the text area, use `window-inside-pixel-edges'. */)
1162 (Lisp_Object window)
1164 register struct window *w = decode_valid_window (window);
1166 return list4i (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
1167 WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
1170 static void
1171 calc_absolute_offset (struct window *w, int *add_x, int *add_y)
1173 struct frame *f = XFRAME (w->frame);
1174 *add_y = f->top_pos;
1175 #ifdef FRAME_MENUBAR_HEIGHT
1176 *add_y += FRAME_MENUBAR_HEIGHT (f);
1177 #endif
1178 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
1179 *add_y += FRAME_TOOLBAR_TOP_HEIGHT (f);
1180 #elif defined (FRAME_TOOLBAR_HEIGHT)
1181 *add_y += FRAME_TOOLBAR_HEIGHT (f);
1182 #endif
1183 #ifdef FRAME_NS_TITLEBAR_HEIGHT
1184 *add_y += FRAME_NS_TITLEBAR_HEIGHT (f);
1185 #endif
1186 *add_x = f->left_pos;
1187 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
1188 *add_x += FRAME_TOOLBAR_LEFT_WIDTH (f);
1189 #endif
1192 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges,
1193 Swindow_absolute_pixel_edges, 0, 1, 0,
1194 doc: /* Return a list of the edge pixel coordinates of WINDOW.
1195 WINDOW must be a valid window and defaults to the selected one.
1197 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1198 0, 0 at the top left corner of the display.
1200 RIGHT is one more than the rightmost x position occupied by WINDOW.
1201 BOTTOM is one more than the bottommost y position occupied by WINDOW.
1202 The pixel edges include the space used by WINDOW's scroll bar, display
1203 margins, fringes, header line, and/or mode line. For the pixel edges
1204 of just the text area, use `window-inside-absolute-pixel-edges'. */)
1205 (Lisp_Object window)
1207 register struct window *w = decode_valid_window (window);
1208 int add_x, add_y;
1210 calc_absolute_offset (w, &add_x, &add_y);
1212 return list4i (WINDOW_LEFT_EDGE_X (w) + add_x,
1213 WINDOW_TOP_EDGE_Y (w) + add_y,
1214 WINDOW_RIGHT_EDGE_X (w) + add_x,
1215 WINDOW_BOTTOM_EDGE_Y (w) + add_y);
1218 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
1219 doc: /* Return a list of the edge coordinates of WINDOW.
1220 WINDOW must be a live window and defaults to the selected one.
1222 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
1223 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
1224 0 at top left corner of frame.
1226 RIGHT is one more than the rightmost column of WINDOW's text area.
1227 BOTTOM is one more than the bottommost row of WINDOW's text area. The
1228 inside edges do not include the space used by the WINDOW's scroll bar,
1229 display margins, fringes, header line, and/or mode line. */)
1230 (Lisp_Object window)
1232 register struct window *w = decode_live_window (window);
1234 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w)
1235 + WINDOW_LEFT_MARGIN_COLS (w)
1236 + ((WINDOW_LEFT_FRINGE_WIDTH (w)
1237 + WINDOW_FRAME_COLUMN_WIDTH (w) - 1)
1238 / WINDOW_FRAME_COLUMN_WIDTH (w))),
1239 (WINDOW_TOP_EDGE_LINE (w)
1240 + WINDOW_HEADER_LINE_LINES (w)),
1241 (WINDOW_BOX_RIGHT_EDGE_COL (w)
1242 - WINDOW_RIGHT_MARGIN_COLS (w)
1243 - ((WINDOW_RIGHT_FRINGE_WIDTH (w)
1244 + WINDOW_FRAME_COLUMN_WIDTH (w) - 1)
1245 / WINDOW_FRAME_COLUMN_WIDTH (w))),
1246 (WINDOW_BOTTOM_EDGE_LINE (w)
1247 - WINDOW_MODE_LINE_LINES (w)));
1250 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
1251 doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1252 WINDOW must be a live window and defaults to the selected one.
1254 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1255 (0,0) at the top left corner of the frame's window area.
1257 RIGHT is one more than the rightmost x position of WINDOW's text area.
1258 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1259 The inside edges do not include the space used by WINDOW's scroll bar,
1260 display margins, fringes, header line, and/or mode line. */)
1261 (Lisp_Object window)
1263 register struct window *w = decode_live_window (window);
1265 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
1266 + WINDOW_LEFT_MARGIN_WIDTH (w)
1267 + WINDOW_LEFT_FRINGE_WIDTH (w)),
1268 (WINDOW_TOP_EDGE_Y (w)
1269 + WINDOW_HEADER_LINE_HEIGHT (w)),
1270 (WINDOW_BOX_RIGHT_EDGE_X (w)
1271 - WINDOW_RIGHT_MARGIN_WIDTH (w)
1272 - WINDOW_RIGHT_FRINGE_WIDTH (w)),
1273 (WINDOW_BOTTOM_EDGE_Y (w)
1274 - WINDOW_MODE_LINE_HEIGHT (w)));
1277 DEFUN ("window-inside-absolute-pixel-edges",
1278 Fwindow_inside_absolute_pixel_edges,
1279 Swindow_inside_absolute_pixel_edges, 0, 1, 0,
1280 doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1281 WINDOW must be a live window and defaults to the selected one.
1283 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1284 (0,0) at the top left corner of the frame's window area.
1286 RIGHT is one more than the rightmost x position of WINDOW's text area.
1287 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1288 The inside edges do not include the space used by WINDOW's scroll bar,
1289 display margins, fringes, header line, and/or mode line. */)
1290 (Lisp_Object window)
1292 register struct window *w = decode_live_window (window);
1293 int add_x, add_y;
1295 calc_absolute_offset (w, &add_x, &add_y);
1297 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
1298 + WINDOW_LEFT_MARGIN_WIDTH (w)
1299 + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
1300 (WINDOW_TOP_EDGE_Y (w)
1301 + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
1302 (WINDOW_BOX_RIGHT_EDGE_X (w)
1303 - WINDOW_RIGHT_MARGIN_WIDTH (w)
1304 - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
1305 (WINDOW_BOTTOM_EDGE_Y (w)
1306 - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
1309 /* Test if the character at column X, row Y is within window W.
1310 If it is not, return ON_NOTHING;
1311 if it is on the window's vertical divider, return
1312 ON_RIGHT_DIVIDER;
1313 if it is on the window's horizontal divider, return
1314 ON_BOTTOM_DIVIDER;
1315 if it is in the window's text area, return ON_TEXT;
1316 if it is on the window's modeline, return ON_MODE_LINE;
1317 if it is on the border between the window and its right sibling,
1318 return ON_VERTICAL_BORDER;
1319 if it is on a scroll bar, return ON_SCROLL_BAR;
1320 if it is on the window's top line, return ON_HEADER_LINE;
1321 if it is in left or right fringe of the window,
1322 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1323 if it is in the marginal area to the left/right of the window,
1324 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1326 X and Y are frame relative pixel coordinates. */
1328 static enum window_part
1329 coordinates_in_window (register struct window *w, int x, int y)
1331 struct frame *f = XFRAME (WINDOW_FRAME (w));
1332 enum window_part part;
1333 int ux = FRAME_COLUMN_WIDTH (f);
1334 int left_x = WINDOW_LEFT_EDGE_X (w);
1335 int right_x = WINDOW_RIGHT_EDGE_X (w);
1336 int top_y = WINDOW_TOP_EDGE_Y (w);
1337 int bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
1338 /* The width of the area where the vertical line can be dragged.
1339 (Between mode lines for instance. */
1340 int grabbable_width = ux;
1341 int lmargin_width, rmargin_width, text_left, text_right;
1343 /* Outside any interesting row or column? */
1344 if (y < top_y || y >= bottom_y || x < left_x || x >= right_x)
1345 return ON_NOTHING;
1347 /* On the horizontal window divider (which prevails the vertical
1348 divider)? */
1349 if (WINDOW_BOTTOM_DIVIDER_WIDTH (w) > 0
1350 && y >= (bottom_y - WINDOW_BOTTOM_DIVIDER_WIDTH (w))
1351 && y <= bottom_y)
1352 return ON_BOTTOM_DIVIDER;
1353 /* On vertical window divider? */
1354 else if (!WINDOW_RIGHTMOST_P (w)
1355 && WINDOW_RIGHT_DIVIDER_WIDTH (w) > 0
1356 && x >= right_x - WINDOW_RIGHT_DIVIDER_WIDTH (w)
1357 && x <= right_x)
1358 return ON_RIGHT_DIVIDER;
1359 /* On the horizontal scroll bar? (Including the empty space at its
1360 right!) */
1361 else if ((WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w)
1362 && y >= (bottom_y
1363 - WINDOW_SCROLL_BAR_AREA_HEIGHT (w)
1364 - CURRENT_MODE_LINE_HEIGHT (w)
1365 - WINDOW_BOTTOM_DIVIDER_WIDTH (w))
1366 && y <= (bottom_y
1367 - CURRENT_MODE_LINE_HEIGHT (w)
1368 - WINDOW_BOTTOM_DIVIDER_WIDTH (w))))
1369 return ON_HORIZONTAL_SCROLL_BAR;
1370 /* On the mode or header line? */
1371 else if ((WINDOW_WANTS_MODELINE_P (w)
1372 && y >= (bottom_y
1373 - CURRENT_MODE_LINE_HEIGHT (w)
1374 - WINDOW_BOTTOM_DIVIDER_WIDTH (w))
1375 && y <= bottom_y - WINDOW_BOTTOM_DIVIDER_WIDTH (w)
1376 && (part = ON_MODE_LINE))
1377 || (WINDOW_WANTS_HEADER_LINE_P (w)
1378 && y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
1379 && (part = ON_HEADER_LINE)))
1381 /* If it's under/over the scroll bar portion of the mode/header
1382 line, say it's on the vertical line. That's to be able to
1383 resize windows horizontally in case we're using toolkit scroll
1384 bars. Note: If scrollbars are on the left, the window that
1385 must be eventually resized is that on the left of WINDOW. */
1386 if ((WINDOW_RIGHT_DIVIDER_WIDTH (w) == 0)
1387 && ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
1388 && !WINDOW_LEFTMOST_P (w)
1389 && eabs (x - left_x) < grabbable_width)
1390 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
1391 && !WINDOW_RIGHTMOST_P (w)
1392 && eabs (x - right_x) < grabbable_width)))
1393 return ON_VERTICAL_BORDER;
1394 else
1395 return part;
1398 /* In what's below, we subtract 1 when computing right_x because we
1399 want the rightmost pixel, which is given by left_pixel+width-1. */
1400 if (w->pseudo_window_p)
1402 left_x = 0;
1403 right_x = WINDOW_PIXEL_WIDTH (w) - 1;
1405 else
1407 left_x = WINDOW_BOX_LEFT_EDGE_X (w);
1408 right_x = WINDOW_BOX_RIGHT_EDGE_X (w) - 1;
1411 /* Outside any interesting column? */
1412 if (x < left_x || x > right_x)
1413 return ON_VERTICAL_SCROLL_BAR;
1415 lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
1416 rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
1418 text_left = window_box_left (w, TEXT_AREA);
1419 text_right = text_left + window_box_width (w, TEXT_AREA);
1421 if (FRAME_WINDOW_P (f))
1423 if (!w->pseudo_window_p
1424 && WINDOW_RIGHT_DIVIDER_WIDTH (w) == 0
1425 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
1426 && !WINDOW_RIGHTMOST_P (w)
1427 && (eabs (x - right_x) < grabbable_width))
1428 return ON_VERTICAL_BORDER;
1430 /* Need to say "x > right_x" rather than >=, since on character
1431 terminals, the vertical line's x coordinate is right_x. */
1432 else if (!w->pseudo_window_p
1433 && WINDOW_RIGHT_DIVIDER_WIDTH (w) == 0
1434 && !WINDOW_RIGHTMOST_P (w)
1435 /* Why check ux if we are not the rightmost window? Also
1436 shouldn't a pseudo window always be rightmost? */
1437 && x > right_x - ux)
1438 return ON_VERTICAL_BORDER;
1440 if (x < text_left)
1442 if (lmargin_width > 0
1443 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
1444 ? (x >= left_x + WINDOW_LEFT_FRINGE_WIDTH (w))
1445 : (x < left_x + lmargin_width)))
1446 return ON_LEFT_MARGIN;
1447 else
1448 return ON_LEFT_FRINGE;
1451 if (x >= text_right)
1453 if (rmargin_width > 0
1454 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
1455 ? (x < right_x - WINDOW_RIGHT_FRINGE_WIDTH (w))
1456 : (x >= right_x - rmargin_width)))
1457 return ON_RIGHT_MARGIN;
1458 else
1459 return ON_RIGHT_FRINGE;
1462 /* Everything special ruled out - must be on text area */
1463 return ON_TEXT;
1466 /* Take X is the frame-relative pixel x-coordinate, and return the
1467 x-coordinate relative to part PART of window W. */
1469 window_relative_x_coord (struct window *w, enum window_part part, int x)
1471 int left_x = (w->pseudo_window_p) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w);
1473 switch (part)
1475 case ON_TEXT:
1476 return x - window_box_left (w, TEXT_AREA);
1478 case ON_HEADER_LINE:
1479 case ON_MODE_LINE:
1480 case ON_LEFT_FRINGE:
1481 return x - left_x;
1483 case ON_RIGHT_FRINGE:
1484 return x - left_x - WINDOW_LEFT_FRINGE_WIDTH (w);
1486 case ON_LEFT_MARGIN:
1487 return (x - left_x
1488 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
1489 ? WINDOW_LEFT_FRINGE_WIDTH (w) : 0));
1491 case ON_RIGHT_MARGIN:
1492 return (x + 1
1493 - ((w->pseudo_window_p)
1494 ? WINDOW_PIXEL_WIDTH (w)
1495 : WINDOW_BOX_RIGHT_EDGE_X (w))
1496 + window_box_width (w, RIGHT_MARGIN_AREA)
1497 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
1498 ? WINDOW_RIGHT_FRINGE_WIDTH (w) : 0));
1501 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1502 return 0;
1506 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
1507 Scoordinates_in_window_p, 2, 2, 0,
1508 doc: /* Return non-nil if COORDINATES are in WINDOW.
1509 WINDOW must be a live window and defaults to the selected one.
1510 COORDINATES is a cons of the form (X . Y), X and Y being distances
1511 measured in characters from the upper-left corner of the frame.
1512 \(0 . 0) denotes the character in the upper left corner of the
1513 frame.
1514 If COORDINATES are in the text portion of WINDOW,
1515 the coordinates relative to the window are returned.
1516 If they are in the bottom divider of WINDOW, `bottom-divider' is returned.
1517 If they are in the right divider of WINDOW, `right-divider' is returned.
1518 If they are in the mode line of WINDOW, `mode-line' is returned.
1519 If they are in the header line of WINDOW, `header-line' is returned.
1520 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1521 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1522 If they are on the border between WINDOW and its right sibling,
1523 `vertical-line' is returned.
1524 If they are in the windows's left or right marginal areas, `left-margin'\n\
1525 or `right-margin' is returned. */)
1526 (register Lisp_Object coordinates, Lisp_Object window)
1528 struct window *w;
1529 struct frame *f;
1530 int x, y;
1531 Lisp_Object lx, ly;
1533 w = decode_live_window (window);
1534 f = XFRAME (w->frame);
1535 CHECK_CONS (coordinates);
1536 lx = Fcar (coordinates);
1537 ly = Fcdr (coordinates);
1538 CHECK_NUMBER_OR_FLOAT (lx);
1539 CHECK_NUMBER_OR_FLOAT (ly);
1540 x = FRAME_PIXEL_X_FROM_CANON_X (f, lx) + FRAME_INTERNAL_BORDER_WIDTH (f);
1541 y = FRAME_PIXEL_Y_FROM_CANON_Y (f, ly) + FRAME_INTERNAL_BORDER_WIDTH (f);
1543 switch (coordinates_in_window (w, x, y))
1545 case ON_NOTHING:
1546 return Qnil;
1548 case ON_TEXT:
1549 /* Convert X and Y to window relative pixel coordinates, and
1550 return the canonical char units. */
1551 x -= window_box_left (w, TEXT_AREA);
1552 y -= WINDOW_TOP_EDGE_Y (w);
1553 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f, x),
1554 FRAME_CANON_Y_FROM_PIXEL_Y (f, y));
1556 case ON_MODE_LINE:
1557 return Qmode_line;
1559 case ON_VERTICAL_BORDER:
1560 return Qvertical_line;
1562 case ON_HEADER_LINE:
1563 return Qheader_line;
1565 case ON_LEFT_FRINGE:
1566 return Qleft_fringe;
1568 case ON_RIGHT_FRINGE:
1569 return Qright_fringe;
1571 case ON_LEFT_MARGIN:
1572 return Qleft_margin;
1574 case ON_RIGHT_MARGIN:
1575 return Qright_margin;
1577 case ON_VERTICAL_SCROLL_BAR:
1578 /* Historically we are supposed to return nil in this case. */
1579 return Qnil;
1581 case ON_HORIZONTAL_SCROLL_BAR:
1582 return Qnil;
1584 case ON_RIGHT_DIVIDER:
1585 return Qright_divider;
1587 case ON_BOTTOM_DIVIDER:
1588 return Qbottom_divider;
1590 default:
1591 emacs_abort ();
1596 /* Callback for foreach_window, used in window_from_coordinates.
1597 Check if window W contains coordinates specified by USER_DATA which
1598 is actually a pointer to a struct check_window_data CW.
1600 Check if window W contains coordinates *CW->x and *CW->y. If it
1601 does, return W in *CW->window, as Lisp_Object, and return in
1602 *CW->part the part of the window under coordinates *X,*Y. Return
1603 zero from this function to stop iterating over windows. */
1605 struct check_window_data
1607 Lisp_Object *window;
1608 int x, y;
1609 enum window_part *part;
1612 static int
1613 check_window_containing (struct window *w, void *user_data)
1615 struct check_window_data *cw = user_data;
1616 enum window_part found;
1617 int continue_p = 1;
1619 found = coordinates_in_window (w, cw->x, cw->y);
1620 if (found != ON_NOTHING)
1622 *cw->part = found;
1623 XSETWINDOW (*cw->window, w);
1624 continue_p = 0;
1627 return continue_p;
1631 /* Find the window containing frame-relative pixel position X/Y and
1632 return it as a Lisp_Object.
1634 If X, Y is on one of the window's special `window_part' elements,
1635 set *PART to the id of that element.
1637 If there is no window under X, Y return nil and leave *PART
1638 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1640 This function was previously implemented with a loop cycling over
1641 windows with Fnext_window, and starting with the frame's selected
1642 window. It turned out that this doesn't work with an
1643 implementation of next_window using Vwindow_list, because
1644 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1645 tree of F when this function is called asynchronously from
1646 note_mouse_highlight. The original loop didn't terminate in this
1647 case. */
1649 Lisp_Object
1650 window_from_coordinates (struct frame *f, int x, int y,
1651 enum window_part *part, bool tool_bar_p)
1653 Lisp_Object window;
1654 struct check_window_data cw;
1655 enum window_part dummy;
1657 if (part == 0)
1658 part = &dummy;
1660 window = Qnil;
1661 cw.window = &window, cw.x = x, cw.y = y; cw.part = part;
1662 foreach_window (f, check_window_containing, &cw);
1664 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
1665 /* If not found above, see if it's in the tool bar window, if a tool
1666 bar exists. */
1667 if (NILP (window)
1668 && tool_bar_p
1669 && WINDOWP (f->tool_bar_window)
1670 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0
1671 && (coordinates_in_window (XWINDOW (f->tool_bar_window), x, y)
1672 != ON_NOTHING))
1674 *part = ON_TEXT;
1675 window = f->tool_bar_window;
1677 #endif
1679 return window;
1682 DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
1683 doc: /* Return window containing coordinates X and Y on FRAME.
1684 FRAME must be a live frame and defaults to the selected one.
1685 The top left corner of the frame is considered to be row 0,
1686 column 0. */)
1687 (Lisp_Object x, Lisp_Object y, Lisp_Object frame)
1689 struct frame *f = decode_live_frame (frame);
1691 /* Check that arguments are integers or floats. */
1692 CHECK_NUMBER_OR_FLOAT (x);
1693 CHECK_NUMBER_OR_FLOAT (y);
1695 return window_from_coordinates (f,
1696 (FRAME_PIXEL_X_FROM_CANON_X (f, x)
1697 + FRAME_INTERNAL_BORDER_WIDTH (f)),
1698 (FRAME_PIXEL_Y_FROM_CANON_Y (f, y)
1699 + FRAME_INTERNAL_BORDER_WIDTH (f)),
1700 0, 0);
1703 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
1704 doc: /* Return current value of point in WINDOW.
1705 WINDOW must be a live window and defaults to the selected one.
1707 For a nonselected window, this is the value point would have if that
1708 window were selected.
1710 Note that, when WINDOW is selected, the value returned is the same as
1711 that returned by `point' for WINDOW's buffer. It would be more strictly
1712 correct to return the top-level value of `point', outside of any
1713 `save-excursion' forms. But that is hard to define. */)
1714 (Lisp_Object window)
1716 register struct window *w = decode_live_window (window);
1718 if (w == XWINDOW (selected_window))
1719 return make_number (BUF_PT (XBUFFER (w->contents)));
1720 else
1721 return Fmarker_position (w->pointm);
1724 DEFUN ("window-old-point", Fwindow_old_point, Swindow_old_point, 0, 1, 0,
1725 doc: /* Return old value of point in WINDOW.
1726 WINDOW must be a live window and defaults to the selected one. */)
1727 (Lisp_Object window)
1729 return Fmarker_position (decode_live_window (window)->old_pointm);
1732 DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
1733 doc: /* Return position at which display currently starts in WINDOW.
1734 WINDOW must be a live window and defaults to the selected one.
1735 This is updated by redisplay or by calling `set-window-start'. */)
1736 (Lisp_Object window)
1738 return Fmarker_position (decode_live_window (window)->start);
1741 /* This is text temporarily removed from the doc string below.
1743 This function returns nil if the position is not currently known.
1744 That happens when redisplay is preempted and doesn't finish.
1745 If in that case you want to compute where the end of the window would
1746 have been if redisplay had finished, do this:
1747 (save-excursion
1748 (goto-char (window-start window))
1749 (vertical-motion (1- (window-height window)) window)
1750 (point))") */
1752 DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0,
1753 doc: /* Return position at which display currently ends in WINDOW.
1754 WINDOW must be a live window and defaults to the selected one.
1755 This is updated by redisplay, when it runs to completion.
1756 Simply changing the buffer text or setting `window-start'
1757 does not update this value.
1758 Return nil if there is no recorded value. (This can happen if the
1759 last redisplay of WINDOW was preempted, and did not finish.)
1760 If UPDATE is non-nil, compute the up-to-date position
1761 if it isn't already recorded. */)
1762 (Lisp_Object window, Lisp_Object update)
1764 Lisp_Object value;
1765 struct window *w = decode_live_window (window);
1766 Lisp_Object buf;
1767 struct buffer *b;
1769 buf = w->contents;
1770 CHECK_BUFFER (buf);
1771 b = XBUFFER (buf);
1773 if (! NILP (update)
1774 && (windows_or_buffers_changed
1775 || !w->window_end_valid
1776 || b->clip_changed
1777 || b->prevent_redisplay_optimizations_p
1778 || window_outdated (w))
1779 && !noninteractive)
1781 struct text_pos startp;
1782 struct it it;
1783 struct buffer *old_buffer = NULL;
1784 void *itdata = NULL;
1786 /* Cannot use Fvertical_motion because that function doesn't
1787 cope with variable-height lines. */
1788 if (b != current_buffer)
1790 old_buffer = current_buffer;
1791 set_buffer_internal (b);
1794 /* In case W->start is out of the range, use something
1795 reasonable. This situation occurred when loading a file with
1796 `-l' containing a call to `rmail' with subsequent other
1797 commands. At the end, W->start happened to be BEG, while
1798 rmail had already narrowed the buffer. */
1799 CLIP_TEXT_POS_FROM_MARKER (startp, w->start);
1801 itdata = bidi_shelve_cache ();
1802 start_display (&it, w, startp);
1803 move_it_vertically (&it, window_box_height (w));
1804 if (it.current_y < it.last_visible_y)
1805 move_it_past_eol (&it);
1806 value = make_number (IT_CHARPOS (it));
1807 bidi_unshelve_cache (itdata, 0);
1809 if (old_buffer)
1810 set_buffer_internal (old_buffer);
1812 else
1813 XSETINT (value, BUF_Z (b) - w->window_end_pos);
1815 return value;
1818 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
1819 doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1820 WINDOW must be a live window and defaults to the selected one.
1821 Return POS. */)
1822 (Lisp_Object window, Lisp_Object pos)
1824 register struct window *w = decode_live_window (window);
1826 /* Type of POS is checked by Fgoto_char or set_marker_restricted ... */
1828 if (w == XWINDOW (selected_window))
1830 if (XBUFFER (w->contents) == current_buffer)
1831 Fgoto_char (pos);
1832 else
1834 struct buffer *old_buffer = current_buffer;
1836 /* ... but here we want to catch type error before buffer change. */
1837 CHECK_NUMBER_COERCE_MARKER (pos);
1838 set_buffer_internal (XBUFFER (w->contents));
1839 Fgoto_char (pos);
1840 set_buffer_internal (old_buffer);
1843 else
1845 set_marker_restricted (w->pointm, pos, w->contents);
1846 /* We have to make sure that redisplay updates the window to show
1847 the new value of point. */
1848 wset_redisplay (w);
1851 return pos;
1854 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
1855 doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1856 WINDOW must be a live window and defaults to the selected one. Return
1857 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1858 overriding motion of point in order to display at this exact start. */)
1859 (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
1861 register struct window *w = decode_live_window (window);
1863 set_marker_restricted (w->start, pos, w->contents);
1864 /* This is not right, but much easier than doing what is right. */
1865 w->start_at_line_beg = 0;
1866 if (NILP (noforce))
1867 w->force_start = 1;
1868 w->update_mode_line = 1;
1869 /* Bug#15957. */
1870 w->window_end_valid = 0;
1871 wset_redisplay (w);
1873 return pos;
1876 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
1877 Spos_visible_in_window_p, 0, 3, 0,
1878 doc: /* Return non-nil if position POS is currently on the frame in WINDOW.
1879 WINDOW must be a live window and defaults to the selected one.
1881 Return nil if that position is scrolled vertically out of view. If a
1882 character is only partially visible, nil is returned, unless the
1883 optional argument PARTIALLY is non-nil. If POS is only out of view
1884 because of horizontal scrolling, return non-nil. If POS is t, it
1885 specifies the position of the last visible glyph in WINDOW. POS
1886 defaults to point in WINDOW; WINDOW defaults to the selected window.
1888 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1889 the return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1890 where X and Y are the pixel coordinates relative to the top left corner
1891 of the window. The remaining elements are omitted if the character after
1892 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1893 off-window at the top and bottom of the screen line ("row") containing
1894 POS, ROWH is the visible height of that row, and VPOS is the row number
1895 \(zero-based). */)
1896 (Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
1898 register struct window *w;
1899 register EMACS_INT posint;
1900 register struct buffer *buf;
1901 struct text_pos top;
1902 Lisp_Object in_window = Qnil;
1903 int rtop, rbot, rowh, vpos, fully_p = 1;
1904 int x, y;
1906 w = decode_live_window (window);
1907 buf = XBUFFER (w->contents);
1908 SET_TEXT_POS_FROM_MARKER (top, w->start);
1910 if (EQ (pos, Qt))
1911 posint = -1;
1912 else if (!NILP (pos))
1914 CHECK_NUMBER_COERCE_MARKER (pos);
1915 posint = XINT (pos);
1917 else if (w == XWINDOW (selected_window))
1918 posint = PT;
1919 else
1920 posint = marker_position (w->pointm);
1922 /* If position is above window start or outside buffer boundaries,
1923 or if window start is out of range, position is not visible. */
1924 if ((EQ (pos, Qt)
1925 || (posint >= CHARPOS (top) && posint <= BUF_ZV (buf)))
1926 && CHARPOS (top) >= BUF_BEGV (buf)
1927 && CHARPOS (top) <= BUF_ZV (buf)
1928 && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, &rowh, &vpos)
1929 && (fully_p = !rtop && !rbot, (!NILP (partially) || fully_p)))
1930 in_window = Qt;
1932 if (!NILP (in_window) && !NILP (partially))
1934 Lisp_Object part = Qnil;
1935 if (!fully_p)
1936 part = list4i (rtop, rbot, rowh, vpos);
1937 in_window = Fcons (make_number (x),
1938 Fcons (make_number (y), part));
1941 return in_window;
1944 DEFUN ("window-line-height", Fwindow_line_height,
1945 Swindow_line_height, 0, 2, 0,
1946 doc: /* Return height in pixels of text line LINE in window WINDOW.
1947 WINDOW must be a live window and defaults to the selected one.
1949 Return height of current line if LINE is omitted or nil. Return height of
1950 header or mode line if LINE is `header-line' or `mode-line'.
1951 Otherwise, LINE is a text line number starting from 0. A negative number
1952 counts from the end of the window.
1954 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1955 in pixels of the visible part of the line, VPOS and YPOS are the
1956 vertical position in lines and pixels of the line, relative to the top
1957 of the first text line, and OFFBOT is the number of off-window pixels at
1958 the bottom of the text line. If there are off-window pixels at the top
1959 of the (first) text line, YPOS is negative.
1961 Return nil if window display is not up-to-date. In that case, use
1962 `pos-visible-in-window-p' to obtain the information. */)
1963 (Lisp_Object line, Lisp_Object window)
1965 register struct window *w;
1966 register struct buffer *b;
1967 struct glyph_row *row, *end_row;
1968 int max_y, crop, i;
1969 EMACS_INT n;
1971 w = decode_live_window (window);
1973 if (noninteractive || w->pseudo_window_p)
1974 return Qnil;
1976 CHECK_BUFFER (w->contents);
1977 b = XBUFFER (w->contents);
1979 /* Fail if current matrix is not up-to-date. */
1980 if (!w->window_end_valid
1981 || windows_or_buffers_changed
1982 || b->clip_changed
1983 || b->prevent_redisplay_optimizations_p
1984 || window_outdated (w))
1985 return Qnil;
1987 if (NILP (line))
1989 i = w->cursor.vpos;
1990 if (i < 0 || i >= w->current_matrix->nrows
1991 || (row = MATRIX_ROW (w->current_matrix, i), !row->enabled_p))
1992 return Qnil;
1993 max_y = window_text_bottom_y (w);
1994 goto found_row;
1997 if (EQ (line, Qheader_line))
1999 if (!WINDOW_WANTS_HEADER_LINE_P (w))
2000 return Qnil;
2001 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
2002 return row->enabled_p ? list4i (row->height, 0, 0, 0) : Qnil;
2005 if (EQ (line, Qmode_line))
2007 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
2008 return (row->enabled_p ?
2009 list4i (row->height,
2010 0, /* not accurate */
2011 (WINDOW_HEADER_LINE_HEIGHT (w)
2012 + window_text_bottom_y (w)),
2014 : Qnil);
2017 CHECK_NUMBER (line);
2018 n = XINT (line);
2020 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
2021 end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
2022 max_y = window_text_bottom_y (w);
2023 i = 0;
2025 while ((n < 0 || i < n)
2026 && row <= end_row && row->enabled_p
2027 && row->y + row->height < max_y)
2028 row++, i++;
2030 if (row > end_row || !row->enabled_p)
2031 return Qnil;
2033 if (++n < 0)
2035 if (-n > i)
2036 return Qnil;
2037 row += n;
2038 i += n;
2041 found_row:
2042 crop = max (0, (row->y + row->height) - max_y);
2043 return list4i (row->height + min (0, row->y) - crop, i, row->y, crop);
2046 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
2047 0, 1, 0,
2048 doc: /* Return non-nil when WINDOW is dedicated to its buffer.
2049 More precisely, return the value assigned by the last call of
2050 `set-window-dedicated-p' for WINDOW. Return nil if that function was
2051 never called with WINDOW as its argument, or the value set by that
2052 function was internally reset since its last call. WINDOW must be a
2053 live window and defaults to the selected one.
2055 When a window is dedicated to its buffer, `display-buffer' will refrain
2056 from displaying another buffer in it. `get-lru-window' and
2057 `get-largest-window' treat dedicated windows specially.
2058 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
2059 `kill-buffer' can delete a dedicated window and the containing frame.
2061 Functions like `set-window-buffer' may change the buffer displayed by a
2062 window, unless that window is "strongly" dedicated to its buffer, that
2063 is the value returned by `window-dedicated-p' is t. */)
2064 (Lisp_Object window)
2066 return decode_live_window (window)->dedicated;
2069 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
2070 Sset_window_dedicated_p, 2, 2, 0,
2071 doc: /* Mark WINDOW as dedicated according to FLAG.
2072 WINDOW must be a live window and defaults to the selected one. FLAG
2073 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
2074 mark WINDOW as non-dedicated. Return FLAG.
2076 When a window is dedicated to its buffer, `display-buffer' will refrain
2077 from displaying another buffer in it. `get-lru-window' and
2078 `get-largest-window' treat dedicated windows specially.
2079 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
2080 `quit-restore-window' and `kill-buffer' can delete a dedicated window
2081 and the containing frame.
2083 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
2084 its buffer. Functions like `set-window-buffer' may change the buffer
2085 displayed by a window, unless that window is strongly dedicated to its
2086 buffer. If and when `set-window-buffer' displays another buffer in a
2087 window, it also makes sure that the window is no more dedicated. */)
2088 (Lisp_Object window, Lisp_Object flag)
2090 wset_dedicated (decode_live_window (window), flag);
2091 return flag;
2094 DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
2095 0, 1, 0,
2096 doc: /* Return buffers previously shown in WINDOW.
2097 WINDOW must be a live window and defaults to the selected one.
2099 The return value is a list of elements (BUFFER WINDOW-START POS),
2100 where BUFFER is a buffer, WINDOW-START is the start position of the
2101 window for that buffer, and POS is a window-specific point value. */)
2102 (Lisp_Object window)
2104 return decode_live_window (window)->prev_buffers;
2107 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
2108 Sset_window_prev_buffers, 2, 2, 0,
2109 doc: /* Set WINDOW's previous buffers to PREV-BUFFERS.
2110 WINDOW must be a live window and defaults to the selected one.
2112 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
2113 where BUFFER is a buffer, WINDOW-START is the start position of the
2114 window for that buffer, and POS is a window-specific point value. */)
2115 (Lisp_Object window, Lisp_Object prev_buffers)
2117 wset_prev_buffers (decode_live_window (window), prev_buffers);
2118 return prev_buffers;
2121 DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
2122 0, 1, 0,
2123 doc: /* Return list of buffers recently re-shown in WINDOW.
2124 WINDOW must be a live window and defaults to the selected one. */)
2125 (Lisp_Object window)
2127 return decode_live_window (window)->next_buffers;
2130 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
2131 Sset_window_next_buffers, 2, 2, 0,
2132 doc: /* Set WINDOW's next buffers to NEXT-BUFFERS.
2133 WINDOW must be a live window and defaults to the selected one.
2134 NEXT-BUFFERS should be a list of buffers. */)
2135 (Lisp_Object window, Lisp_Object next_buffers)
2137 wset_next_buffers (decode_live_window (window), next_buffers);
2138 return next_buffers;
2141 DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
2142 0, 1, 0,
2143 doc: /* Return the parameters of WINDOW and their values.
2144 WINDOW must be a valid window and defaults to the selected one. The
2145 return value is a list of elements of the form (PARAMETER . VALUE). */)
2146 (Lisp_Object window)
2148 return Fcopy_alist (decode_valid_window (window)->window_parameters);
2151 DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
2152 2, 2, 0,
2153 doc: /* Return WINDOW's value for PARAMETER.
2154 WINDOW can be any window and defaults to the selected one. */)
2155 (Lisp_Object window, Lisp_Object parameter)
2157 Lisp_Object result;
2159 result = Fassq (parameter, decode_any_window (window)->window_parameters);
2160 return CDR_SAFE (result);
2163 DEFUN ("set-window-parameter", Fset_window_parameter,
2164 Sset_window_parameter, 3, 3, 0,
2165 doc: /* Set WINDOW's value of PARAMETER to VALUE.
2166 WINDOW can be any window and defaults to the selected one.
2167 Return VALUE. */)
2168 (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
2170 register struct window *w = decode_any_window (window);
2171 Lisp_Object old_alist_elt;
2173 old_alist_elt = Fassq (parameter, w->window_parameters);
2174 if (NILP (old_alist_elt))
2175 wset_window_parameters
2176 (w, Fcons (Fcons (parameter, value), w->window_parameters));
2177 else
2178 Fsetcdr (old_alist_elt, value);
2179 return value;
2182 DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
2183 0, 1, 0,
2184 doc: /* Return the display-table that WINDOW is using.
2185 WINDOW must be a live window and defaults to the selected one. */)
2186 (Lisp_Object window)
2188 return decode_live_window (window)->display_table;
2191 /* Get the display table for use on window W. This is either W's
2192 display table or W's buffer's display table. Ignore the specified
2193 tables if they are not valid; if no valid table is specified,
2194 return 0. */
2196 struct Lisp_Char_Table *
2197 window_display_table (struct window *w)
2199 struct Lisp_Char_Table *dp = NULL;
2201 if (DISP_TABLE_P (w->display_table))
2202 dp = XCHAR_TABLE (w->display_table);
2203 else if (BUFFERP (w->contents))
2205 struct buffer *b = XBUFFER (w->contents);
2207 if (DISP_TABLE_P (BVAR (b, display_table)))
2208 dp = XCHAR_TABLE (BVAR (b, display_table));
2209 else if (DISP_TABLE_P (Vstandard_display_table))
2210 dp = XCHAR_TABLE (Vstandard_display_table);
2213 return dp;
2216 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
2217 doc: /* Set WINDOW's display-table to TABLE.
2218 WINDOW must be a live window and defaults to the selected one. */)
2219 (register Lisp_Object window, Lisp_Object table)
2221 wset_display_table (decode_live_window (window), table);
2222 return table;
2225 /* Record info on buffer window W is displaying
2226 when it is about to cease to display that buffer. */
2227 static void
2228 unshow_buffer (register struct window *w)
2230 Lisp_Object buf = w->contents;
2231 struct buffer *b = XBUFFER (buf);
2233 eassert (b == XMARKER (w->pointm)->buffer);
2235 #if 0
2236 if (w == XWINDOW (selected_window)
2237 || ! EQ (buf, XWINDOW (selected_window)->contents))
2238 /* Do this except when the selected window's buffer
2239 is being removed from some other window. */
2240 #endif
2241 /* last_window_start records the start position that this buffer
2242 had in the last window to be disconnected from it.
2243 Now that this statement is unconditional,
2244 it is possible for the buffer to be displayed in the
2245 selected window, while last_window_start reflects another
2246 window which was recently showing the same buffer.
2247 Some people might say that might be a good thing. Let's see. */
2248 b->last_window_start = marker_position (w->start);
2250 /* Point in the selected window's buffer
2251 is actually stored in that buffer, and the window's pointm isn't used.
2252 So don't clobber point in that buffer. */
2253 if (! EQ (buf, XWINDOW (selected_window)->contents)
2254 /* Don't clobber point in current buffer either (this could be
2255 useful in connection with bug#12208).
2256 && XBUFFER (buf) != current_buffer */
2257 /* This line helps to fix Horsley's testbug.el bug. */
2258 && !(WINDOWP (BVAR (b, last_selected_window))
2259 && w != XWINDOW (BVAR (b, last_selected_window))
2260 && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->contents)))
2261 temp_set_point_both (b,
2262 clip_to_bounds (BUF_BEGV (b),
2263 marker_position (w->pointm),
2264 BUF_ZV (b)),
2265 clip_to_bounds (BUF_BEGV_BYTE (b),
2266 marker_byte_position (w->pointm),
2267 BUF_ZV_BYTE (b)));
2269 if (WINDOWP (BVAR (b, last_selected_window))
2270 && w == XWINDOW (BVAR (b, last_selected_window)))
2271 bset_last_selected_window (b, Qnil);
2274 /* Put NEW into the window structure in place of OLD. SETFLAG zero
2275 means change window structure only. Otherwise store geometry and
2276 other settings as well. */
2277 static void
2278 replace_window (Lisp_Object old, Lisp_Object new, int setflag)
2280 register Lisp_Object tem;
2281 register struct window *o = XWINDOW (old), *n = XWINDOW (new);
2283 /* If OLD is its frame's root window, then NEW is the new
2284 root window for that frame. */
2285 if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
2286 fset_root_window (XFRAME (o->frame), new);
2288 if (setflag)
2290 n->pixel_left = o->pixel_left;
2291 n->pixel_top = o->pixel_top;
2292 n->pixel_width = o->pixel_width;
2293 n->pixel_height = o->pixel_height;
2294 n->left_col = o->left_col;
2295 n->top_line = o->top_line;
2296 n->total_cols = o->total_cols;
2297 n->total_lines = o->total_lines;
2298 wset_normal_cols (n, o->normal_cols);
2299 wset_normal_cols (o, make_float (1.0));
2300 wset_normal_lines (n, o->normal_lines);
2301 wset_normal_lines (o, make_float (1.0));
2302 n->desired_matrix = n->current_matrix = 0;
2303 n->vscroll = 0;
2304 memset (&n->cursor, 0, sizeof (n->cursor));
2305 memset (&n->phys_cursor, 0, sizeof (n->phys_cursor));
2306 n->last_cursor_vpos = 0;
2307 #ifdef HAVE_WINDOW_SYSTEM
2308 n->phys_cursor_type = NO_CURSOR;
2309 n->phys_cursor_width = -1;
2310 #endif
2311 n->must_be_updated_p = 0;
2312 n->pseudo_window_p = 0;
2313 n->window_end_vpos = 0;
2314 n->window_end_pos = 0;
2315 n->window_end_valid = 0;
2318 tem = o->next;
2319 wset_next (n, tem);
2320 if (!NILP (tem))
2321 wset_prev (XWINDOW (tem), new);
2323 tem = o->prev;
2324 wset_prev (n, tem);
2325 if (!NILP (tem))
2326 wset_next (XWINDOW (tem), new);
2328 tem = o->parent;
2329 wset_parent (n, tem);
2330 if (!NILP (tem) && EQ (XWINDOW (tem)->contents, old))
2331 wset_combination (XWINDOW (tem), XWINDOW (tem)->horizontal, new);
2334 /* If window WINDOW and its parent window are iso-combined, merge
2335 WINDOW's children into those of its parent window and mark WINDOW as
2336 deleted. */
2338 static void
2339 recombine_windows (Lisp_Object window)
2341 struct window *w, *p, *c;
2342 Lisp_Object parent, child;
2343 bool horflag;
2345 w = XWINDOW (window);
2346 parent = w->parent;
2347 if (!NILP (parent) && NILP (w->combination_limit))
2349 p = XWINDOW (parent);
2350 if (WINDOWP (p->contents) && WINDOWP (w->contents)
2351 && p->horizontal == w->horizontal)
2352 /* WINDOW and PARENT are both either a vertical or a horizontal
2353 combination. */
2355 horflag = WINDOW_HORIZONTAL_COMBINATION_P (w);
2356 child = w->contents;
2357 c = XWINDOW (child);
2359 /* Splice WINDOW's children into its parent's children and
2360 assign new normal sizes. */
2361 if (NILP (w->prev))
2362 wset_combination (p, horflag, child);
2363 else
2365 wset_prev (c, w->prev);
2366 wset_next (XWINDOW (w->prev), child);
2369 while (c)
2371 wset_parent (c, parent);
2373 if (horflag)
2374 wset_normal_cols
2375 (c, make_float ((double) c->pixel_width
2376 / (double) p->pixel_width));
2377 else
2378 wset_normal_lines
2379 (c, make_float ((double) c->pixel_height
2380 / (double) p->pixel_height));
2382 if (NILP (c->next))
2384 if (!NILP (w->next))
2386 wset_next (c, w->next);
2387 wset_prev (XWINDOW (c->next), child);
2390 c = 0;
2392 else
2394 child = c->next;
2395 c = XWINDOW (child);
2399 /* WINDOW can be deleted now. */
2400 wset_combination (w, 0, Qnil);
2405 /* If WINDOW can be deleted, delete it. */
2406 static void
2407 delete_deletable_window (Lisp_Object window)
2409 if (!NILP (call1 (Qwindow_deletable_p, window)))
2410 call1 (Qdelete_window, window);
2413 /***********************************************************************
2414 Window List
2415 ***********************************************************************/
2417 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2418 pointer. This is a callback function for foreach_window, used in
2419 the window_list function. */
2421 static int
2422 add_window_to_list (struct window *w, void *user_data)
2424 Lisp_Object *list = user_data;
2425 Lisp_Object window;
2426 XSETWINDOW (window, w);
2427 *list = Fcons (window, *list);
2428 return 1;
2432 /* Return a list of all windows, for use by next_window. If
2433 Vwindow_list is a list, return that list. Otherwise, build a new
2434 list, cache it in Vwindow_list, and return that. */
2436 Lisp_Object
2437 window_list (void)
2439 if (!CONSP (Vwindow_list))
2441 Lisp_Object tail, frame;
2443 Vwindow_list = Qnil;
2444 FOR_EACH_FRAME (tail, frame)
2446 Lisp_Object args[2];
2448 /* We are visiting windows in canonical order, and add
2449 new windows at the front of args[1], which means we
2450 have to reverse this list at the end. */
2451 args[1] = Qnil;
2452 foreach_window (XFRAME (frame), add_window_to_list, &args[1]);
2453 args[0] = Vwindow_list;
2454 args[1] = Fnreverse (args[1]);
2455 Vwindow_list = Fnconc (2, args);
2459 return Vwindow_list;
2463 /* Value is non-zero if WINDOW satisfies the constraints given by
2464 OWINDOW, MINIBUF and ALL_FRAMES.
2466 MINIBUF t means WINDOW may be minibuffer windows.
2467 `lambda' means WINDOW may not be a minibuffer window.
2468 a window means a specific minibuffer window
2470 ALL_FRAMES t means search all frames,
2471 nil means search just current frame,
2472 `visible' means search just visible frames on the
2473 current terminal,
2474 0 means search visible and iconified frames on the
2475 current terminal,
2476 a window means search the frame that window belongs to,
2477 a frame means consider windows on that frame, only. */
2479 static bool
2480 candidate_window_p (Lisp_Object window, Lisp_Object owindow,
2481 Lisp_Object minibuf, Lisp_Object all_frames)
2483 struct window *w = XWINDOW (window);
2484 struct frame *f = XFRAME (w->frame);
2485 bool candidate_p = 1;
2487 if (!BUFFERP (w->contents))
2488 candidate_p = 0;
2489 else if (MINI_WINDOW_P (w)
2490 && (EQ (minibuf, Qlambda)
2491 || (WINDOWP (minibuf) && !EQ (minibuf, window))))
2493 /* If MINIBUF is `lambda' don't consider any mini-windows.
2494 If it is a window, consider only that one. */
2495 candidate_p = 0;
2497 else if (EQ (all_frames, Qt))
2498 candidate_p = 1;
2499 else if (NILP (all_frames))
2501 eassert (WINDOWP (owindow));
2502 candidate_p = EQ (w->frame, XWINDOW (owindow)->frame);
2504 else if (EQ (all_frames, Qvisible))
2506 candidate_p = FRAME_VISIBLE_P (f)
2507 && (FRAME_TERMINAL (XFRAME (w->frame))
2508 == FRAME_TERMINAL (XFRAME (selected_frame)));
2511 else if (INTEGERP (all_frames) && XINT (all_frames) == 0)
2513 candidate_p = (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)
2514 #ifdef HAVE_X_WINDOWS
2515 /* Yuck!! If we've just created the frame and the
2516 window-manager requested the user to place it
2517 manually, the window may still not be considered
2518 `visible'. I'd argue it should be at least
2519 something like `iconified', but don't know how to do
2520 that yet. --Stef */
2521 || (FRAME_X_P (f) && f->output_data.x->asked_for_visible
2522 && !f->output_data.x->has_been_visible)
2523 #endif
2525 && (FRAME_TERMINAL (XFRAME (w->frame))
2526 == FRAME_TERMINAL (XFRAME (selected_frame)));
2528 else if (WINDOWP (all_frames))
2529 candidate_p = (EQ (FRAME_MINIBUF_WINDOW (f), all_frames)
2530 || EQ (XWINDOW (all_frames)->frame, w->frame)
2531 || EQ (XWINDOW (all_frames)->frame, FRAME_FOCUS_FRAME (f)));
2532 else if (FRAMEP (all_frames))
2533 candidate_p = EQ (all_frames, w->frame);
2535 return candidate_p;
2539 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2540 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2541 MINIBUF, and ALL_FRAMES. */
2543 static void
2544 decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object *all_frames)
2546 struct window *w = decode_live_window (*window);
2548 XSETWINDOW (*window, w);
2549 /* MINIBUF nil may or may not include minibuffers. Decide if it
2550 does. */
2551 if (NILP (*minibuf))
2552 *minibuf = minibuf_level ? minibuf_window : Qlambda;
2553 else if (!EQ (*minibuf, Qt))
2554 *minibuf = Qlambda;
2556 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2557 => count none of them, or a specific minibuffer window (the
2558 active one) to count. */
2560 /* ALL_FRAMES nil doesn't specify which frames to include. */
2561 if (NILP (*all_frames))
2562 *all_frames
2563 = (!EQ (*minibuf, Qlambda)
2564 ? FRAME_MINIBUF_WINDOW (XFRAME (w->frame))
2565 : Qnil);
2566 else if (EQ (*all_frames, Qvisible))
2568 else if (EQ (*all_frames, make_number (0)))
2570 else if (FRAMEP (*all_frames))
2572 else if (!EQ (*all_frames, Qt))
2573 *all_frames = Qnil;
2577 /* Return the next or previous window of WINDOW in cyclic ordering
2578 of windows. NEXT_P non-zero means return the next window. See the
2579 documentation string of next-window for the meaning of MINIBUF and
2580 ALL_FRAMES. */
2582 static Lisp_Object
2583 next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames, int next_p)
2585 decode_next_window_args (&window, &minibuf, &all_frames);
2587 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2588 return the first window on the frame. */
2589 if (FRAMEP (all_frames)
2590 && !EQ (all_frames, XWINDOW (window)->frame))
2591 return Fframe_first_window (all_frames);
2593 if (next_p)
2595 Lisp_Object list;
2597 /* Find WINDOW in the list of all windows. */
2598 list = Fmemq (window, window_list ());
2600 /* Scan forward from WINDOW to the end of the window list. */
2601 if (CONSP (list))
2602 for (list = XCDR (list); CONSP (list); list = XCDR (list))
2603 if (candidate_window_p (XCAR (list), window, minibuf, all_frames))
2604 break;
2606 /* Scan from the start of the window list up to WINDOW. */
2607 if (!CONSP (list))
2608 for (list = Vwindow_list;
2609 CONSP (list) && !EQ (XCAR (list), window);
2610 list = XCDR (list))
2611 if (candidate_window_p (XCAR (list), window, minibuf, all_frames))
2612 break;
2614 if (CONSP (list))
2615 window = XCAR (list);
2617 else
2619 Lisp_Object candidate, list;
2621 /* Scan through the list of windows for candidates. If there are
2622 candidate windows in front of WINDOW, the last one of these
2623 is the one we want. If there are candidates following WINDOW
2624 in the list, again the last one of these is the one we want. */
2625 candidate = Qnil;
2626 for (list = window_list (); CONSP (list); list = XCDR (list))
2628 if (EQ (XCAR (list), window))
2630 if (WINDOWP (candidate))
2631 break;
2633 else if (candidate_window_p (XCAR (list), window, minibuf,
2634 all_frames))
2635 candidate = XCAR (list);
2638 if (WINDOWP (candidate))
2639 window = candidate;
2642 return window;
2646 DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
2647 doc: /* Return live window after WINDOW in the cyclic ordering of windows.
2648 WINDOW must be a live window and defaults to the selected one. The
2649 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2650 consider.
2652 MINIBUF nil or omitted means consider the minibuffer window only if the
2653 minibuffer is active. MINIBUF t means consider the minibuffer window
2654 even if the minibuffer is not active. Any other value means do not
2655 consider the minibuffer window even if the minibuffer is active.
2657 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2658 plus the minibuffer window if specified by the MINIBUF argument. If the
2659 minibuffer counts, consider all windows on all frames that share that
2660 minibuffer too. The following non-nil values of ALL-FRAMES have special
2661 meanings:
2663 - t means consider all windows on all existing frames.
2665 - `visible' means consider all windows on all visible frames.
2667 - 0 (the number zero) means consider all windows on all visible and
2668 iconified frames.
2670 - A frame means consider all windows on that frame only.
2672 Anything else means consider all windows on WINDOW's frame and no
2673 others.
2675 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2676 `next-window' to iterate through the entire cycle of acceptable
2677 windows, eventually ending up back at the window you started with.
2678 `previous-window' traverses the same cycle, in the reverse order. */)
2679 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2681 return next_window (window, minibuf, all_frames, 1);
2685 DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0,
2686 doc: /* Return live window before WINDOW in the cyclic ordering of windows.
2687 WINDOW must be a live window and defaults to the selected one. The
2688 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2689 consider.
2691 MINIBUF nil or omitted means consider the minibuffer window only if the
2692 minibuffer is active. MINIBUF t means consider the minibuffer window
2693 even if the minibuffer is not active. Any other value means do not
2694 consider the minibuffer window even if the minibuffer is active.
2696 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2697 plus the minibuffer window if specified by the MINIBUF argument. If the
2698 minibuffer counts, consider all windows on all frames that share that
2699 minibuffer too. The following non-nil values of ALL-FRAMES have special
2700 meanings:
2702 - t means consider all windows on all existing frames.
2704 - `visible' means consider all windows on all visible frames.
2706 - 0 (the number zero) means consider all windows on all visible and
2707 iconified frames.
2709 - A frame means consider all windows on that frame only.
2711 Anything else means consider all windows on WINDOW's frame and no
2712 others.
2714 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2715 use `previous-window' to iterate through the entire cycle of
2716 acceptable windows, eventually ending up back at the window you
2717 started with. `next-window' traverses the same cycle, in the
2718 reverse order. */)
2719 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2721 return next_window (window, minibuf, all_frames, 0);
2725 /* Return a list of windows in cyclic ordering. Arguments are like
2726 for `next-window'. */
2728 static Lisp_Object
2729 window_list_1 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2731 Lisp_Object tail, list, rest;
2733 decode_next_window_args (&window, &minibuf, &all_frames);
2734 list = Qnil;
2736 for (tail = window_list (); CONSP (tail); tail = XCDR (tail))
2737 if (candidate_window_p (XCAR (tail), window, minibuf, all_frames))
2738 list = Fcons (XCAR (tail), list);
2740 /* Rotate the list to start with WINDOW. */
2741 list = Fnreverse (list);
2742 rest = Fmemq (window, list);
2743 if (!NILP (rest) && !EQ (rest, list))
2745 for (tail = list; !EQ (XCDR (tail), rest); tail = XCDR (tail))
2747 XSETCDR (tail, Qnil);
2748 list = nconc2 (rest, list);
2750 return list;
2754 DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0,
2755 doc: /* Return a list of windows on FRAME, starting with WINDOW.
2756 FRAME nil or omitted means use the selected frame.
2757 WINDOW nil or omitted means use the window selected within FRAME.
2758 MINIBUF t means include the minibuffer window, even if it isn't active.
2759 MINIBUF nil or omitted means include the minibuffer window only
2760 if it's active.
2761 MINIBUF neither nil nor t means never include the minibuffer window. */)
2762 (Lisp_Object frame, Lisp_Object minibuf, Lisp_Object window)
2764 if (NILP (window))
2765 window = FRAMEP (frame) ? XFRAME (frame)->selected_window : selected_window;
2766 CHECK_WINDOW (window);
2767 if (NILP (frame))
2768 frame = selected_frame;
2770 if (!EQ (frame, XWINDOW (window)->frame))
2771 error ("Window is on a different frame");
2773 return window_list_1 (window, minibuf, frame);
2777 DEFUN ("window-list-1", Fwindow_list_1, Swindow_list_1, 0, 3, 0,
2778 doc: /* Return a list of all live windows.
2779 WINDOW specifies the first window to list and defaults to the selected
2780 window.
2782 Optional argument MINIBUF nil or omitted means consider the minibuffer
2783 window only if the minibuffer is active. MINIBUF t means consider the
2784 minibuffer window even if the minibuffer is not active. Any other value
2785 means do not consider the minibuffer window even if the minibuffer is
2786 active.
2788 Optional argument ALL-FRAMES nil or omitted means consider all windows
2789 on WINDOW's frame, plus the minibuffer window if specified by the
2790 MINIBUF argument. If the minibuffer counts, consider all windows on all
2791 frames that share that minibuffer too. The following non-nil values of
2792 ALL-FRAMES have special meanings:
2794 - t means consider all windows on all existing frames.
2796 - `visible' means consider all windows on all visible frames.
2798 - 0 (the number zero) means consider all windows on all visible and
2799 iconified frames.
2801 - A frame means consider all windows on that frame only.
2803 Anything else means consider all windows on WINDOW's frame and no
2804 others.
2806 If WINDOW is not on the list of windows returned, some other window will
2807 be listed first but no error is signaled. */)
2808 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
2810 return window_list_1 (window, minibuf, all_frames);
2813 /* Look at all windows, performing an operation specified by TYPE
2814 with argument OBJ.
2815 If FRAMES is Qt, look at all frames;
2816 Qnil, look at just the selected frame;
2817 Qvisible, look at visible frames;
2818 a frame, just look at windows on that frame.
2819 If MINI is non-zero, perform the operation on minibuffer windows too. */
2821 enum window_loop
2823 WINDOW_LOOP_UNUSED,
2824 GET_BUFFER_WINDOW, /* Arg is buffer */
2825 REPLACE_BUFFER_IN_WINDOWS_SAFELY, /* Arg is buffer */
2826 REDISPLAY_BUFFER_WINDOWS, /* Arg is buffer */
2827 CHECK_ALL_WINDOWS /* Arg is ignored */
2830 static Lisp_Object
2831 window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frames)
2833 Lisp_Object window, windows, best_window, frame_arg;
2834 int frame_best_window_flag = 0;
2835 struct frame *f;
2836 struct gcpro gcpro1;
2838 /* If we're only looping through windows on a particular frame,
2839 frame points to that frame. If we're looping through windows
2840 on all frames, frame is 0. */
2841 if (FRAMEP (frames))
2842 f = XFRAME (frames);
2843 else if (NILP (frames))
2844 f = SELECTED_FRAME ();
2845 else
2846 f = NULL;
2848 if (f)
2849 frame_arg = Qlambda;
2850 else if (EQ (frames, make_number (0)))
2851 frame_arg = frames;
2852 else if (EQ (frames, Qvisible))
2853 frame_arg = frames;
2854 else
2855 frame_arg = Qt;
2857 /* frame_arg is Qlambda to stick to one frame,
2858 Qvisible to consider all visible frames,
2859 or Qt otherwise. */
2861 /* Pick a window to start with. */
2862 if (WINDOWP (obj))
2863 window = obj;
2864 else if (f)
2865 window = FRAME_SELECTED_WINDOW (f);
2866 else
2867 window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2869 windows = window_list_1 (window, mini ? Qt : Qnil, frame_arg);
2870 GCPRO1 (windows);
2871 best_window = Qnil;
2873 for (; CONSP (windows); windows = XCDR (windows))
2875 struct window *w;
2877 window = XCAR (windows);
2878 w = XWINDOW (window);
2880 /* Note that we do not pay attention here to whether the frame
2881 is visible, since Fwindow_list skips non-visible frames if
2882 that is desired, under the control of frame_arg. */
2883 if (!MINI_WINDOW_P (w)
2884 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2885 consider all windows. */
2886 || type == REPLACE_BUFFER_IN_WINDOWS_SAFELY
2887 || (mini && minibuf_level > 0))
2888 switch (type)
2890 case GET_BUFFER_WINDOW:
2891 if (EQ (w->contents, obj)
2892 /* Don't find any minibuffer window except the one that
2893 is currently in use. */
2894 && (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))
2896 if (EQ (window, selected_window))
2897 /* Preferably return the selected window. */
2898 RETURN_UNGCPRO (window);
2899 else if (EQ (XWINDOW (window)->frame, selected_frame)
2900 && !frame_best_window_flag)
2901 /* Prefer windows on the current frame (but don't
2902 choose another one if we have one already). */
2904 best_window = window;
2905 frame_best_window_flag = 1;
2907 else if (NILP (best_window))
2908 best_window = window;
2910 break;
2912 case REPLACE_BUFFER_IN_WINDOWS_SAFELY:
2913 /* We could simply check whether the buffer shown by window
2914 is live, and show another buffer in case it isn't. */
2915 if (EQ (w->contents, obj))
2917 /* Undedicate WINDOW. */
2918 wset_dedicated (w, Qnil);
2919 /* Make WINDOW show the buffer returned by
2920 other_buffer_safely, don't run any hooks. */
2921 set_window_buffer
2922 (window, other_buffer_safely (w->contents), 0, 0);
2923 /* If WINDOW is the selected window, make its buffer
2924 current. But do so only if the window shows the
2925 current buffer (Bug#6454). */
2926 if (EQ (window, selected_window)
2927 && XBUFFER (w->contents) == current_buffer)
2928 Fset_buffer (w->contents);
2930 break;
2932 case REDISPLAY_BUFFER_WINDOWS:
2933 if (EQ (w->contents, obj))
2935 mark_window_display_accurate (window, 0);
2936 w->update_mode_line = 1;
2937 XBUFFER (obj)->prevent_redisplay_optimizations_p = 1;
2938 update_mode_lines = 27;
2939 best_window = window;
2941 break;
2943 /* Check for a leaf window that has a killed buffer
2944 or broken markers. */
2945 case CHECK_ALL_WINDOWS:
2946 if (BUFFERP (w->contents))
2948 struct buffer *b = XBUFFER (w->contents);
2950 if (!BUFFER_LIVE_P (b))
2951 emacs_abort ();
2952 if (!MARKERP (w->start) || XMARKER (w->start)->buffer != b)
2953 emacs_abort ();
2954 if (!MARKERP (w->pointm) || XMARKER (w->pointm)->buffer != b)
2955 emacs_abort ();
2957 break;
2959 case WINDOW_LOOP_UNUSED:
2960 break;
2964 UNGCPRO;
2965 return best_window;
2968 /* Used for debugging. Abort if any window has a dead buffer. */
2970 extern void check_all_windows (void) EXTERNALLY_VISIBLE;
2971 void
2972 check_all_windows (void)
2974 window_loop (CHECK_ALL_WINDOWS, Qnil, 1, Qt);
2977 DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 0, 2, 0,
2978 doc: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2979 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2980 the current buffer.
2982 The optional argument ALL-FRAMES specifies the frames to consider:
2984 - t means consider all windows on all existing frames.
2986 - `visible' means consider all windows on all visible frames.
2988 - 0 (the number zero) means consider all windows on all visible
2989 and iconified frames.
2991 - A frame means consider all windows on that frame only.
2993 Any other value of ALL-FRAMES means consider all windows on the
2994 selected frame and no others. */)
2995 (Lisp_Object buffer_or_name, Lisp_Object all_frames)
2997 Lisp_Object buffer;
2999 if (NILP (buffer_or_name))
3000 buffer = Fcurrent_buffer ();
3001 else
3002 buffer = Fget_buffer (buffer_or_name);
3004 if (BUFFERP (buffer))
3005 return window_loop (GET_BUFFER_WINDOW, buffer, 1, all_frames);
3006 else
3007 return Qnil;
3011 static Lisp_Object
3012 resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizontal, Lisp_Object ignore, Lisp_Object pixelwise)
3014 return call5 (Qwindow_resize_root_window, window, delta, horizontal, ignore, pixelwise);
3018 Lisp_Object
3019 sanitize_window_sizes (Lisp_Object frame, Lisp_Object horizontal)
3021 return call2 (Qwindow_sanitize_window_sizes, frame, horizontal);
3025 static Lisp_Object
3026 window_pixel_to_total (Lisp_Object frame, Lisp_Object horizontal)
3028 return call2 (Qwindow_pixel_to_total, frame, horizontal);
3032 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal,
3033 Sdelete_other_windows_internal, 0, 2, "",
3034 doc: /* Make WINDOW fill its frame.
3035 Only the frame WINDOW is on is affected. WINDOW must be a valid window
3036 and defaults to the selected one.
3038 Optional argument ROOT, if non-nil, must specify an internal window such
3039 that WINDOW is in its window subtree. If this is the case, replace ROOT
3040 by WINDOW and leave alone any windows not part of ROOT's subtree.
3042 When WINDOW is live try to reduce display jumps by keeping the text
3043 previously visible in WINDOW in the same place on the frame. Doing this
3044 depends on the value of (window-start WINDOW), so if calling this
3045 function in a program gives strange scrolling, make sure the
3046 window-start value is reasonable when this function is called. */)
3047 (Lisp_Object window, Lisp_Object root)
3049 struct window *w, *r, *s;
3050 struct frame *f;
3051 Lisp_Object sibling, pwindow, swindow IF_LINT (= Qnil), delta;
3052 ptrdiff_t startpos IF_LINT (= 0), startbyte IF_LINT (= 0);
3053 int top IF_LINT (= 0), new_top, resize_failed;
3055 w = decode_valid_window (window);
3056 XSETWINDOW (window, w);
3057 f = XFRAME (w->frame);
3059 if (NILP (root))
3060 /* ROOT is the frame's root window. */
3062 root = FRAME_ROOT_WINDOW (f);
3063 r = XWINDOW (root);
3065 else
3066 /* ROOT must be an ancestor of WINDOW. */
3068 r = decode_valid_window (root);
3069 pwindow = XWINDOW (window)->parent;
3070 while (!NILP (pwindow))
3071 if (EQ (pwindow, root))
3072 break;
3073 else
3074 pwindow = XWINDOW (pwindow)->parent;
3075 if (!EQ (pwindow, root))
3076 error ("Specified root is not an ancestor of specified window");
3079 if (EQ (window, root))
3080 /* A noop. */
3081 return Qnil;
3082 /* I don't understand the "top > 0" part below. If we deal with a
3083 standalone minibuffer it would have been caught by the preceding
3084 test. */
3085 else if (MINI_WINDOW_P (w)) /* && top > 0) */
3086 error ("Can't expand minibuffer to full frame");
3088 if (BUFFERP (w->contents))
3090 startpos = marker_position (w->start);
3091 startbyte = marker_byte_position (w->start);
3092 top = (WINDOW_TOP_EDGE_LINE (w)
3093 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w))));
3094 /* Make sure WINDOW is the frame's selected window. */
3095 if (!EQ (window, FRAME_SELECTED_WINDOW (f)))
3097 if (EQ (selected_frame, w->frame))
3098 Fselect_window (window, Qnil);
3099 else
3100 fset_selected_window (f, window);
3103 else
3105 /* See if the frame's selected window is a part of the window
3106 subtree rooted at WINDOW, by finding all the selected window's
3107 parents and comparing each one with WINDOW. If it isn't we
3108 need a new selected window for this frame. */
3109 swindow = FRAME_SELECTED_WINDOW (f);
3110 while (1)
3112 pwindow = swindow;
3113 while (!NILP (pwindow) && !EQ (window, pwindow))
3114 pwindow = XWINDOW (pwindow)->parent;
3116 if (EQ (window, pwindow))
3117 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
3118 as the new selected window. */
3119 break;
3120 else
3121 /* Else try the previous window of SWINDOW. */
3122 swindow = Fprevious_window (swindow, Qlambda, Qnil);
3125 if (!EQ (swindow, FRAME_SELECTED_WINDOW (f)))
3127 if (EQ (selected_frame, w->frame))
3128 Fselect_window (swindow, Qnil);
3129 else
3130 fset_selected_window (f, swindow);
3134 block_input ();
3135 if (!FRAME_INITIAL_P (f))
3137 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
3139 /* We are going to free the glyph matrices of WINDOW, and with
3140 that we might lose any information about glyph rows that have
3141 some of their glyphs highlighted in mouse face. (These rows
3142 are marked with a non-zero mouse_face_p flag.) If WINDOW
3143 indeed has some glyphs highlighted in mouse face, signal to
3144 frame's up-to-date hook that mouse highlight was overwritten,
3145 so that it will arrange for redisplaying the highlight. */
3146 if (EQ (hlinfo->mouse_face_window, window))
3147 reset_mouse_highlight (hlinfo);
3149 free_window_matrices (r);
3151 fset_redisplay (f);
3152 Vwindow_list = Qnil;
3153 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
3154 resize_failed = 0;
3156 if (!WINDOW_LEAF_P (w))
3158 /* Resize child windows vertically. */
3159 XSETINT (delta, r->pixel_height - w->pixel_height);
3160 w->pixel_top = r->pixel_top;
3161 w->top_line = r->top_line;
3162 resize_root_window (window, delta, Qnil, Qnil, Qt);
3163 if (window_resize_check (w, 0))
3165 window_resize_apply (w, 0);
3166 window_pixel_to_total (w->frame, Qnil);
3168 else
3170 resize_root_window (window, delta, Qnil, Qt, Qt);
3171 if (window_resize_check (w, 0))
3173 window_resize_apply (w, 0);
3174 window_pixel_to_total (w->frame, Qnil);
3176 else
3177 resize_failed = 1;
3180 /* Resize child windows horizontally. */
3181 if (!resize_failed)
3183 w->left_col = r->left_col;
3184 w->pixel_left = r->pixel_left;
3185 XSETINT (delta, r->pixel_width - w->pixel_width);
3186 resize_root_window (window, delta, Qt, Qnil, Qt);
3187 if (window_resize_check (w, 1))
3189 window_resize_apply (w, 1);
3190 window_pixel_to_total (w->frame, Qt);
3192 else
3194 resize_root_window (window, delta, Qt, Qt, Qt);
3195 if (window_resize_check (w, 1))
3197 window_resize_apply (w, 1);
3198 window_pixel_to_total (w->frame, Qt);
3200 else
3201 resize_failed = 1;
3205 if (resize_failed)
3206 /* Play safe, if we still can ... */
3208 window = swindow;
3209 w = XWINDOW (window);
3213 /* Cleanly unlink WINDOW from window-tree. */
3214 if (!NILP (w->prev))
3215 /* Get SIBLING above (on the left of) WINDOW. */
3217 sibling = w->prev;
3218 s = XWINDOW (sibling);
3219 wset_next (s, w->next);
3220 if (!NILP (s->next))
3221 wset_prev (XWINDOW (s->next), sibling);
3223 else
3224 /* Get SIBLING below (on the right of) WINDOW. */
3226 sibling = w->next;
3227 s = XWINDOW (sibling);
3228 wset_prev (s, Qnil);
3229 wset_combination (XWINDOW (w->parent),
3230 XWINDOW (w->parent)->horizontal, sibling);
3233 /* Delete ROOT and all child windows of ROOT. */
3234 if (WINDOWP (r->contents))
3236 delete_all_child_windows (r->contents);
3237 wset_combination (r, 0, Qnil);
3240 replace_window (root, window, 1);
3242 /* This must become SWINDOW anyway ....... */
3243 if (BUFFERP (w->contents) && !resize_failed)
3245 /* Try to minimize scrolling, by setting the window start to the
3246 point will cause the text at the old window start to be at the
3247 same place on the frame. But don't try to do this if the
3248 window start is outside the visible portion (as might happen
3249 when the display is not current, due to typeahead). */
3250 new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
3251 if (new_top != top
3252 && startpos >= BUF_BEGV (XBUFFER (w->contents))
3253 && startpos <= BUF_ZV (XBUFFER (w->contents)))
3255 struct position pos;
3256 struct buffer *obuf = current_buffer;
3258 Fset_buffer (w->contents);
3259 /* This computation used to temporarily move point, but that
3260 can have unwanted side effects due to text properties. */
3261 pos = *vmotion (startpos, startbyte, -top, w);
3263 set_marker_both (w->start, w->contents, pos.bufpos, pos.bytepos);
3264 w->window_end_valid = 0;
3265 w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
3266 || FETCH_BYTE (pos.bytepos - 1) == '\n');
3267 /* We need to do this, so that the window-scroll-functions
3268 get called. */
3269 w->optional_new_start = 1;
3271 set_buffer_internal (obuf);
3275 adjust_frame_glyphs (f);
3276 unblock_input ();
3278 run_window_configuration_change_hook (f);
3280 return Qnil;
3284 void
3285 replace_buffer_in_windows (Lisp_Object buffer)
3287 call1 (Qreplace_buffer_in_windows, buffer);
3290 /* If BUFFER is shown in a window, safely replace it with some other
3291 buffer in all windows of all frames, even those on other keyboards. */
3293 void
3294 replace_buffer_in_windows_safely (Lisp_Object buffer)
3296 if (buffer_window_count (XBUFFER (buffer)))
3298 Lisp_Object tail, frame;
3300 /* A single call to window_loop won't do the job because it only
3301 considers frames on the current keyboard. So loop manually over
3302 frames, and handle each one. */
3303 FOR_EACH_FRAME (tail, frame)
3304 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
3308 /* The following three routines are needed for running a window's
3309 configuration change hook. */
3310 static void
3311 run_funs (Lisp_Object funs)
3313 for (; CONSP (funs); funs = XCDR (funs))
3314 if (!EQ (XCAR (funs), Qt))
3315 call0 (XCAR (funs));
3318 static void
3319 select_window_norecord (Lisp_Object window)
3321 if (WINDOW_LIVE_P (window))
3322 Fselect_window (window, Qt);
3325 static void
3326 select_frame_norecord (Lisp_Object frame)
3328 if (FRAME_LIVE_P (XFRAME (frame)))
3329 Fselect_frame (frame, Qt);
3332 void
3333 run_window_configuration_change_hook (struct frame *f)
3335 ptrdiff_t count = SPECPDL_INDEX ();
3336 Lisp_Object frame, global_wcch
3337 = Fdefault_value (Qwindow_configuration_change_hook);
3338 XSETFRAME (frame, f);
3340 if (NILP (Vrun_hooks) || !(f->official))
3341 return;
3343 /* Use the right buffer. Matters when running the local hooks. */
3344 if (current_buffer != XBUFFER (Fwindow_buffer (Qnil)))
3346 record_unwind_current_buffer ();
3347 Fset_buffer (Fwindow_buffer (Qnil));
3350 if (SELECTED_FRAME () != f)
3352 record_unwind_protect (select_frame_norecord, selected_frame);
3353 select_frame_norecord (frame);
3356 /* Look for buffer-local values. */
3358 Lisp_Object windows = Fwindow_list (frame, Qlambda, Qnil);
3359 for (; CONSP (windows); windows = XCDR (windows))
3361 Lisp_Object window = XCAR (windows);
3362 Lisp_Object buffer = Fwindow_buffer (window);
3363 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook,
3364 buffer)))
3366 ptrdiff_t inner_count = SPECPDL_INDEX ();
3367 record_unwind_protect (select_window_norecord, selected_window);
3368 select_window_norecord (window);
3369 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook,
3370 buffer));
3371 unbind_to (inner_count, Qnil);
3376 run_funs (global_wcch);
3377 unbind_to (count, Qnil);
3380 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook,
3381 Srun_window_configuration_change_hook, 0, 1, 0,
3382 doc: /* Run `window-configuration-change-hook' for FRAME.
3383 If FRAME is omitted or nil, it defaults to the selected frame. */)
3384 (Lisp_Object frame)
3386 run_window_configuration_change_hook (decode_live_frame (frame));
3387 return Qnil;
3390 DEFUN ("run-window-scroll-functions", Frun_window_scroll_functions,
3391 Srun_window_scroll_functions, 0, 1, 0,
3392 doc: /* Run `window-scroll-functions' for WINDOW.
3393 If WINDOW is omitted or nil, it defaults to the selected window. */)
3394 (Lisp_Object window)
3396 if (! NILP (Vwindow_scroll_functions))
3397 run_hook_with_args_2 (Qwindow_scroll_functions, window,
3398 Fmarker_position (decode_live_window (window)->start));
3399 return Qnil;
3402 /* Make WINDOW display BUFFER. RUN_HOOKS_P non-zero means it's allowed
3403 to run hooks. See make_frame for a case where it's not allowed.
3404 KEEP_MARGINS_P non-zero means that the current margins, fringes, and
3405 scroll-bar settings of the window are not reset from the buffer's
3406 local settings. */
3408 void
3409 set_window_buffer (Lisp_Object window, Lisp_Object buffer,
3410 bool run_hooks_p, bool keep_margins_p)
3412 struct window *w = XWINDOW (window);
3413 struct buffer *b = XBUFFER (buffer);
3414 ptrdiff_t count = SPECPDL_INDEX ();
3415 bool samebuf = EQ (buffer, w->contents);
3417 wset_buffer (w, buffer);
3419 if (EQ (window, selected_window))
3420 bset_last_selected_window (b, window);
3422 /* Let redisplay errors through. */
3423 b->display_error_modiff = 0;
3425 /* Update time stamps of buffer display. */
3426 if (INTEGERP (BVAR (b, display_count)))
3427 bset_display_count (b, make_number (XINT (BVAR (b, display_count)) + 1));
3428 bset_display_time (b, Fcurrent_time ());
3430 w->window_end_pos = 0;
3431 w->window_end_vpos = 0;
3432 w->last_cursor_vpos = 0;
3434 if (!(keep_margins_p && samebuf))
3435 { /* If we're not actually changing the buffer, don't reset hscroll
3436 and vscroll. This case happens for example when called from
3437 change_frame_size_1, where we use a dummy call to
3438 Fset_window_buffer on the frame's selected window (and no
3439 other) just in order to run window-configuration-change-hook
3440 (no longer true since change_frame_size_1 directly calls
3441 run_window_configuration_change_hook). Resetting hscroll and
3442 vscroll here is problematic for things like image-mode and
3443 doc-view-mode since it resets the image's position whenever we
3444 resize the frame. */
3445 w->hscroll = w->min_hscroll = w->hscroll_whole = 0;
3446 w->suspend_auto_hscroll = 0;
3447 w->vscroll = 0;
3448 set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
3449 set_marker_both (w->old_pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
3450 set_marker_restricted (w->start,
3451 make_number (b->last_window_start),
3452 buffer);
3453 w->start_at_line_beg = 0;
3454 w->force_start = 0;
3456 /* Maybe we could move this into the `if' but it's not obviously safe and
3457 I doubt it's worth the trouble. */
3458 wset_redisplay (w);
3459 w->update_mode_line = true;
3461 /* We must select BUFFER to run the window-scroll-functions and to look up
3462 the buffer-local value of Vwindow_point_insertion_type. */
3463 record_unwind_current_buffer ();
3464 Fset_buffer (buffer);
3466 XMARKER (w->pointm)->insertion_type = !NILP (Vwindow_point_insertion_type);
3467 XMARKER (w->old_pointm)->insertion_type = !NILP (Vwindow_point_insertion_type);
3469 if (!keep_margins_p)
3471 /* Set left and right marginal area width etc. from buffer. */
3472 set_window_fringes (w, BVAR (b, left_fringe_width),
3473 BVAR (b, right_fringe_width),
3474 BVAR (b, fringes_outside_margins));
3475 set_window_scroll_bars (w, BVAR (b, scroll_bar_width),
3476 BVAR (b, vertical_scroll_bar_type),
3477 BVAR (b, scroll_bar_height),
3478 BVAR (b, horizontal_scroll_bar_type));
3479 set_window_margins (w, BVAR (b, left_margin_cols),
3480 BVAR (b, right_margin_cols));
3481 apply_window_adjustment (w);
3484 if (run_hooks_p)
3486 if (! NILP (Vwindow_scroll_functions))
3487 run_hook_with_args_2 (Qwindow_scroll_functions, window,
3488 Fmarker_position (w->start));
3489 if (!samebuf)
3490 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
3493 unbind_to (count, Qnil);
3496 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
3497 doc: /* Make WINDOW display BUFFER-OR-NAME.
3498 WINDOW must be a live window and defaults to the selected one.
3499 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3501 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3502 display margins, fringe widths, and scroll bar settings are preserved;
3503 the default is to reset these from the local settings for BUFFER-OR-NAME
3504 or the frame defaults. Return nil.
3506 This function throws an error when WINDOW is strongly dedicated to its
3507 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3508 already display BUFFER-OR-NAME.
3510 This function runs `window-scroll-functions' before running
3511 `window-configuration-change-hook'. */)
3512 (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
3514 register Lisp_Object tem, buffer;
3515 register struct window *w = decode_live_window (window);
3517 XSETWINDOW (window, w);
3518 buffer = Fget_buffer (buffer_or_name);
3519 CHECK_BUFFER (buffer);
3520 if (!BUFFER_LIVE_P (XBUFFER (buffer)))
3521 error ("Attempt to display deleted buffer");
3523 tem = w->contents;
3524 if (NILP (tem))
3525 error ("Window is deleted");
3526 else
3528 if (!EQ (tem, buffer))
3530 if (EQ (w->dedicated, Qt))
3531 /* WINDOW is strongly dedicated to its buffer, signal an
3532 error. */
3533 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
3534 else
3535 /* WINDOW is weakly dedicated to its buffer, reset
3536 dedication. */
3537 wset_dedicated (w, Qnil);
3539 call1 (Qrecord_window_buffer, window);
3542 unshow_buffer (w);
3545 set_window_buffer (window, buffer, 1, !NILP (keep_margins));
3547 return Qnil;
3550 static Lisp_Object
3551 display_buffer (Lisp_Object buffer, Lisp_Object not_this_window_p, Lisp_Object override_frame)
3553 return call3 (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
3556 DEFUN ("force-window-update", Fforce_window_update, Sforce_window_update,
3557 0, 1, 0,
3558 doc: /* Force all windows to be updated on next redisplay.
3559 If optional arg OBJECT is a window, force redisplay of that window only.
3560 If OBJECT is a buffer or buffer name, force redisplay of all windows
3561 displaying that buffer. */)
3562 (Lisp_Object object)
3564 if (NILP (object))
3566 windows_or_buffers_changed = 29;
3567 update_mode_lines = 28;
3568 return Qt;
3571 if (WINDOWP (object))
3573 struct window *w = XWINDOW (object);
3574 mark_window_display_accurate (object, 0);
3575 w->update_mode_line = 1;
3576 if (BUFFERP (w->contents))
3577 XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
3578 update_mode_lines = 29;
3579 return Qt;
3582 if (STRINGP (object))
3583 object = Fget_buffer (object);
3584 if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object))
3585 && buffer_window_count (XBUFFER (object)))
3587 /* If buffer is live and shown in at least one window, find
3588 all windows showing this buffer and force update of them. */
3589 object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, 0, Qvisible);
3590 return NILP (object) ? Qnil : Qt;
3593 /* If nothing suitable was found, just return.
3594 We could signal an error, but this feature will typically be used
3595 asynchronously in timers or process sentinels, so we don't. */
3596 return Qnil;
3599 /* Obsolete since 24.3. */
3600 void
3601 temp_output_buffer_show (register Lisp_Object buf)
3603 register struct buffer *old = current_buffer;
3604 register Lisp_Object window;
3605 register struct window *w;
3607 bset_directory (XBUFFER (buf), BVAR (current_buffer, directory));
3609 Fset_buffer (buf);
3610 BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
3611 BEGV = BEG;
3612 ZV = Z;
3613 SET_PT (BEG);
3614 set_buffer_internal (old);
3616 if (!NILP (Vtemp_buffer_show_function))
3617 call1 (Vtemp_buffer_show_function, buf);
3618 else if (WINDOW_LIVE_P (window = display_buffer (buf, Qnil, Qnil)))
3620 if (!EQ (XWINDOW (window)->frame, selected_frame))
3621 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
3622 Vminibuf_scroll_window = window;
3623 w = XWINDOW (window);
3624 w->hscroll = w->min_hscroll = w->hscroll_whole = 0;
3625 w->suspend_auto_hscroll = 0;
3626 set_marker_restricted_both (w->start, buf, BEG, BEG);
3627 set_marker_restricted_both (w->pointm, buf, BEG, BEG);
3628 set_marker_restricted_both (w->old_pointm, buf, BEG, BEG);
3630 /* Run temp-buffer-show-hook, with the chosen window selected
3631 and its buffer current. */
3633 ptrdiff_t count = SPECPDL_INDEX ();
3634 Lisp_Object prev_window, prev_buffer;
3635 prev_window = selected_window;
3636 XSETBUFFER (prev_buffer, old);
3638 /* Select the window that was chosen, for running the hook.
3639 Note: Both Fselect_window and select_window_norecord may
3640 set-buffer to the buffer displayed in the window,
3641 so we need to save the current buffer. --stef */
3642 record_unwind_protect (restore_buffer, prev_buffer);
3643 record_unwind_protect (select_window_norecord, prev_window);
3644 Fselect_window (window, Qt);
3645 Fset_buffer (w->contents);
3646 Frun_hooks (1, &Qtemp_buffer_show_hook);
3647 unbind_to (count, Qnil);
3652 /* Make new window, have it replace WINDOW in window-tree, and make
3653 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3654 horizontal child). */
3655 static void
3656 make_parent_window (Lisp_Object window, bool horflag)
3658 Lisp_Object parent;
3659 register struct window *o, *p;
3661 o = XWINDOW (window);
3662 p = allocate_window ();
3663 memcpy ((char *) p + sizeof (struct vectorlike_header),
3664 (char *) o + sizeof (struct vectorlike_header),
3665 word_size * VECSIZE (struct window));
3666 /* P's buffer slot may change from nil to a buffer... */
3667 adjust_window_count (p, 1);
3668 XSETWINDOW (parent, p);
3670 p->sequence_number = ++sequence_number;
3672 replace_window (window, parent, 1);
3674 wset_next (o, Qnil);
3675 wset_prev (o, Qnil);
3676 wset_parent (o, parent);
3677 /* ...but now P becomes an internal window. */
3678 wset_start (p, Qnil);
3679 wset_pointm (p, Qnil);
3680 wset_old_pointm (p, Qnil);
3681 wset_buffer (p, Qnil);
3682 wset_combination (p, horflag, window);
3683 wset_combination_limit (p, Qnil);
3684 wset_window_parameters (p, Qnil);
3687 /* Make new window from scratch. */
3688 Lisp_Object
3689 make_window (void)
3691 Lisp_Object window;
3692 register struct window *w;
3694 w = allocate_window ();
3695 /* Initialize Lisp data. Note that allocate_window initializes all
3696 Lisp data to nil, so do it only for slots which should not be nil. */
3697 wset_normal_lines (w, make_float (1.0));
3698 wset_normal_cols (w, make_float (1.0));
3699 wset_new_total (w, make_number (0));
3700 wset_new_normal (w, make_number (0));
3701 wset_new_pixel (w, make_number (0));
3702 wset_start (w, Fmake_marker ());
3703 wset_pointm (w, Fmake_marker ());
3704 wset_old_pointm (w, Fmake_marker ());
3705 wset_vertical_scroll_bar_type (w, Qt);
3706 wset_horizontal_scroll_bar_type (w, Qt);
3707 /* These Lisp fields are marked specially so they're not set to nil by
3708 allocate_window. */
3709 wset_prev_buffers (w, Qnil);
3710 wset_next_buffers (w, Qnil);
3712 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3713 non-Lisp data, so do it only for slots which should not be zero. */
3714 w->nrows_scale_factor = w->ncols_scale_factor = 1;
3715 w->left_fringe_width = w->right_fringe_width = -1;
3716 w->mode_line_height = w->header_line_height = -1;
3717 #ifdef HAVE_WINDOW_SYSTEM
3718 w->phys_cursor_type = NO_CURSOR;
3719 w->phys_cursor_width = -1;
3720 #endif
3721 w->sequence_number = ++sequence_number;
3722 w->scroll_bar_width = -1;
3723 w->scroll_bar_height = -1;
3724 w->column_number_displayed = -1;
3725 /* Reset window_list. */
3726 Vwindow_list = Qnil;
3727 /* Return window. */
3728 XSETWINDOW (window, w);
3729 return window;
3732 DEFUN ("set-window-new-pixel", Fset_window_new_pixel, Sset_window_new_pixel, 2, 3, 0,
3733 doc: /* Set new pixel size of WINDOW to SIZE.
3734 WINDOW must be a valid window and defaults to the selected one.
3735 Return SIZE.
3737 Optional argument ADD non-nil means add SIZE to the new pixel size of
3738 WINDOW and return the sum.
3740 The new pixel size of WINDOW, if valid, will be shortly installed as
3741 WINDOW's pixel height (see `window-pixel-height') or pixel width (see
3742 `window-pixel-width').
3744 Note: This function does not operate on any child windows of WINDOW. */)
3745 (Lisp_Object window, Lisp_Object size, Lisp_Object add)
3747 struct window *w = decode_valid_window (window);
3748 EMACS_INT size_min = NILP (add) ? 0 : - XINT (w->new_pixel);
3749 EMACS_INT size_max = size_min + min (INT_MAX, MOST_POSITIVE_FIXNUM);
3751 CHECK_RANGED_INTEGER (size, size_min, size_max);
3752 if (NILP (add))
3753 wset_new_pixel (w, size);
3754 else
3755 wset_new_pixel (w, make_number (XINT (w->new_pixel) + XINT (size)));
3757 return w->new_pixel;
3760 DEFUN ("set-window-new-total", Fset_window_new_total, Sset_window_new_total, 2, 3, 0,
3761 doc: /* Set new total size of WINDOW to SIZE.
3762 WINDOW must be a valid window and defaults to the selected one.
3763 Return SIZE.
3765 Optional argument ADD non-nil means add SIZE to the new total size of
3766 WINDOW and return the sum.
3768 The new total size of WINDOW, if valid, will be shortly installed as
3769 WINDOW's total height (see `window-total-height') or total width (see
3770 `window-total-width').
3772 Note: This function does not operate on any child windows of WINDOW. */)
3773 (Lisp_Object window, Lisp_Object size, Lisp_Object add)
3775 struct window *w = decode_valid_window (window);
3777 CHECK_NUMBER (size);
3778 if (NILP (add))
3779 wset_new_total (w, size);
3780 else
3781 wset_new_total (w, make_number (XINT (w->new_total) + XINT (size)));
3783 return w->new_total;
3786 DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal, 1, 2, 0,
3787 doc: /* Set new normal size of WINDOW to SIZE.
3788 WINDOW must be a valid window and defaults to the selected one.
3789 Return SIZE.
3791 The new normal size of WINDOW, if valid, will be shortly installed as
3792 WINDOW's normal size (see `window-normal-size').
3794 Note: This function does not operate on any child windows of WINDOW. */)
3795 (Lisp_Object window, Lisp_Object size)
3797 wset_new_normal (decode_valid_window (window), size);
3798 return size;
3801 /* Return 1 if setting w->pixel_height (w->pixel_width if HORFLAG is
3802 non-zero) to w->new_pixel would result in correct heights (widths)
3803 for window W and recursively all child windows of W.
3805 Note: This function does not check any of `window-fixed-size-p',
3806 `window-min-height' or `window-min-width'. It does check that window
3807 sizes do not drop below one line (two columns). */
3808 static int
3809 window_resize_check (struct window *w, bool horflag)
3811 struct frame *f = XFRAME (w->frame);
3812 struct window *c;
3814 if (WINDOW_VERTICAL_COMBINATION_P (w))
3815 /* W is a vertical combination. */
3817 c = XWINDOW (w->contents);
3818 if (horflag)
3819 /* All child windows of W must have the same width as W. */
3821 while (c)
3823 if (XINT (c->new_pixel) != XINT (w->new_pixel)
3824 || !window_resize_check (c, horflag))
3825 return 0;
3827 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3830 return 1;
3832 else
3833 /* The sum of the heights of the child windows of W must equal
3834 W's height. */
3836 int remaining_pixels = XINT (w->new_pixel);
3838 while (c)
3840 if (!window_resize_check (c, horflag))
3841 return 0;
3843 remaining_pixels -= XINT (c->new_pixel);
3844 if (remaining_pixels < 0)
3845 return 0;
3846 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3849 return remaining_pixels == 0;
3852 else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
3853 /* W is a horizontal combination. */
3855 c = XWINDOW (w->contents);
3856 if (horflag)
3857 /* The sum of the widths of the child windows of W must equal W's
3858 width. */
3860 int remaining_pixels = XINT (w->new_pixel);
3862 while (c)
3864 if (!window_resize_check (c, horflag))
3865 return 0;
3867 remaining_pixels -= XINT (c->new_pixel);
3868 if (remaining_pixels < 0)
3869 return 0;
3870 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3873 return remaining_pixels == 0;
3875 else
3876 /* All child windows of W must have the same height as W. */
3878 while (c)
3880 if (XINT (c->new_pixel) != XINT (w->new_pixel)
3881 || !window_resize_check (c, horflag))
3882 return 0;
3884 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3887 return 1;
3890 else
3891 /* A leaf window. Make sure it's not too small. The following
3892 hardcodes the values of `window-safe-min-width' (2) and
3893 `window-safe-min-height' (1) which are defined in window.el. */
3894 return (XINT (w->new_pixel) >= (horflag
3895 ? (2 * FRAME_COLUMN_WIDTH (f))
3896 : FRAME_LINE_HEIGHT (f)));
3900 /* Set w->pixel_height (w->pixel_width if HORFLAG is non-zero) to
3901 w->new_pixel for window W and recursively all child windows of W.
3902 Also calculate and assign the new vertical (horizontal) pixel start
3903 positions of each of these windows.
3905 This function does not perform any error checks. Make sure you have
3906 run window_resize_check on W before applying this function. */
3907 static void
3908 window_resize_apply (struct window *w, bool horflag)
3910 struct window *c;
3911 int edge;
3912 int unit = (horflag
3913 ? FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w))
3914 : FRAME_LINE_HEIGHT (WINDOW_XFRAME (w)));
3916 /* Note: Assigning new_normal requires that the new total size of the
3917 parent window has been set *before*. */
3918 if (horflag)
3920 w->pixel_width = XFASTINT (w->new_pixel);
3921 w->total_cols = w->pixel_width / unit;
3922 if (NUMBERP (w->new_normal))
3923 wset_normal_cols (w, w->new_normal);
3925 edge = w->pixel_left;
3927 else
3929 w->pixel_height = XFASTINT (w->new_pixel);
3930 w->total_lines = w->pixel_height / unit;
3931 if (NUMBERP (w->new_normal))
3932 wset_normal_lines (w, w->new_normal);
3934 edge = w->pixel_top;
3937 if (WINDOW_VERTICAL_COMBINATION_P (w))
3938 /* W is a vertical combination. */
3940 c = XWINDOW (w->contents);
3941 while (c)
3943 if (horflag)
3945 c->pixel_left = edge;
3946 c->left_col = edge / unit;
3948 else
3950 c->pixel_top = edge;
3951 c->top_line = edge / unit;
3953 window_resize_apply (c, horflag);
3954 if (!horflag)
3955 edge = edge + c->pixel_height;
3957 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3960 else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
3961 /* W is a horizontal combination. */
3963 c = XWINDOW (w->contents);
3964 while (c)
3966 if (horflag)
3968 c->pixel_left = edge;
3969 c->left_col = edge / unit;
3971 else
3973 c->pixel_top = edge;
3974 c->top_line = edge / unit;
3977 window_resize_apply (c, horflag);
3978 if (horflag)
3979 edge = edge + c->pixel_width;
3981 c = NILP (c->next) ? 0 : XWINDOW (c->next);
3984 else
3985 /* Bug#15957. */
3986 w->window_end_valid = 0;
3990 /* Set w->total_lines (w->total_cols if HORFLAG is non-zero) to
3991 w->new_total for window W and recursively all child windows of W.
3992 Also calculate and assign the new vertical (horizontal) start
3993 positions of each of these windows. */
3994 static void
3995 window_resize_apply_total (struct window *w, bool horflag)
3997 struct window *c;
3998 int edge;
4000 /* Note: Assigning new_normal requires that the new total size of the
4001 parent window has been set *before*. */
4002 if (horflag)
4004 w->total_cols = XFASTINT (w->new_total);
4005 edge = w->left_col;
4007 else
4009 w->total_lines = XFASTINT (w->new_total);
4010 edge = w->top_line;
4013 if (WINDOW_VERTICAL_COMBINATION_P (w))
4014 /* W is a vertical combination. */
4016 c = XWINDOW (w->contents);
4017 while (c)
4019 if (horflag)
4020 c->left_col = edge;
4021 else
4022 c->top_line = edge;
4024 window_resize_apply_total (c, horflag);
4025 if (!horflag)
4026 edge = edge + c->total_lines;
4028 c = NILP (c->next) ? 0 : XWINDOW (c->next);
4031 else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
4032 /* W is a horizontal combination. */
4034 c = XWINDOW (w->contents);
4035 while (c)
4037 if (horflag)
4038 c->left_col = edge;
4039 else
4040 c->top_line = edge;
4042 window_resize_apply_total (c, horflag);
4043 if (horflag)
4044 edge = edge + c->total_cols;
4046 c = NILP (c->next) ? 0 : XWINDOW (c->next);
4051 DEFUN ("window-resize-apply", Fwindow_resize_apply, Swindow_resize_apply, 0, 2, 0,
4052 doc: /* Apply requested size values for window-tree of FRAME.
4053 If FRAME is omitted or nil, it defaults to the selected frame.
4055 Optional argument HORIZONTAL omitted or nil means apply requested
4056 height values. HORIZONTAL non-nil means apply requested width values.
4058 The requested size values are those set by `set-window-new-pixel' and
4059 `set-window-new-normal'. This function checks whether the requested
4060 values sum up to a valid window layout, recursively assigns the new
4061 sizes of all child windows and calculates and assigns the new start
4062 positions of these windows.
4064 Return t if the requested values have been applied correctly, nil
4065 otherwise.
4067 Note: This function does not check any of `window-fixed-size-p',
4068 `window-min-height' or `window-min-width'. All these checks have to
4069 be applied on the Elisp level. */)
4070 (Lisp_Object frame, Lisp_Object horizontal)
4072 struct frame *f = decode_live_frame (frame);
4073 struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
4074 bool horflag = !NILP (horizontal);
4076 if (!window_resize_check (r, horflag)
4077 || (XINT (r->new_pixel)
4078 != (horflag ? r->pixel_width : r->pixel_height)))
4079 return Qnil;
4081 block_input ();
4082 window_resize_apply (r, horflag);
4084 fset_redisplay (f);
4085 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
4087 adjust_frame_glyphs (f);
4088 unblock_input ();
4090 return Qt;
4094 DEFUN ("window-resize-apply-total", Fwindow_resize_apply_total, Swindow_resize_apply_total, 0, 2, 0,
4095 doc: /* Apply requested total size values for window-tree of FRAME.
4096 If FRAME is omitted or nil, it defaults to the selected frame.
4098 This function does not assign pixel or normal size values. You should
4099 have run `window-resize-apply' before running this.
4101 Optional argument HORIZONTAL omitted or nil means apply requested
4102 height values. HORIZONTAL non-nil means apply requested width
4103 values. */)
4104 (Lisp_Object frame, Lisp_Object horizontal)
4106 struct frame *f = decode_live_frame (frame);
4107 struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
4109 block_input ();
4110 /* Necessary when deleting the top-/or leftmost window. */
4111 r->left_col = 0;
4112 r->top_line = FRAME_TOP_MARGIN (f);
4113 window_resize_apply_total (r, !NILP (horizontal));
4114 /* Handle the mini window. */
4115 if (FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
4117 struct window *m = XWINDOW (f->minibuffer_window);
4119 if (NILP (horizontal))
4121 m->top_line = r->top_line + r->total_lines;
4122 m->total_lines = XFASTINT (m->new_total);
4124 else
4125 m->total_cols = XFASTINT (m->new_total);
4128 unblock_input ();
4130 return Qt;
4134 /* Resize frame F's windows when number of lines of F is set to SIZE.
4135 HORFLAG 1 means resize windows when number of columns of F is set to
4136 SIZE. PIXELWISE 1 means to interpret SIZE as pixels.
4138 This function can delete all windows but the selected one in order to
4139 satisfy the request. The result will be meaningful if and only if
4140 F's windows have meaningful sizes when you call this. */
4141 void
4142 resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
4144 Lisp_Object root = f->root_window;
4145 struct window *r = XWINDOW (root);
4146 Lisp_Object mini = f->minibuffer_window;
4147 struct window *m;
4148 /* old_size is the old size of the frame's root window. */
4149 int old_size = horflag ? r->total_cols : r->total_lines;
4150 int old_pixel_size = horflag ? r->pixel_width : r->pixel_height;
4151 int old_pixel_top = r->pixel_top;
4152 /* new_size is the new size of the frame's root window. */
4153 int new_size, new_pixel_size;
4154 int unit = horflag ? FRAME_COLUMN_WIDTH (f) : FRAME_LINE_HEIGHT (f);
4156 /* Don't let the size drop below one unit. This is more comforting
4157 when we are called from x_set_tool_bar_lines since the latter may
4158 have implicitly given us a zero or negative height. */
4159 if (pixelwise)
4161 /* Note: This does not include the size for internal borders
4162 since these are not part of the frame's text area. */
4163 new_pixel_size = max (horflag
4164 ? size
4165 : (size
4166 - ((FRAME_HAS_MINIBUF_P (f)
4167 && !FRAME_MINIBUF_ONLY_P (f))
4168 ? FRAME_LINE_HEIGHT (f) : 0)),
4169 unit);
4170 new_size = new_pixel_size / unit;
4172 else
4174 new_size = max (horflag
4175 ? size
4176 : (size
4177 - ((FRAME_HAS_MINIBUF_P (f)
4178 && !FRAME_MINIBUF_ONLY_P (f))
4179 ? 1 : 0)),
4181 new_pixel_size = new_size * unit;
4184 r->top_line = FRAME_TOP_MARGIN (f);
4185 r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
4187 if (new_pixel_size == old_pixel_size
4188 && r->pixel_top == old_pixel_top)
4190 else if (WINDOW_LEAF_P (r))
4191 /* For a leaf root window just set the size. */
4192 if (horflag)
4194 r->total_cols = new_size;
4195 r->pixel_width = new_pixel_size;
4197 else
4199 r->total_lines = new_size;
4200 r->pixel_height = new_pixel_size;
4202 else
4204 Lisp_Object delta;
4206 if (pixelwise)
4207 XSETINT (delta, new_pixel_size - old_pixel_size);
4208 else
4209 XSETINT (delta, new_size - old_size);
4211 /* Try a "normal" resize first. */
4212 resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil,
4213 pixelwise ? Qt : Qnil);
4214 if (window_resize_check (r, horflag)
4215 && new_pixel_size == XINT (r->new_pixel))
4217 window_resize_apply (r, horflag);
4218 window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
4220 else
4222 /* Try with "reasonable" minimum sizes next. */
4223 resize_root_window (root, delta, horflag ? Qt : Qnil, Qt,
4224 pixelwise ? Qt : Qnil);
4225 if (window_resize_check (r, horflag)
4226 && new_pixel_size == XINT (r->new_pixel))
4228 window_resize_apply (r, horflag);
4229 window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
4230 #if 0 /* Let's try without safe sizes and/or killing other windows. */
4232 else
4234 /* Finally, try with "safe" minimum sizes. */
4235 resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe,
4236 pixelwise ? Qt : Qnil);
4237 if (window_resize_check (r, horflag)
4238 && new_pixel_size == XINT (r->new_pixel))
4240 window_resize_apply (r, horflag);
4241 window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
4243 else
4245 /* We lost. Delete all windows but the frame's
4246 selected one. */
4247 root = f->selected_window;
4248 Fdelete_other_windows_internal (root, Qnil);
4249 if (horflag)
4251 XWINDOW (root)->total_cols = new_size;
4252 XWINDOW (root)->pixel_width = new_pixel_size;
4254 else
4256 XWINDOW (root)->total_lines = new_size;
4257 XWINDOW (root)->pixel_height = new_pixel_size;
4260 #endif /* 0 */
4265 if (FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
4267 m = XWINDOW (mini);
4268 if (horflag)
4270 m->total_cols = size;
4271 m->pixel_width = new_pixel_size;
4273 else
4275 /* Are we sure we always want 1 line here? */
4276 m->total_lines = 1;
4277 m->pixel_height = FRAME_LINE_HEIGHT (f);
4278 m->top_line = r->top_line + r->total_lines;
4279 m->pixel_top = r->pixel_top + r->pixel_height;
4283 fset_redisplay (f);
4287 DEFUN ("split-window-internal", Fsplit_window_internal, Ssplit_window_internal, 4, 4, 0,
4288 doc: /* Split window OLD.
4289 Second argument PIXEL-SIZE specifies the number of pixels of the
4290 new window. In any case TOTAL-SIZE must be a positive integer.
4292 Third argument SIDE nil (or `below') specifies that the new window shall
4293 be located below WINDOW. SIDE `above' means the new window shall be
4294 located above WINDOW. In both cases PIXEL-SIZE specifies the pixel
4295 height of the new window including space reserved for the mode and/or
4296 header line.
4298 SIDE t (or `right') specifies that the new window shall be located on
4299 the right side of WINDOW. SIDE `left' means the new window shall be
4300 located on the left of WINDOW. In both cases PIXEL-SIZE specifies the
4301 width of the new window including space reserved for fringes and the
4302 scrollbar or a divider column.
4304 Fourth argument NORMAL-SIZE specifies the normal size of the new window
4305 according to the SIDE argument.
4307 The new pixel and normal sizes of all involved windows must have been
4308 set correctly. See the code of `split-window' for how this is done. */)
4309 (Lisp_Object old, Lisp_Object pixel_size, Lisp_Object side, Lisp_Object normal_size)
4311 /* OLD (*o) is the window we have to split. (*p) is either OLD's
4312 parent window or an internal window we have to install as OLD's new
4313 parent. REFERENCE (*r) must denote a live window, or is set to OLD
4314 provided OLD is a leaf window, or to the frame's selected window.
4315 NEW (*n) is the new window created with some parameters taken from
4316 REFERENCE (*r). */
4317 register Lisp_Object new, frame, reference;
4318 register struct window *o, *p, *n, *r, *c;
4319 struct frame *f;
4320 bool horflag
4321 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
4322 = EQ (side, Qt) || EQ (side, Qleft) || EQ (side, Qright);
4323 int combination_limit = 0, sum = 0;
4324 int total_size;
4326 CHECK_WINDOW (old);
4327 o = XWINDOW (old);
4328 frame = WINDOW_FRAME (o);
4329 f = XFRAME (frame);
4331 CHECK_NUMBER (pixel_size);
4332 total_size
4333 = XINT (pixel_size) / (horflag
4334 ? FRAME_COLUMN_WIDTH (f)
4335 : FRAME_LINE_HEIGHT (f));
4337 /* Set combination_limit to 1 if we have to make a new parent window.
4338 We do that if either `window-combination-limit' is t, or OLD has no
4339 parent, or OLD is ortho-combined. */
4340 combination_limit =
4341 EQ (Vwindow_combination_limit, Qt)
4342 || NILP (o->parent)
4343 || (horflag
4344 ? WINDOW_VERTICAL_COMBINATION_P (XWINDOW (o->parent))
4345 : WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (o->parent)));
4347 /* We need a live reference window to initialize some parameters. */
4348 if (WINDOW_LIVE_P (old))
4349 /* OLD is live, use it as reference window. */
4350 reference = old;
4351 else
4352 /* Use the frame's selected window as reference window. */
4353 reference = FRAME_SELECTED_WINDOW (f);
4354 r = XWINDOW (reference);
4356 /* The following bugs are caught by `split-window'. */
4357 if (MINI_WINDOW_P (o))
4358 error ("Attempt to split minibuffer window");
4359 else if (total_size < (horflag ? 2 : 1))
4360 error ("Size of new window too small (after split)");
4361 else if (!combination_limit && !NILP (Vwindow_combination_resize))
4362 /* `window-combination-resize' non-nil means try to resize OLD's siblings
4363 proportionally. */
4365 p = XWINDOW (o->parent);
4366 /* Temporarily pretend we split the parent window. */
4367 wset_new_pixel
4368 (p, make_number ((horflag ? p->pixel_width : p->pixel_height)
4369 - XINT (pixel_size)));
4370 if (!window_resize_check (p, horflag))
4371 error ("Window sizes don't fit");
4372 else
4373 /* Undo the temporary pretension. */
4374 wset_new_pixel (p, make_number (horflag ? p->pixel_width : p->pixel_height));
4376 else
4378 if (!window_resize_check (o, horflag))
4379 error ("Resizing old window failed");
4380 else if (XINT (pixel_size) + XINT (o->new_pixel)
4381 != (horflag ? o->pixel_width : o->pixel_height))
4382 error ("Sum of sizes of old and new window don't fit");
4385 /* This is our point of no return. */
4386 if (combination_limit)
4388 /* Save the old value of o->normal_cols/lines. It gets corrupted
4389 by make_parent_window and we need it below for assigning it to
4390 p->new_normal. */
4391 Lisp_Object new_normal
4392 = horflag ? o->normal_cols : o->normal_lines;
4394 make_parent_window (old, horflag);
4395 p = XWINDOW (o->parent);
4396 if (EQ (Vwindow_combination_limit, Qt))
4397 /* Store t in the new parent's combination_limit slot to avoid
4398 that its children get merged into another window. */
4399 wset_combination_limit (p, Qt);
4400 /* These get applied below. */
4401 wset_new_pixel
4402 (p, make_number (horflag ? o->pixel_width : o->pixel_height));
4403 wset_new_total
4404 (p, make_number (horflag ? o->total_cols : o->total_lines));
4405 wset_new_normal (p, new_normal);
4407 else
4408 p = XWINDOW (o->parent);
4410 fset_redisplay (f);
4411 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
4412 new = make_window ();
4413 n = XWINDOW (new);
4414 wset_frame (n, frame);
4415 wset_parent (n, o->parent);
4417 if (EQ (side, Qabove) || EQ (side, Qleft))
4419 wset_prev (n, o->prev);
4420 if (NILP (n->prev))
4421 wset_combination (p, horflag, new);
4422 else
4423 wset_next (XWINDOW (n->prev), new);
4424 wset_next (n, old);
4425 wset_prev (o, new);
4427 else
4429 wset_next (n, o->next);
4430 if (!NILP (n->next))
4431 wset_prev (XWINDOW (n->next), new);
4432 wset_prev (n, old);
4433 wset_next (o, new);
4436 n->window_end_valid = 0;
4437 n->last_cursor_vpos = 0;
4439 /* Get special geometry settings from reference window. */
4440 n->left_margin_cols = r->left_margin_cols;
4441 n->right_margin_cols = r->right_margin_cols;
4442 n->left_fringe_width = r->left_fringe_width;
4443 n->right_fringe_width = r->right_fringe_width;
4444 n->fringes_outside_margins = r->fringes_outside_margins;
4445 n->scroll_bar_width = r->scroll_bar_width;
4446 n->scroll_bar_height = r->scroll_bar_height;
4447 wset_vertical_scroll_bar_type (n, r->vertical_scroll_bar_type);
4448 wset_horizontal_scroll_bar_type (n, r->horizontal_scroll_bar_type);
4450 /* Directly assign orthogonal coordinates and sizes. */
4451 if (horflag)
4453 n->pixel_top = o->pixel_top;
4454 n->top_line = o->top_line;
4455 n->pixel_height = o->pixel_height;
4456 n->total_lines = o->total_lines;
4458 else
4460 n->pixel_left = o->pixel_left;
4461 n->left_col = o->left_col;
4462 n->pixel_width = o->pixel_width;
4463 n->total_cols = o->total_cols;
4466 /* Iso-coordinates and sizes are assigned by window_resize_apply,
4467 get them ready here. */
4468 wset_new_pixel (n, pixel_size);
4469 c = XWINDOW (p->contents);
4470 while (c)
4472 if (c != n)
4473 sum = sum + XINT (c->new_total);
4474 c = NILP (c->next) ? 0 : XWINDOW (c->next);
4476 wset_new_total (n, make_number ((horflag
4477 ? p->total_cols
4478 : p->total_lines)
4479 - sum));
4480 wset_new_normal (n, normal_size);
4482 block_input ();
4483 window_resize_apply (p, horflag);
4484 adjust_frame_glyphs (f);
4485 /* Set buffer of NEW to buffer of reference window. Don't run
4486 any hooks. */
4487 set_window_buffer (new, r->contents, 0, 1);
4488 unblock_input ();
4490 /* Maybe we should run the scroll functions in Elisp (which already
4491 runs the configuration change hook). */
4492 if (! NILP (Vwindow_scroll_functions))
4493 run_hook_with_args_2 (Qwindow_scroll_functions, new,
4494 Fmarker_position (n->start));
4495 /* Return NEW. */
4496 return new;
4500 DEFUN ("delete-window-internal", Fdelete_window_internal, Sdelete_window_internal, 1, 1, 0,
4501 doc: /* Remove WINDOW from its frame.
4502 WINDOW defaults to the selected window. Return nil.
4503 Signal an error when WINDOW is the only window on its frame. */)
4504 (register Lisp_Object window)
4506 register Lisp_Object parent, sibling, frame, root;
4507 struct window *w, *p, *s, *r;
4508 struct frame *f;
4509 bool horflag, before_sibling = 0;
4511 w = decode_any_window (window);
4512 XSETWINDOW (window, w);
4513 if (NILP (w->contents))
4514 /* It's a no-op to delete an already deleted window. */
4515 return Qnil;
4517 parent = w->parent;
4518 if (NILP (parent))
4519 /* Never delete a minibuffer or frame root window. */
4520 error ("Attempt to delete minibuffer or sole ordinary window");
4521 else if (NILP (w->prev) && NILP (w->next))
4522 /* Rather bow out here, this case should be handled on the Elisp
4523 level. */
4524 error ("Attempt to delete sole window of parent");
4526 p = XWINDOW (parent);
4527 horflag = WINDOW_HORIZONTAL_COMBINATION_P (p);
4529 frame = WINDOW_FRAME (w);
4530 f = XFRAME (frame);
4532 root = FRAME_ROOT_WINDOW (f);
4533 r = XWINDOW (root);
4535 /* Unlink WINDOW from window tree. */
4536 if (NILP (w->prev))
4537 /* Get SIBLING below (on the right of) WINDOW. */
4539 /* before_sibling 1 means WINDOW is the first child of its
4540 parent and thus before the sibling. */
4541 before_sibling = 1;
4542 sibling = w->next;
4543 s = XWINDOW (sibling);
4544 wset_prev (s, Qnil);
4545 wset_combination (p, horflag, sibling);
4547 else
4548 /* Get SIBLING above (on the left of) WINDOW. */
4550 sibling = w->prev;
4551 s = XWINDOW (sibling);
4552 wset_next (s, w->next);
4553 if (!NILP (s->next))
4554 wset_prev (XWINDOW (s->next), sibling);
4557 if (window_resize_check (r, horflag)
4558 && (XINT (r->new_pixel)
4559 == (horflag ? r->pixel_width : r->pixel_height)))
4560 /* We can delete WINDOW now. */
4563 /* Block input. */
4564 block_input ();
4565 window_resize_apply (p, horflag);
4566 /* If this window is referred to by the dpyinfo's mouse
4567 highlight, invalidate that slot to be safe (Bug#9904). */
4568 if (!FRAME_INITIAL_P (f))
4570 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
4572 if (EQ (hlinfo->mouse_face_window, window))
4573 hlinfo->mouse_face_window = Qnil;
4576 fset_redisplay (f);
4577 Vwindow_list = Qnil;
4578 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
4580 wset_next (w, Qnil); /* Don't delete w->next too. */
4581 free_window_matrices (w);
4583 if (WINDOWP (w->contents))
4585 delete_all_child_windows (w->contents);
4586 wset_combination (w, 0, Qnil);
4588 else
4590 unshow_buffer (w);
4591 unchain_marker (XMARKER (w->pointm));
4592 unchain_marker (XMARKER (w->old_pointm));
4593 unchain_marker (XMARKER (w->start));
4594 wset_buffer (w, Qnil);
4597 if (NILP (s->prev) && NILP (s->next))
4598 /* A matrjoshka where SIBLING has become the only child of
4599 PARENT. */
4601 /* Put SIBLING into PARENT's place. */
4602 replace_window (parent, sibling, 0);
4603 /* Have SIBLING inherit the following three slot values from
4604 PARENT (the combination_limit slot is not inherited). */
4605 wset_normal_cols (s, p->normal_cols);
4606 wset_normal_lines (s, p->normal_lines);
4607 /* Mark PARENT as deleted. */
4608 wset_combination (p, 0, Qnil);
4609 /* Try to merge SIBLING into its new parent. */
4610 recombine_windows (sibling);
4613 adjust_frame_glyphs (f);
4615 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f)))
4616 /* We deleted the frame's selected window. */
4618 /* Use the frame's first window as fallback ... */
4619 Lisp_Object new_selected_window = Fframe_first_window (frame);
4620 /* ... but preferably use its most recently used window. */
4621 Lisp_Object mru_window;
4623 /* `get-mru-window' might fail for some reason so play it safe
4624 - promote the first window _without recording it_ first. */
4625 if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
4626 Fselect_window (new_selected_window, Qt);
4627 else
4628 fset_selected_window (f, new_selected_window);
4630 unblock_input ();
4632 /* Now look whether `get-mru-window' gets us something. */
4633 mru_window = call1 (Qget_mru_window, frame);
4634 if (WINDOW_LIVE_P (mru_window)
4635 && EQ (XWINDOW (mru_window)->frame, frame))
4636 new_selected_window = mru_window;
4638 /* If all ended up well, we now promote the mru window. */
4639 if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
4640 Fselect_window (new_selected_window, Qnil);
4641 else
4642 fset_selected_window (f, new_selected_window);
4644 else
4645 unblock_input ();
4647 /* Must be run by the caller:
4648 run_window_configuration_change_hook (f); */
4650 else
4651 /* We failed: Relink WINDOW into window tree. */
4653 if (before_sibling)
4655 wset_prev (s, window);
4656 wset_combination (p, horflag, window);
4658 else
4660 wset_next (s, window);
4661 if (!NILP (w->next))
4662 wset_prev (XWINDOW (w->next), window);
4664 error ("Deletion failed");
4667 return Qnil;
4670 /***********************************************************************
4671 Resizing Mini-Windows
4672 ***********************************************************************/
4674 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4675 can. */
4676 void
4677 grow_mini_window (struct window *w, int delta, bool pixelwise)
4679 struct frame *f = XFRAME (w->frame);
4680 struct window *r;
4681 Lisp_Object root, height;
4682 int line_height, pixel_height;
4684 eassert (MINI_WINDOW_P (w));
4685 eassert (delta >= 0);
4687 if (delta > 0)
4689 root = FRAME_ROOT_WINDOW (f);
4690 r = XWINDOW (root);
4691 height = call3 (Qwindow_resize_root_window_vertically,
4692 root, make_number (- delta), pixelwise ? Qt : Qnil);
4693 if (INTEGERP (height) && window_resize_check (r, 0))
4695 block_input ();
4696 window_resize_apply (r, 0);
4698 if (pixelwise)
4700 pixel_height = min (-XINT (height), INT_MAX - w->pixel_height);
4701 line_height = pixel_height / FRAME_LINE_HEIGHT (f);
4703 else
4705 line_height = min (-XINT (height),
4706 ((INT_MAX - w->pixel_height)
4707 / FRAME_LINE_HEIGHT (f)));
4708 pixel_height = line_height * FRAME_LINE_HEIGHT (f);
4711 /* Grow the mini-window. */
4712 w->pixel_top = r->pixel_top + r->pixel_height;
4713 w->top_line = r->top_line + r->total_lines;
4714 /* Make sure the mini-window has always at least one line. */
4715 w->pixel_height = max (w->pixel_height + pixel_height,
4716 FRAME_LINE_HEIGHT (f));
4717 w->total_lines = max (w->total_lines + line_height, 1);
4719 /* Enforce full redisplay of the frame. */
4720 /* FIXME: Shouldn't window--resize-root-window-vertically do it? */
4721 fset_redisplay (f);
4722 adjust_frame_glyphs (f);
4723 unblock_input ();
4728 /* Shrink mini-window W to one line. */
4729 void
4730 shrink_mini_window (struct window *w, bool pixelwise)
4732 struct frame *f = XFRAME (w->frame);
4733 struct window *r;
4734 Lisp_Object root, delta;
4735 EMACS_INT height, unit;
4737 eassert (MINI_WINDOW_P (w));
4739 height = pixelwise ? w->pixel_height : w->total_lines;
4740 unit = pixelwise ? FRAME_LINE_HEIGHT (f) : 1;
4741 if (height > unit)
4743 root = FRAME_ROOT_WINDOW (f);
4744 r = XWINDOW (root);
4745 delta = call3 (Qwindow_resize_root_window_vertically,
4746 root, make_number (height - unit),
4747 pixelwise ? Qt : Qnil);
4748 if (INTEGERP (delta) && window_resize_check (r, 0))
4750 block_input ();
4751 window_resize_apply (r, 0);
4753 /* Shrink the mini-window. */
4754 w->top_line = r->top_line + r->total_lines;
4755 w->total_lines = 1;
4756 w->pixel_top = r->pixel_top + r->pixel_height;
4757 w->pixel_height = FRAME_LINE_HEIGHT (f);
4758 /* Enforce full redisplay of the frame. */
4759 /* FIXME: Shouldn't window--resize-root-window-vertically do it? */
4760 fset_redisplay (f);
4761 adjust_frame_glyphs (f);
4762 unblock_input ();
4764 /* If the above failed for whatever strange reason we must make a
4765 one window frame here. The same routine will be needed when
4766 shrinking the frame (and probably when making the initial
4767 *scratch* window). For the moment leave things as they are. */
4771 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini_window_internal, 1, 1, 0,
4772 doc: /* Resize minibuffer window WINDOW. */)
4773 (Lisp_Object window)
4775 struct window *w = XWINDOW (window);
4776 struct window *r;
4777 struct frame *f;
4778 int height;
4780 CHECK_WINDOW (window);
4781 f = XFRAME (w->frame);
4783 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w->frame)), window))
4784 error ("Not a valid minibuffer window");
4785 else if (FRAME_MINIBUF_ONLY_P (f))
4786 error ("Cannot resize a minibuffer-only frame");
4788 r = XWINDOW (FRAME_ROOT_WINDOW (f));
4789 height = r->pixel_height + w->pixel_height;
4790 if (window_resize_check (r, 0)
4791 && XINT (w->new_pixel) > 0
4792 && height == XINT (r->new_pixel) + XINT (w->new_pixel))
4794 block_input ();
4795 window_resize_apply (r, 0);
4797 w->pixel_height = XFASTINT (w->new_pixel);
4798 w->total_lines = w->pixel_height / FRAME_LINE_HEIGHT (f);
4799 w->pixel_top = r->pixel_top + r->pixel_height;
4800 w->top_line = r->top_line + r->total_lines;
4802 fset_redisplay (f);
4803 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
4804 adjust_frame_glyphs (f);
4805 unblock_input ();
4806 return Qt;
4808 else
4809 error ("Failed to resize minibuffer window");
4812 /* Mark window cursors off for all windows in the window tree rooted
4813 at W by setting their phys_cursor_on_p flag to zero. Called from
4814 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4815 the frame are cleared. */
4817 void
4818 mark_window_cursors_off (struct window *w)
4820 while (w)
4822 if (WINDOWP (w->contents))
4823 mark_window_cursors_off (XWINDOW (w->contents));
4824 else
4825 w->phys_cursor_on_p = 0;
4827 w = NILP (w->next) ? 0 : XWINDOW (w->next);
4832 /* Return number of lines of text (not counting mode lines) in W. */
4835 window_internal_height (struct window *w)
4837 int ht = w->total_lines;
4839 if (!MINI_WINDOW_P (w))
4841 if (!NILP (w->parent)
4842 || WINDOWP (w->contents)
4843 || !NILP (w->next)
4844 || !NILP (w->prev)
4845 || WINDOW_WANTS_MODELINE_P (w))
4846 --ht;
4848 if (WINDOW_WANTS_HEADER_LINE_P (w))
4849 --ht;
4852 return ht;
4856 /************************************************************************
4857 Window Scrolling
4858 ***********************************************************************/
4860 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4861 N screen-fulls, which is defined as the height of the window minus
4862 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4863 instead. Negative values of N mean scroll down. NOERROR non-zero
4864 means don't signal an error if we try to move over BEGV or ZV,
4865 respectively. */
4867 static void
4868 window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
4870 immediate_quit = 1;
4871 n = clip_to_bounds (INT_MIN, n, INT_MAX);
4873 wset_redisplay (XWINDOW (window));
4875 /* If we must, use the pixel-based version which is much slower than
4876 the line-based one but can handle varying line heights. */
4877 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window)->frame)))
4878 window_scroll_pixel_based (window, n, whole, noerror);
4879 else
4880 window_scroll_line_based (window, n, whole, noerror);
4882 /* Bug#15957. */
4883 XWINDOW (window)->window_end_valid = 0;
4884 immediate_quit = 0;
4888 /* Implementation of window_scroll that works based on pixel line
4889 heights. See the comment of window_scroll for parameter
4890 descriptions. */
4892 static void
4893 window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
4895 struct it it;
4896 struct window *w = XWINDOW (window);
4897 struct text_pos start;
4898 int this_scroll_margin;
4899 /* True if we fiddled the window vscroll field without really scrolling. */
4900 int vscrolled = 0;
4901 int x, y, rtop, rbot, rowh, vpos;
4902 void *itdata = NULL;
4903 int window_total_lines;
4904 int frame_line_height = default_line_pixel_height (w);
4905 bool adjust_old_pointm = !NILP (Fequal (Fwindow_point (window),
4906 Fwindow_old_point (window)));
4908 SET_TEXT_POS_FROM_MARKER (start, w->start);
4909 /* Scrolling a minibuffer window via scroll bar when the echo area
4910 shows long text sometimes resets the minibuffer contents behind
4911 our backs. */
4912 if (CHARPOS (start) > ZV)
4913 SET_TEXT_POS (start, BEGV, BEGV_BYTE);
4915 /* If PT is not visible in WINDOW, move back one half of
4916 the screen. Allow PT to be partially visible, otherwise
4917 something like (scroll-down 1) with PT in the line before
4918 the partially visible one would recenter. */
4920 if (!pos_visible_p (w, PT, &x, &y, &rtop, &rbot, &rowh, &vpos))
4922 itdata = bidi_shelve_cache ();
4923 /* Move backward half the height of the window. Performance note:
4924 vmotion used here is about 10% faster, but would give wrong
4925 results for variable height lines. */
4926 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
4927 it.current_y = it.last_visible_y;
4928 move_it_vertically_backward (&it, window_box_height (w) / 2);
4930 /* The function move_iterator_vertically may move over more than
4931 the specified y-distance. If it->w is small, e.g. a
4932 mini-buffer window, we may end up in front of the window's
4933 display area. This is the case when Start displaying at the
4934 start of the line containing PT in this case. */
4935 if (it.current_y <= 0)
4937 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
4938 move_it_vertically_backward (&it, 0);
4939 it.current_y = 0;
4942 start = it.current.pos;
4943 bidi_unshelve_cache (itdata, 0);
4945 else if (auto_window_vscroll_p)
4947 if (rtop || rbot) /* Partially visible. */
4949 int px;
4950 int dy = frame_line_height;
4951 if (whole)
4952 dy = max ((window_box_height (w)
4953 - next_screen_context_lines * dy),
4954 dy);
4955 dy *= n;
4957 if (n < 0)
4959 /* Only vscroll backwards if already vscrolled forwards. */
4960 if (w->vscroll < 0 && rtop > 0)
4962 px = max (0, -w->vscroll - min (rtop, -dy));
4963 Fset_window_vscroll (window, make_number (px), Qt);
4964 return;
4967 if (n > 0)
4969 /* Do vscroll if already vscrolled or only display line. */
4970 if (rbot > 0 && (w->vscroll < 0 || vpos == 0))
4972 px = max (0, -w->vscroll + min (rbot, dy));
4973 Fset_window_vscroll (window, make_number (px), Qt);
4974 return;
4977 /* Maybe modify window start instead of scrolling. */
4978 if (rbot > 0 || w->vscroll < 0)
4980 ptrdiff_t spos;
4982 Fset_window_vscroll (window, make_number (0), Qt);
4983 /* If there are other text lines above the current row,
4984 move window start to current row. Else to next row. */
4985 if (rbot > 0)
4986 spos = XINT (Fline_beginning_position (Qnil));
4987 else
4988 spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
4989 set_marker_restricted (w->start, make_number (spos),
4990 w->contents);
4991 w->start_at_line_beg = 1;
4992 w->update_mode_line = 1;
4993 /* Set force_start so that redisplay_window will run the
4994 window-scroll-functions. */
4995 w->force_start = 1;
4996 return;
5000 /* Cancel previous vscroll. */
5001 Fset_window_vscroll (window, make_number (0), Qt);
5004 itdata = bidi_shelve_cache ();
5005 /* If scroll_preserve_screen_position is non-nil, we try to set
5006 point in the same window line as it is now, so get that line. */
5007 if (!NILP (Vscroll_preserve_screen_position))
5009 /* We preserve the goal pixel coordinate across consecutive
5010 calls to scroll-up, scroll-down and other commands that
5011 have the `scroll-command' property. This avoids the
5012 possibility of point becoming "stuck" on a tall line when
5013 scrolling by one line. */
5014 if (window_scroll_pixel_based_preserve_y < 0
5015 || !SYMBOLP (KVAR (current_kboard, Vlast_command))
5016 || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
5018 start_display (&it, w, start);
5019 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
5020 window_scroll_pixel_based_preserve_y = it.current_y;
5021 window_scroll_pixel_based_preserve_x = it.current_x;
5024 else
5025 window_scroll_pixel_based_preserve_y
5026 = window_scroll_pixel_based_preserve_x = -1;
5028 /* Move iterator it from start the specified distance forward or
5029 backward. The result is the new window start. */
5030 start_display (&it, w, start);
5031 if (whole)
5033 ptrdiff_t start_pos = IT_CHARPOS (it);
5034 int dy = frame_line_height;
5036 dy = max ((window_box_height (w)
5037 - next_screen_context_lines * dy),
5038 dy) * n;
5040 /* Note that move_it_vertically always moves the iterator to the
5041 start of a line. So, if the last line doesn't have a newline,
5042 we would end up at the start of the line ending at ZV. */
5043 if (dy <= 0)
5045 move_it_vertically_backward (&it, -dy);
5046 /* Ensure we actually do move, e.g. in case we are currently
5047 looking at an image that is taller that the window height. */
5048 while (start_pos == IT_CHARPOS (it)
5049 && start_pos > BEGV)
5050 move_it_by_lines (&it, -1);
5052 else if (dy > 0)
5054 move_it_to (&it, ZV, -1, it.current_y + dy, -1,
5055 MOVE_TO_POS | MOVE_TO_Y);
5056 /* Ensure we actually do move, e.g. in case we are currently
5057 looking at an image that is taller that the window height. */
5058 while (start_pos == IT_CHARPOS (it)
5059 && start_pos < ZV)
5060 move_it_by_lines (&it, 1);
5063 else
5064 move_it_by_lines (&it, n);
5066 /* We failed if we find ZV is already on the screen (scrolling up,
5067 means there's nothing past the end), or if we can't start any
5068 earlier (scrolling down, means there's nothing past the top). */
5069 if ((n > 0 && IT_CHARPOS (it) == ZV)
5070 || (n < 0 && IT_CHARPOS (it) == CHARPOS (start)))
5072 if (IT_CHARPOS (it) == ZV)
5074 if (it.current_y < it.last_visible_y
5075 && (it.current_y + it.max_ascent + it.max_descent
5076 > it.last_visible_y))
5078 /* The last line was only partially visible, make it fully
5079 visible. */
5080 w->vscroll = (it.last_visible_y
5081 - it.current_y + it.max_ascent + it.max_descent);
5082 adjust_frame_glyphs (it.f);
5084 else
5086 bidi_unshelve_cache (itdata, 0);
5087 if (noerror)
5088 return;
5089 else if (n < 0) /* could happen with empty buffers */
5090 xsignal0 (Qbeginning_of_buffer);
5091 else
5092 xsignal0 (Qend_of_buffer);
5095 else
5097 if (w->vscroll != 0)
5098 /* The first line was only partially visible, make it fully
5099 visible. */
5100 w->vscroll = 0;
5101 else
5103 bidi_unshelve_cache (itdata, 0);
5104 if (noerror)
5105 return;
5106 else
5107 xsignal0 (Qbeginning_of_buffer);
5111 /* If control gets here, then we vscrolled. */
5113 XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
5115 /* Don't try to change the window start below. */
5116 vscrolled = 1;
5119 if (! vscrolled)
5121 ptrdiff_t pos = IT_CHARPOS (it);
5122 ptrdiff_t bytepos;
5124 /* If in the middle of a multi-glyph character move forward to
5125 the next character. */
5126 if (in_display_vector_p (&it))
5128 ++pos;
5129 move_it_to (&it, pos, -1, -1, -1, MOVE_TO_POS);
5132 /* Set the window start, and set up the window for redisplay. */
5133 set_marker_restricted_both (w->start, w->contents, IT_CHARPOS (it),
5134 IT_BYTEPOS (it));
5135 bytepos = marker_byte_position (w->start);
5136 w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
5137 w->update_mode_line = 1;
5138 /* Set force_start so that redisplay_window will run the
5139 window-scroll-functions. */
5140 w->force_start = 1;
5143 /* The rest of this function uses current_y in a nonstandard way,
5144 not including the height of the header line if any. */
5145 it.current_y = it.vpos = 0;
5147 /* Move PT out of scroll margins.
5148 This code wants current_y to be zero at the window start position
5149 even if there is a header line. */
5150 window_total_lines
5151 = w->total_lines * WINDOW_FRAME_LINE_HEIGHT (w) / frame_line_height;
5152 this_scroll_margin = max (0, scroll_margin);
5153 this_scroll_margin
5154 = min (this_scroll_margin, window_total_lines / 4);
5155 this_scroll_margin *= frame_line_height;
5157 if (n > 0)
5159 /* We moved the window start towards ZV, so PT may be now
5160 in the scroll margin at the top. */
5161 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
5162 if (IT_CHARPOS (it) == PT && it.current_y >= this_scroll_margin
5163 && (NILP (Vscroll_preserve_screen_position)
5164 || EQ (Vscroll_preserve_screen_position, Qt)))
5165 /* We found PT at a legitimate height. Leave it alone. */
5167 else if (window_scroll_pixel_based_preserve_y >= 0)
5169 /* If we have a header line, take account of it.
5170 This is necessary because we set it.current_y to 0, above. */
5171 move_it_to (&it, -1,
5172 window_scroll_pixel_based_preserve_x,
5173 window_scroll_pixel_based_preserve_y
5174 - (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0 ),
5175 -1, MOVE_TO_Y | MOVE_TO_X);
5176 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
5178 else
5180 while (it.current_y < this_scroll_margin)
5182 int prev = it.current_y;
5183 move_it_by_lines (&it, 1);
5184 if (prev == it.current_y)
5185 break;
5187 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
5190 else if (n < 0)
5192 ptrdiff_t charpos, bytepos;
5193 int partial_p;
5195 /* Save our position, for the
5196 window_scroll_pixel_based_preserve_y case. */
5197 charpos = IT_CHARPOS (it);
5198 bytepos = IT_BYTEPOS (it);
5200 /* We moved the window start towards BEGV, so PT may be now
5201 in the scroll margin at the bottom. */
5202 move_it_to (&it, PT, -1,
5203 (it.last_visible_y - CURRENT_HEADER_LINE_HEIGHT (w)
5204 - this_scroll_margin - 1),
5206 MOVE_TO_POS | MOVE_TO_Y);
5208 /* Save our position, in case it's correct. */
5209 charpos = IT_CHARPOS (it);
5210 bytepos = IT_BYTEPOS (it);
5212 /* If PT is in the screen line at the last fully visible line,
5213 move_it_to will stop at X = 0 in that line, because the
5214 required Y coordinate is reached there. See if we can get to
5215 PT without descending lower in Y, and if we can, it means we
5216 reached PT before the scroll margin. */
5217 if (charpos != PT)
5219 struct it it2;
5220 void *it_data;
5222 it2 = it;
5223 it_data = bidi_shelve_cache ();
5224 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
5225 if (IT_CHARPOS (it) == PT && it.current_y == it2.current_y)
5227 charpos = IT_CHARPOS (it);
5228 bytepos = IT_BYTEPOS (it);
5229 bidi_unshelve_cache (it_data, 1);
5231 else
5233 it = it2;
5234 bidi_unshelve_cache (it_data, 0);
5238 /* See if point is on a partially visible line at the end. */
5239 if (it.what == IT_EOB)
5240 partial_p = it.current_y + it.ascent + it.descent > it.last_visible_y;
5241 else
5243 move_it_by_lines (&it, 1);
5244 partial_p = it.current_y > it.last_visible_y;
5247 if (charpos == PT && !partial_p
5248 && (NILP (Vscroll_preserve_screen_position)
5249 || EQ (Vscroll_preserve_screen_position, Qt)))
5250 /* We found PT before we found the display margin, so PT is ok. */
5252 else if (window_scroll_pixel_based_preserve_y >= 0)
5254 SET_TEXT_POS_FROM_MARKER (start, w->start);
5255 start_display (&it, w, start);
5256 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5257 here because we called start_display again and did not
5258 alter it.current_y this time. */
5259 move_it_to (&it, -1, window_scroll_pixel_based_preserve_x,
5260 window_scroll_pixel_based_preserve_y, -1,
5261 MOVE_TO_Y | MOVE_TO_X);
5262 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
5264 else
5266 if (partial_p)
5267 /* The last line was only partially visible, so back up two
5268 lines to make sure we're on a fully visible line. */
5270 move_it_by_lines (&it, -2);
5271 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
5273 else
5274 /* No, the position we saved is OK, so use it. */
5275 SET_PT_BOTH (charpos, bytepos);
5278 bidi_unshelve_cache (itdata, 0);
5280 if (adjust_old_pointm)
5281 Fset_marker (w->old_pointm,
5282 ((w == XWINDOW (selected_window))
5283 ? make_number (BUF_PT (XBUFFER (w->contents)))
5284 : Fmarker_position (w->pointm)),
5285 w->contents);
5289 /* Implementation of window_scroll that works based on screen lines.
5290 See the comment of window_scroll for parameter descriptions. */
5292 static void
5293 window_scroll_line_based (Lisp_Object window, int n, bool whole, int noerror)
5295 register struct window *w = XWINDOW (window);
5296 /* Fvertical_motion enters redisplay, which can trigger
5297 fontification, which in turn can modify buffer text (e.g., if the
5298 fontification functions replace escape sequences with faces, as
5299 in `grep-mode-font-lock-keywords'). So we use a marker to record
5300 the old point position, to prevent crashes in SET_PT_BOTH. */
5301 Lisp_Object opoint_marker = Fpoint_marker ();
5302 register ptrdiff_t pos, pos_byte;
5303 register int ht = window_internal_height (w);
5304 register Lisp_Object tem;
5305 bool lose;
5306 Lisp_Object bolp;
5307 ptrdiff_t startpos = marker_position (w->start);
5308 ptrdiff_t startbyte = marker_byte_position (w->start);
5309 Lisp_Object original_pos = Qnil;
5310 bool adjust_old_pointm = !NILP (Fequal (Fwindow_point (window),
5311 Fwindow_old_point (window)));
5313 /* If scrolling screen-fulls, compute the number of lines to
5314 scroll from the window's height. */
5315 if (whole)
5316 n *= max (1, ht - next_screen_context_lines);
5318 if (!NILP (Vscroll_preserve_screen_position))
5320 if (window_scroll_preserve_vpos <= 0
5321 || !SYMBOLP (KVAR (current_kboard, Vlast_command))
5322 || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
5324 struct position posit
5325 = *compute_motion (startpos, startbyte, 0, 0, 0,
5326 PT, ht, 0, -1, w->hscroll, 0, w);
5328 window_scroll_preserve_vpos = posit.vpos;
5329 window_scroll_preserve_hpos = posit.hpos + w->hscroll;
5332 original_pos = Fcons (make_number (window_scroll_preserve_hpos),
5333 make_number (window_scroll_preserve_vpos));
5336 XSETFASTINT (tem, PT);
5337 tem = Fpos_visible_in_window_p (tem, window, Qnil);
5339 if (NILP (tem))
5341 Fvertical_motion (make_number (- (ht / 2)), window);
5342 startpos = PT;
5343 startbyte = PT_BYTE;
5346 SET_PT_BOTH (startpos, startbyte);
5347 lose = n < 0 && PT == BEGV;
5348 Fvertical_motion (make_number (n), window);
5349 pos = PT;
5350 pos_byte = PT_BYTE;
5351 bolp = Fbolp ();
5352 SET_PT_BOTH (marker_position (opoint_marker),
5353 marker_byte_position (opoint_marker));
5355 if (lose)
5357 if (noerror)
5358 return;
5359 else
5360 xsignal0 (Qbeginning_of_buffer);
5363 if (pos < ZV)
5365 /* Don't use a scroll margin that is negative or too large. */
5366 int this_scroll_margin =
5367 max (0, min (scroll_margin, w->total_lines / 4));
5369 set_marker_restricted_both (w->start, w->contents, pos, pos_byte);
5370 w->start_at_line_beg = !NILP (bolp);
5371 w->update_mode_line = 1;
5372 /* Set force_start so that redisplay_window will run
5373 the window-scroll-functions. */
5374 w->force_start = 1;
5376 if (!NILP (Vscroll_preserve_screen_position)
5377 && (whole || !EQ (Vscroll_preserve_screen_position, Qt)))
5379 SET_PT_BOTH (pos, pos_byte);
5380 Fvertical_motion (original_pos, window);
5382 /* If we scrolled forward, put point enough lines down
5383 that it is outside the scroll margin. */
5384 else if (n > 0)
5386 int top_margin;
5388 if (this_scroll_margin > 0)
5390 SET_PT_BOTH (pos, pos_byte);
5391 Fvertical_motion (make_number (this_scroll_margin), window);
5392 top_margin = PT;
5394 else
5395 top_margin = pos;
5397 if (top_margin <= marker_position (opoint_marker))
5398 SET_PT_BOTH (marker_position (opoint_marker),
5399 marker_byte_position (opoint_marker));
5400 else if (!NILP (Vscroll_preserve_screen_position))
5402 SET_PT_BOTH (pos, pos_byte);
5403 Fvertical_motion (original_pos, window);
5405 else
5406 SET_PT (top_margin);
5408 else if (n < 0)
5410 int bottom_margin;
5412 /* If we scrolled backward, put point near the end of the window
5413 but not within the scroll margin. */
5414 SET_PT_BOTH (pos, pos_byte);
5415 tem = Fvertical_motion (make_number (ht - this_scroll_margin), window);
5416 if (XFASTINT (tem) == ht - this_scroll_margin)
5417 bottom_margin = PT;
5418 else
5419 bottom_margin = PT + 1;
5421 if (bottom_margin > marker_position (opoint_marker))
5422 SET_PT_BOTH (marker_position (opoint_marker),
5423 marker_byte_position (opoint_marker));
5424 else
5426 if (!NILP (Vscroll_preserve_screen_position))
5428 SET_PT_BOTH (pos, pos_byte);
5429 Fvertical_motion (original_pos, window);
5431 else
5432 Fvertical_motion (make_number (-1), window);
5436 else
5438 if (noerror)
5439 return;
5440 else
5441 xsignal0 (Qend_of_buffer);
5444 if (adjust_old_pointm)
5445 Fset_marker (w->old_pointm,
5446 ((w == XWINDOW (selected_window))
5447 ? make_number (BUF_PT (XBUFFER (w->contents)))
5448 : Fmarker_position (w->pointm)),
5449 w->contents);
5453 /* Scroll selected_window up or down. If N is nil, scroll a
5454 screen-full which is defined as the height of the window minus
5455 next_screen_context_lines. If N is the symbol `-', scroll.
5456 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5457 up. This is the guts of Fscroll_up and Fscroll_down. */
5459 static void
5460 scroll_command (Lisp_Object n, int direction)
5462 ptrdiff_t count = SPECPDL_INDEX ();
5464 eassert (eabs (direction) == 1);
5466 /* If selected window's buffer isn't current, make it current for
5467 the moment. But don't screw up if window_scroll gets an error. */
5468 if (XBUFFER (XWINDOW (selected_window)->contents) != current_buffer)
5470 record_unwind_protect (save_excursion_restore, save_excursion_save ());
5471 Fset_buffer (XWINDOW (selected_window)->contents);
5474 if (NILP (n))
5475 window_scroll (selected_window, direction, 1, 0);
5476 else if (EQ (n, Qminus))
5477 window_scroll (selected_window, -direction, 1, 0);
5478 else
5480 n = Fprefix_numeric_value (n);
5481 window_scroll (selected_window, XINT (n) * direction, 0, 0);
5484 unbind_to (count, Qnil);
5487 DEFUN ("scroll-up", Fscroll_up, Sscroll_up, 0, 1, "^P",
5488 doc: /* Scroll text of selected window upward ARG lines.
5489 If ARG is omitted or nil, scroll upward by a near full screen.
5490 A near full screen is `next-screen-context-lines' less than a full screen.
5491 Negative ARG means scroll downward.
5492 If ARG is the atom `-', scroll downward by nearly full screen.
5493 When calling from a program, supply as argument a number, nil, or `-'. */)
5494 (Lisp_Object arg)
5496 scroll_command (arg, 1);
5497 return Qnil;
5500 DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "^P",
5501 doc: /* Scroll text of selected window down ARG lines.
5502 If ARG is omitted or nil, scroll down by a near full screen.
5503 A near full screen is `next-screen-context-lines' less than a full screen.
5504 Negative ARG means scroll upward.
5505 If ARG is the atom `-', scroll upward by nearly full screen.
5506 When calling from a program, supply as argument a number, nil, or `-'. */)
5507 (Lisp_Object arg)
5509 scroll_command (arg, -1);
5510 return Qnil;
5513 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, Sother_window_for_scrolling, 0, 0, 0,
5514 doc: /* Return the other window for \"other window scroll\" commands.
5515 If `other-window-scroll-buffer' is non-nil, a window
5516 showing that buffer is used.
5517 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5518 specifies the window. This takes precedence over
5519 `other-window-scroll-buffer'. */)
5520 (void)
5522 Lisp_Object window;
5524 if (MINI_WINDOW_P (XWINDOW (selected_window))
5525 && !NILP (Vminibuf_scroll_window))
5526 window = Vminibuf_scroll_window;
5527 /* If buffer is specified and live, scroll that buffer. */
5528 else if (!NILP (Vother_window_scroll_buffer)
5529 && BUFFERP (Vother_window_scroll_buffer)
5530 && BUFFER_LIVE_P (XBUFFER (Vother_window_scroll_buffer)))
5532 window = Fget_buffer_window (Vother_window_scroll_buffer, Qnil);
5533 if (NILP (window))
5534 window = display_buffer (Vother_window_scroll_buffer, Qt, Qnil);
5536 else
5538 /* Nothing specified; look for a neighboring window on the same
5539 frame. */
5540 window = Fnext_window (selected_window, Qnil, Qnil);
5542 if (EQ (window, selected_window))
5543 /* That didn't get us anywhere; look for a window on another
5544 visible frame. */
5546 window = Fnext_window (window, Qnil, Qt);
5547 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window))))
5548 && ! EQ (window, selected_window));
5551 CHECK_LIVE_WINDOW (window);
5553 if (EQ (window, selected_window))
5554 error ("There is no other window");
5556 return window;
5559 DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "P",
5560 doc: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5561 A near full screen is `next-screen-context-lines' less than a full screen.
5562 The next window is the one below the current one; or the one at the top
5563 if the current one is at the bottom. Negative ARG means scroll downward.
5564 If ARG is the atom `-', scroll downward by nearly full screen.
5565 When calling from a program, supply as argument a number, nil, or `-'.
5567 If `other-window-scroll-buffer' is non-nil, scroll the window
5568 showing that buffer, popping the buffer up if necessary.
5569 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5570 specifies the window to scroll. This takes precedence over
5571 `other-window-scroll-buffer'. */)
5572 (Lisp_Object arg)
5574 Lisp_Object window;
5575 struct window *w;
5576 ptrdiff_t count = SPECPDL_INDEX ();
5578 window = Fother_window_for_scrolling ();
5579 w = XWINDOW (window);
5581 /* Don't screw up if window_scroll gets an error. */
5582 record_unwind_protect (save_excursion_restore, save_excursion_save ());
5584 Fset_buffer (w->contents);
5585 SET_PT_BOTH (marker_position (w->pointm), marker_byte_position (w->pointm));
5586 SET_PT_BOTH (marker_position (w->old_pointm), marker_byte_position (w->old_pointm));
5588 if (NILP (arg))
5589 window_scroll (window, 1, 1, 1);
5590 else if (EQ (arg, Qminus))
5591 window_scroll (window, -1, 1, 1);
5592 else
5594 if (CONSP (arg))
5595 arg = XCAR (arg);
5596 CHECK_NUMBER (arg);
5597 window_scroll (window, XINT (arg), 0, 1);
5600 set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
5601 set_marker_both (w->old_pointm, Qnil, PT, PT_BYTE);
5602 unbind_to (count, Qnil);
5604 return Qnil;
5607 DEFUN ("scroll-left", Fscroll_left, Sscroll_left, 0, 2, "^P\np",
5608 doc: /* Scroll selected window display ARG columns left.
5609 Default for ARG is window width minus 2.
5610 Value is the total amount of leftward horizontal scrolling in
5611 effect after the change.
5612 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5613 lower bound for automatic scrolling, i.e. automatic scrolling
5614 will not scroll a window to a column less than the value returned
5615 by this function. This happens in an interactive call. */)
5616 (register Lisp_Object arg, Lisp_Object set_minimum)
5618 struct window *w = XWINDOW (selected_window);
5619 EMACS_INT requested_arg = (NILP (arg)
5620 ? window_body_width (w, 0) - 2
5621 : XINT (Fprefix_numeric_value (arg)));
5622 Lisp_Object result = set_window_hscroll (w, w->hscroll + requested_arg);
5624 if (!NILP (set_minimum))
5625 w->min_hscroll = w->hscroll;
5627 w->suspend_auto_hscroll = 1;
5629 return result;
5632 DEFUN ("scroll-right", Fscroll_right, Sscroll_right, 0, 2, "^P\np",
5633 doc: /* Scroll selected window display ARG columns right.
5634 Default for ARG is window width minus 2.
5635 Value is the total amount of leftward horizontal scrolling in
5636 effect after the change.
5637 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5638 lower bound for automatic scrolling, i.e. automatic scrolling
5639 will not scroll a window to a column less than the value returned
5640 by this function. This happens in an interactive call. */)
5641 (register Lisp_Object arg, Lisp_Object set_minimum)
5643 struct window *w = XWINDOW (selected_window);
5644 EMACS_INT requested_arg = (NILP (arg)
5645 ? window_body_width (w, 0) - 2
5646 : XINT (Fprefix_numeric_value (arg)));
5647 Lisp_Object result = set_window_hscroll (w, w->hscroll - requested_arg);
5649 if (!NILP (set_minimum))
5650 w->min_hscroll = w->hscroll;
5652 w->suspend_auto_hscroll = 1;
5654 return result;
5657 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window, Sminibuffer_selected_window, 0, 0, 0,
5658 doc: /* Return the window which was selected when entering the minibuffer.
5659 Returns nil, if selected window is not a minibuffer window. */)
5660 (void)
5662 if (minibuf_level > 0
5663 && MINI_WINDOW_P (XWINDOW (selected_window))
5664 && WINDOW_LIVE_P (minibuf_selected_window))
5665 return minibuf_selected_window;
5667 return Qnil;
5670 /* Value is the number of lines actually displayed in window W,
5671 as opposed to its height. */
5673 static int
5674 displayed_window_lines (struct window *w)
5676 struct it it;
5677 struct text_pos start;
5678 int height = window_box_height (w);
5679 struct buffer *old_buffer;
5680 int bottom_y;
5681 void *itdata = NULL;
5683 if (XBUFFER (w->contents) != current_buffer)
5685 old_buffer = current_buffer;
5686 set_buffer_internal (XBUFFER (w->contents));
5688 else
5689 old_buffer = NULL;
5691 /* In case W->start is out of the accessible range, do something
5692 reasonable. This happens in Info mode when Info-scroll-down
5693 calls (recenter -1) while W->start is 1. */
5694 CLIP_TEXT_POS_FROM_MARKER (start, w->start);
5696 itdata = bidi_shelve_cache ();
5697 start_display (&it, w, start);
5698 move_it_vertically (&it, height);
5699 bottom_y = line_bottom_y (&it);
5700 bidi_unshelve_cache (itdata, 0);
5702 /* rms: On a non-window display,
5703 the value of it.vpos at the bottom of the screen
5704 seems to be 1 larger than window_box_height (w).
5705 This kludge fixes a bug whereby (move-to-window-line -1)
5706 when ZV is on the last screen line
5707 moves to the previous screen line instead of the last one. */
5708 if (! FRAME_WINDOW_P (XFRAME (w->frame)))
5709 height++;
5711 /* Add in empty lines at the bottom of the window. */
5712 if (bottom_y < height)
5714 int uy = FRAME_LINE_HEIGHT (it.f);
5715 it.vpos += (height - bottom_y + uy - 1) / uy;
5718 if (old_buffer)
5719 set_buffer_internal (old_buffer);
5721 return it.vpos;
5725 DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
5726 doc: /* Center point in selected window and maybe redisplay frame.
5727 With a numeric prefix argument ARG, recenter putting point on screen line ARG
5728 relative to the selected window. If ARG is negative, it counts up from the
5729 bottom of the window. (ARG should be less than the height of the window.)
5731 If ARG is omitted or nil, then recenter with point on the middle line of
5732 the selected window; if the variable `recenter-redisplay' is non-nil,
5733 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5734 is set to `grow-only', this resets the tool-bar's height to the minimum
5735 height needed); if `recenter-redisplay' has the special value `tty',
5736 then only tty frames are redrawn.
5738 Just C-u as prefix means put point in the center of the window
5739 and redisplay normally--don't erase and redraw the frame. */)
5740 (register Lisp_Object arg)
5742 struct window *w = XWINDOW (selected_window);
5743 struct buffer *buf = XBUFFER (w->contents);
5744 bool center_p = 0;
5745 ptrdiff_t charpos, bytepos;
5746 EMACS_INT iarg IF_LINT (= 0);
5747 int this_scroll_margin;
5749 if (buf != current_buffer)
5750 error ("`recenter'ing a window that does not display current-buffer.");
5752 /* If redisplay is suppressed due to an error, try again. */
5753 buf->display_error_modiff = 0;
5755 if (NILP (arg))
5757 if (!NILP (Vrecenter_redisplay)
5758 && (!EQ (Vrecenter_redisplay, Qtty)
5759 || !NILP (Ftty_type (selected_frame))))
5761 ptrdiff_t i;
5763 /* Invalidate pixel data calculated for all compositions. */
5764 for (i = 0; i < n_compositions; i++)
5765 composition_table[i]->font = NULL;
5766 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5767 WINDOW_XFRAME (w)->minimize_tool_bar_window_p = 1;
5768 #endif
5769 Fredraw_frame (WINDOW_FRAME (w));
5770 SET_FRAME_GARBAGED (WINDOW_XFRAME (w));
5773 center_p = 1;
5775 else if (CONSP (arg)) /* Just C-u. */
5776 center_p = 1;
5777 else
5779 arg = Fprefix_numeric_value (arg);
5780 CHECK_NUMBER (arg);
5781 iarg = XINT (arg);
5784 /* Do this after making BUF current
5785 in case scroll_margin is buffer-local. */
5786 this_scroll_margin
5787 = max (0, min (scroll_margin, w->total_lines / 4));
5789 /* Handle centering on a graphical frame specially. Such frames can
5790 have variable-height lines and centering point on the basis of
5791 line counts would lead to strange effects. */
5792 if (FRAME_WINDOW_P (XFRAME (w->frame)))
5794 if (center_p)
5796 struct it it;
5797 struct text_pos pt;
5798 void *itdata = bidi_shelve_cache ();
5800 SET_TEXT_POS (pt, PT, PT_BYTE);
5801 start_display (&it, w, pt);
5802 move_it_vertically_backward (&it, window_box_height (w) / 2);
5803 charpos = IT_CHARPOS (it);
5804 bytepos = IT_BYTEPOS (it);
5805 bidi_unshelve_cache (itdata, 0);
5807 else if (iarg < 0)
5809 struct it it;
5810 struct text_pos pt;
5811 ptrdiff_t nlines = min (PTRDIFF_MAX, -iarg);
5812 int extra_line_spacing;
5813 int h = window_box_height (w);
5814 void *itdata = bidi_shelve_cache ();
5816 iarg = - max (-iarg, this_scroll_margin);
5818 SET_TEXT_POS (pt, PT, PT_BYTE);
5819 start_display (&it, w, pt);
5821 /* Be sure we have the exact height of the full line containing PT. */
5822 move_it_by_lines (&it, 0);
5824 /* The amount of pixels we have to move back is the window
5825 height minus what's displayed in the line containing PT,
5826 and the lines below. */
5827 it.current_y = 0;
5828 it.vpos = 0;
5829 move_it_by_lines (&it, nlines);
5831 if (it.vpos == nlines)
5832 h -= it.current_y;
5833 else
5835 /* Last line has no newline. */
5836 h -= line_bottom_y (&it);
5837 it.vpos++;
5840 /* Don't reserve space for extra line spacing of last line. */
5841 extra_line_spacing = it.max_extra_line_spacing;
5843 /* If we can't move down NLINES lines because we hit
5844 the end of the buffer, count in some empty lines. */
5845 if (it.vpos < nlines)
5847 nlines -= it.vpos;
5848 extra_line_spacing = it.extra_line_spacing;
5849 h -= nlines * (FRAME_LINE_HEIGHT (it.f) + extra_line_spacing);
5851 if (h <= 0)
5853 bidi_unshelve_cache (itdata, 0);
5854 return Qnil;
5857 /* Now find the new top line (starting position) of the window. */
5858 start_display (&it, w, pt);
5859 it.current_y = 0;
5860 move_it_vertically_backward (&it, h);
5862 /* If extra line spacing is present, we may move too far
5863 back. This causes the last line to be only partially
5864 visible (which triggers redisplay to recenter that line
5865 in the middle), so move forward.
5866 But ignore extra line spacing on last line, as it is not
5867 considered to be part of the visible height of the line.
5869 h += extra_line_spacing;
5870 while (-it.current_y > h)
5871 move_it_by_lines (&it, 1);
5873 charpos = IT_CHARPOS (it);
5874 bytepos = IT_BYTEPOS (it);
5876 bidi_unshelve_cache (itdata, 0);
5878 else
5880 struct position pos;
5882 iarg = max (iarg, this_scroll_margin);
5884 pos = *vmotion (PT, PT_BYTE, -iarg, w);
5885 charpos = pos.bufpos;
5886 bytepos = pos.bytepos;
5889 else
5891 struct position pos;
5892 int ht = window_internal_height (w);
5894 if (center_p)
5895 iarg = ht / 2;
5896 else if (iarg < 0)
5897 iarg += ht;
5899 /* Don't let it get into the margin at either top or bottom. */
5900 iarg = clip_to_bounds (this_scroll_margin, iarg,
5901 ht - this_scroll_margin - 1);
5903 pos = *vmotion (PT, PT_BYTE, - iarg, w);
5904 charpos = pos.bufpos;
5905 bytepos = pos.bytepos;
5908 /* Set the new window start. */
5909 set_marker_both (w->start, w->contents, charpos, bytepos);
5910 w->window_end_valid = 0;
5912 w->optional_new_start = 1;
5914 w->start_at_line_beg = (bytepos == BEGV_BYTE
5915 || FETCH_BYTE (bytepos - 1) == '\n');
5917 wset_redisplay (w);
5919 return Qnil;
5922 DEFUN ("window-text-width", Fwindow_text_width, Swindow_text_width,
5923 0, 2, 0,
5924 doc: /* Return the width in columns of the text display area of WINDOW.
5925 WINDOW must be a live window and defaults to the selected one.
5927 The returned width does not include dividers, scrollbars, margins,
5928 fringes, nor any partial-width columns at the right of the text
5929 area.
5931 Optional argument PIXELWISE non-nil, means to return the width in
5932 pixels. */)
5933 (Lisp_Object window, Lisp_Object pixelwise)
5935 struct window *w = decode_live_window (window);
5937 if (NILP (pixelwise))
5938 return make_number (window_box_width (w, TEXT_AREA)
5939 / FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w)));
5940 else
5941 return make_number (window_box_width (w, TEXT_AREA));
5944 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
5945 0, 2, 0,
5946 doc: /* Return the height in lines of the text display area of WINDOW.
5947 WINDOW must be a live window and defaults to the selected one.
5949 The returned height does not include dividers, the mode line, any header
5950 line, nor any partial-height lines at the bottom of the text area.
5952 Optional argument PIXELWISE non-nil, means to return the height in
5953 pixels. */)
5954 (Lisp_Object window, Lisp_Object pixelwise)
5956 struct window *w = decode_live_window (window);
5958 if (NILP (pixelwise))
5959 return make_number (window_box_height (w)
5960 / FRAME_LINE_HEIGHT (WINDOW_XFRAME (w)));
5961 else
5962 return make_number (window_box_height (w));
5965 DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
5966 1, 1, "P",
5967 doc: /* Position point relative to window.
5968 ARG nil means position point at center of window.
5969 Else, ARG specifies vertical position within the window;
5970 zero means top of window, negative means relative to bottom of window. */)
5971 (Lisp_Object arg)
5973 struct window *w = XWINDOW (selected_window);
5974 int lines, start;
5975 Lisp_Object window;
5976 #if 0
5977 int this_scroll_margin;
5978 #endif
5980 if (!(BUFFERP (w->contents) && XBUFFER (w->contents) == current_buffer))
5981 /* This test is needed to make sure PT/PT_BYTE make sense in w->contents
5982 when passed below to set_marker_both. */
5983 error ("move-to-window-line called from unrelated buffer");
5985 window = selected_window;
5986 start = marker_position (w->start);
5987 if (start < BEGV || start > ZV)
5989 int height = window_internal_height (w);
5990 Fvertical_motion (make_number (- (height / 2)), window);
5991 set_marker_both (w->start, w->contents, PT, PT_BYTE);
5992 w->start_at_line_beg = !NILP (Fbolp ());
5993 w->force_start = 1;
5995 else
5996 Fgoto_char (w->start);
5998 lines = displayed_window_lines (w);
6000 #if 0
6001 this_scroll_margin = max (0, min (scroll_margin, lines / 4));
6002 #endif
6004 if (NILP (arg))
6005 XSETFASTINT (arg, lines / 2);
6006 else
6008 EMACS_INT iarg = XINT (Fprefix_numeric_value (arg));
6010 if (iarg < 0)
6011 iarg = iarg + lines;
6013 #if 0 /* This code would prevent move-to-window-line from moving point
6014 to a place inside the scroll margins (which would cause the
6015 next redisplay to scroll). I wrote this code, but then concluded
6016 it is probably better not to install it. However, it is here
6017 inside #if 0 so as not to lose it. -- rms. */
6019 /* Don't let it get into the margin at either top or bottom. */
6020 iarg = max (iarg, this_scroll_margin);
6021 iarg = min (iarg, lines - this_scroll_margin - 1);
6022 #endif
6024 arg = make_number (iarg);
6027 /* Skip past a partially visible first line. */
6028 if (w->vscroll)
6029 XSETINT (arg, XINT (arg) + 1);
6031 return Fvertical_motion (arg, window);
6036 /***********************************************************************
6037 Window Configuration
6038 ***********************************************************************/
6040 struct save_window_data
6042 struct vectorlike_header header;
6043 Lisp_Object selected_frame;
6044 Lisp_Object current_window;
6045 Lisp_Object current_buffer;
6046 Lisp_Object minibuf_scroll_window;
6047 Lisp_Object minibuf_selected_window;
6048 Lisp_Object root_window;
6049 Lisp_Object focus_frame;
6050 /* A vector, each of whose elements is a struct saved_window
6051 for one window. */
6052 Lisp_Object saved_windows;
6054 /* All fields above are traced by the GC.
6055 From `frame-cols' down, the fields are ignored by the GC. */
6056 /* We should be able to do without the following two. */
6057 int frame_cols, frame_lines;
6058 /* These two should get eventually replaced by their pixel
6059 counterparts. */
6060 int frame_menu_bar_lines, frame_tool_bar_lines;
6061 int frame_text_width, frame_text_height;
6062 /* These are currently unused. We need them as soon as we convert
6063 to pixels. */
6064 int frame_menu_bar_height, frame_tool_bar_height;
6067 /* This is saved as a Lisp_Vector. */
6068 struct saved_window
6070 struct vectorlike_header header;
6072 Lisp_Object window, buffer, start, pointm, old_pointm;
6073 Lisp_Object pixel_left, pixel_top, pixel_height, pixel_width;
6074 Lisp_Object left_col, top_line, total_cols, total_lines;
6075 Lisp_Object normal_cols, normal_lines;
6076 Lisp_Object hscroll, min_hscroll, hscroll_whole, suspend_auto_hscroll;
6077 Lisp_Object parent, prev;
6078 Lisp_Object start_at_line_beg;
6079 Lisp_Object display_table;
6080 Lisp_Object left_margin_cols, right_margin_cols;
6081 Lisp_Object left_fringe_width, right_fringe_width, fringes_outside_margins;
6082 Lisp_Object scroll_bar_width, vertical_scroll_bar_type, dedicated;
6083 Lisp_Object scroll_bar_height, horizontal_scroll_bar_type;
6084 Lisp_Object combination_limit, window_parameters;
6087 #define SAVED_WINDOW_N(swv,n) \
6088 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
6090 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
6091 doc: /* Return t if OBJECT is a window-configuration object. */)
6092 (Lisp_Object object)
6094 return WINDOW_CONFIGURATIONP (object) ? Qt : Qnil;
6097 DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_configuration_frame, 1, 1, 0,
6098 doc: /* Return the frame that CONFIG, a window-configuration object, is about. */)
6099 (Lisp_Object config)
6101 register struct save_window_data *data;
6102 struct Lisp_Vector *saved_windows;
6104 CHECK_WINDOW_CONFIGURATION (config);
6106 data = (struct save_window_data *) XVECTOR (config);
6107 saved_windows = XVECTOR (data->saved_windows);
6108 return XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
6111 DEFUN ("set-window-configuration", Fset_window_configuration,
6112 Sset_window_configuration, 1, 1, 0,
6113 doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
6114 CONFIGURATION must be a value previously returned
6115 by `current-window-configuration' (which see).
6116 If CONFIGURATION was made from a frame that is now deleted,
6117 only frame-independent values can be restored. In this case,
6118 the return value is nil. Otherwise the value is t. */)
6119 (Lisp_Object configuration)
6121 register struct save_window_data *data;
6122 struct Lisp_Vector *saved_windows;
6123 Lisp_Object new_current_buffer;
6124 Lisp_Object frame;
6125 struct frame *f;
6126 ptrdiff_t old_point = -1;
6127 USE_SAFE_ALLOCA;
6129 CHECK_WINDOW_CONFIGURATION (configuration);
6131 data = (struct save_window_data *) XVECTOR (configuration);
6132 saved_windows = XVECTOR (data->saved_windows);
6134 new_current_buffer = data->current_buffer;
6135 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer)))
6136 new_current_buffer = Qnil;
6137 else
6139 if (XBUFFER (new_current_buffer) == current_buffer)
6140 /* The code further down "preserves point" by saving here PT in
6141 old_point and then setting it later back into PT. When the
6142 current-selected-window and the final-selected-window both show
6143 the current buffer, this suffers from the problem that the
6144 current PT is the window-point of the current-selected-window,
6145 while the final PT is the point of the final-selected-window, so
6146 this copy from one PT to the other would end up moving the
6147 window-point of the final-selected-window to the window-point of
6148 the current-selected-window. So we have to be careful which
6149 point of the current-buffer we copy into old_point. */
6150 if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
6151 && WINDOWP (selected_window)
6152 && EQ (XWINDOW (selected_window)->contents, new_current_buffer)
6153 && !EQ (selected_window, data->current_window))
6154 old_point = marker_position (XWINDOW (data->current_window)->pointm);
6155 else
6156 old_point = PT;
6157 else
6158 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6159 point in new_current_buffer as of the last time this buffer was
6160 used. This can be non-deterministic since it can be changed by
6161 things like jit-lock by mere temporary selection of some random
6162 window that happens to show this buffer.
6163 So if possible we want this arbitrary choice of "which point" to
6164 be the one from the to-be-selected-window so as to prevent this
6165 window's cursor from being copied from another window. */
6166 if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
6167 /* If current_window = selected_window, its point is in BUF_PT. */
6168 && !EQ (selected_window, data->current_window))
6169 old_point = marker_position (XWINDOW (data->current_window)->pointm);
6170 else
6171 old_point = BUF_PT (XBUFFER (new_current_buffer));
6174 frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
6175 f = XFRAME (frame);
6177 /* If f is a dead frame, don't bother rebuilding its window tree.
6178 However, there is other stuff we should still try to do below. */
6179 if (FRAME_LIVE_P (f))
6181 Lisp_Object window;
6182 Lisp_Object dead_windows = Qnil;
6183 register Lisp_Object tem, par, pers;
6184 register struct window *w;
6185 register struct saved_window *p;
6186 struct window *root_window;
6187 struct window **leaf_windows;
6188 int n_leaf_windows;
6189 ptrdiff_t k;
6190 int i, n;
6192 /* Don't do this within the main loop below: This may call Lisp
6193 code and is thus potentially unsafe while input is blocked. */
6194 for (k = 0; k < saved_windows->header.size; k++)
6196 p = SAVED_WINDOW_N (saved_windows, k);
6197 window = p->window;
6198 w = XWINDOW (window);
6199 if (BUFFERP (w->contents)
6200 && !EQ (w->contents, p->buffer)
6201 && BUFFER_LIVE_P (XBUFFER (p->buffer)))
6202 /* If a window we restore gets another buffer, record the
6203 window's old buffer. */
6204 call1 (Qrecord_window_buffer, window);
6207 /* Consider frame unofficial, temporarily. */
6208 f->official = false;
6209 /* The mouse highlighting code could get screwed up
6210 if it runs during this. */
6211 block_input ();
6213 /* "Swap out" point from the selected window's buffer
6214 into the window itself. (Normally the pointm of the selected
6215 window holds garbage.) We do this now, before
6216 restoring the window contents, and prevent it from
6217 being done later on when we select a new window. */
6218 if (! NILP (XWINDOW (selected_window)->contents))
6220 w = XWINDOW (selected_window);
6221 set_marker_both (w->pointm,
6222 w->contents,
6223 BUF_PT (XBUFFER (w->contents)),
6224 BUF_PT_BYTE (XBUFFER (w->contents)));
6227 fset_redisplay (f);
6228 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
6230 /* Problem: Freeing all matrices and later allocating them again
6231 is a serious redisplay flickering problem. What we would
6232 really like to do is to free only those matrices not reused
6233 below. */
6234 root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
6235 int nwindows = count_windows (root_window);
6236 SAFE_NALLOCA (leaf_windows, 1, nwindows);
6237 n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
6239 /* Kludge Alert!
6240 Mark all windows now on frame as "deleted".
6241 Restoring the new configuration "undeletes" any that are in it.
6243 Save their current buffers in their height fields, since we may
6244 need it later, if a buffer saved in the configuration is now
6245 dead. */
6246 delete_all_child_windows (FRAME_ROOT_WINDOW (f));
6248 for (k = 0; k < saved_windows->header.size; k++)
6250 p = SAVED_WINDOW_N (saved_windows, k);
6251 window = p->window;
6252 w = XWINDOW (window);
6253 wset_next (w, Qnil);
6255 if (!NILP (p->parent))
6256 wset_parent
6257 (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);
6258 else
6259 wset_parent (w, Qnil);
6261 if (!NILP (p->prev))
6263 wset_prev
6264 (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
6265 wset_next (XWINDOW (w->prev), p->window);
6267 else
6269 wset_prev (w, Qnil);
6270 if (!NILP (w->parent))
6271 wset_combination (XWINDOW (w->parent),
6272 (XINT (p->total_cols)
6273 != XWINDOW (w->parent)->total_cols),
6274 p->window);
6277 /* If we squirreled away the buffer, restore it now. */
6278 if (BUFFERP (w->combination_limit))
6279 wset_buffer (w, w->combination_limit);
6280 w->pixel_left = XFASTINT (p->pixel_left);
6281 w->pixel_top = XFASTINT (p->pixel_top);
6282 w->pixel_width = XFASTINT (p->pixel_width);
6283 w->pixel_height = XFASTINT (p->pixel_height);
6284 w->left_col = XFASTINT (p->left_col);
6285 w->top_line = XFASTINT (p->top_line);
6286 w->total_cols = XFASTINT (p->total_cols);
6287 w->total_lines = XFASTINT (p->total_lines);
6288 wset_normal_cols (w, p->normal_cols);
6289 wset_normal_lines (w, p->normal_lines);
6290 w->hscroll = XFASTINT (p->hscroll);
6291 w->suspend_auto_hscroll = !NILP (p->suspend_auto_hscroll);
6292 w->min_hscroll = XFASTINT (p->min_hscroll);
6293 w->hscroll_whole = XFASTINT (p->hscroll_whole);
6294 wset_display_table (w, p->display_table);
6295 w->left_margin_cols = XINT (p->left_margin_cols);
6296 w->right_margin_cols = XINT (p->right_margin_cols);
6297 w->left_fringe_width = XINT (p->left_fringe_width);
6298 w->right_fringe_width = XINT (p->right_fringe_width);
6299 w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
6300 w->scroll_bar_width = XINT (p->scroll_bar_width);
6301 w->scroll_bar_height = XINT (p->scroll_bar_height);
6302 wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
6303 wset_horizontal_scroll_bar_type (w, p->horizontal_scroll_bar_type);
6304 wset_dedicated (w, p->dedicated);
6305 wset_combination_limit (w, p->combination_limit);
6306 /* Restore any window parameters that have been saved.
6307 Parameters that have not been saved are left alone. */
6308 for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
6310 pers = XCAR (tem);
6311 if (CONSP (pers))
6313 if (NILP (XCDR (pers)))
6315 par = Fassq (XCAR (pers), w->window_parameters);
6316 if (CONSP (par) && !NILP (XCDR (par)))
6317 /* Reset a parameter to nil if and only if it
6318 has a non-nil association. Don't make new
6319 associations. */
6320 Fsetcdr (par, Qnil);
6322 else
6323 /* Always restore a non-nil value. */
6324 Fset_window_parameter (window, XCAR (pers), XCDR (pers));
6328 if (BUFFERP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
6329 /* If saved buffer is alive, install it. */
6331 wset_buffer (w, p->buffer);
6332 w->start_at_line_beg = !NILP (p->start_at_line_beg);
6333 set_marker_restricted (w->start, p->start, w->contents);
6334 set_marker_restricted (w->pointm, p->pointm, w->contents);
6335 set_marker_restricted (w->old_pointm, p->old_pointm, w->contents);
6336 /* As documented in Fcurrent_window_configuration, don't
6337 restore the location of point in the buffer which was
6338 current when the window configuration was recorded. */
6339 if (!EQ (p->buffer, new_current_buffer)
6340 && XBUFFER (p->buffer) == current_buffer)
6341 Fgoto_char (w->pointm);
6343 else if (BUFFERP (w->contents) && BUFFER_LIVE_P (XBUFFER (w->contents)))
6344 /* Keep window's old buffer; make sure the markers are real. */
6346 /* Set window markers at start of visible range. */
6347 if (XMARKER (w->start)->buffer == 0)
6348 set_marker_restricted_both (w->start, w->contents, 0, 0);
6349 if (XMARKER (w->pointm)->buffer == 0)
6350 set_marker_restricted_both
6351 (w->pointm, w->contents,
6352 BUF_PT (XBUFFER (w->contents)),
6353 BUF_PT_BYTE (XBUFFER (w->contents)));
6354 if (XMARKER (w->old_pointm)->buffer == 0)
6355 set_marker_restricted_both
6356 (w->old_pointm, w->contents,
6357 BUF_PT (XBUFFER (w->contents)),
6358 BUF_PT_BYTE (XBUFFER (w->contents)));
6359 w->start_at_line_beg = 1;
6361 else if (!NILP (w->start))
6362 /* Leaf window has no live buffer, get one. */
6364 /* Get the buffer via other_buffer_safely in order to
6365 avoid showing an unimportant buffer and, if necessary, to
6366 recreate *scratch* in the course (part of Juanma's bs-show
6367 scenario from March 2011). */
6368 wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
6369 /* This will set the markers to beginning of visible
6370 range. */
6371 set_marker_restricted_both (w->start, w->contents, 0, 0);
6372 set_marker_restricted_both (w->pointm, w->contents, 0, 0);
6373 set_marker_restricted_both (w->old_pointm, w->contents, 0, 0);
6374 w->start_at_line_beg = 1;
6375 if (!NILP (w->dedicated))
6376 /* Record this window as dead. */
6377 dead_windows = Fcons (window, dead_windows);
6378 /* Make sure window is no more dedicated. */
6379 wset_dedicated (w, Qnil);
6383 fset_root_window (f, data->root_window);
6384 /* Arrange *not* to restore point in the buffer that was
6385 current when the window configuration was saved. */
6386 if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
6387 set_marker_restricted (XWINDOW (data->current_window)->pointm,
6388 make_number (old_point),
6389 XWINDOW (data->current_window)->contents);
6391 /* In the following call to `select-window', prevent "swapping out
6392 point" in the old selected window using the buffer that has
6393 been restored into it. We already swapped out that point from
6394 that window's old buffer.
6396 Do not record the buffer here. We do that in a separate call
6397 to select_window below. See also Bug#16207. */
6398 select_window (data->current_window, Qt, 1);
6399 BVAR (XBUFFER (XWINDOW (selected_window)->contents),
6400 last_selected_window)
6401 = selected_window;
6403 if (NILP (data->focus_frame)
6404 || (FRAMEP (data->focus_frame)
6405 && FRAME_LIVE_P (XFRAME (data->focus_frame))))
6406 Fredirect_frame_focus (frame, data->focus_frame);
6408 /* Now, free glyph matrices in windows that were not reused. */
6409 for (i = n = 0; i < n_leaf_windows; ++i)
6411 if (NILP (leaf_windows[i]->contents))
6412 free_window_matrices (leaf_windows[i]);
6413 else if (EQ (leaf_windows[i]->contents, new_current_buffer))
6414 ++n;
6417 /* Make frame official again and apply frame size changes if
6418 needed. */
6419 f->official = true;
6420 adjust_frame_size (f, -1, -1, 1, 0);
6422 adjust_frame_glyphs (f);
6423 unblock_input ();
6425 /* Scan dead buffer windows. */
6426 for (; CONSP (dead_windows); dead_windows = XCDR (dead_windows))
6428 window = XCAR (dead_windows);
6429 if (WINDOW_LIVE_P (window) && !EQ (window, FRAME_ROOT_WINDOW (f)))
6430 delete_deletable_window (window);
6433 /* Record the selected window's buffer here. The window should
6434 already be the selected one from the call above. */
6435 select_window (data->current_window, Qnil, 0);
6437 /* Fselect_window will have made f the selected frame, so we
6438 reselect the proper frame here. Fhandle_switch_frame will change the
6439 selected window too, but that doesn't make the call to
6440 Fselect_window above totally superfluous; it still sets f's
6441 selected window. */
6442 if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
6443 do_switch_frame (data->selected_frame, 0, 0, Qnil);
6445 run_window_configuration_change_hook (f);
6448 if (!NILP (new_current_buffer))
6450 Fset_buffer (new_current_buffer);
6451 /* If the new current buffer doesn't appear in the selected
6452 window, go to its old point (see bug#12208). */
6453 if (!EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
6454 Fgoto_char (make_number (old_point));
6457 Vminibuf_scroll_window = data->minibuf_scroll_window;
6458 minibuf_selected_window = data->minibuf_selected_window;
6460 SAFE_FREE ();
6461 return (FRAME_LIVE_P (f) ? Qt : Qnil);
6465 void
6466 restore_window_configuration (Lisp_Object configuration)
6468 Fset_window_configuration (configuration);
6472 /* If WINDOW is an internal window, recursively delete all child windows
6473 reachable via the next and contents slots of WINDOW. Otherwise setup
6474 WINDOW to not show any buffer. */
6476 void
6477 delete_all_child_windows (Lisp_Object window)
6479 register struct window *w;
6481 w = XWINDOW (window);
6483 if (!NILP (w->next))
6484 /* Delete WINDOW's siblings (we traverse postorderly). */
6485 delete_all_child_windows (w->next);
6487 if (WINDOWP (w->contents))
6489 delete_all_child_windows (w->contents);
6490 wset_combination (w, 0, Qnil);
6492 else if (BUFFERP (w->contents))
6494 unshow_buffer (w);
6495 unchain_marker (XMARKER (w->pointm));
6496 unchain_marker (XMARKER (w->old_pointm));
6497 unchain_marker (XMARKER (w->start));
6498 /* Since combination limit makes sense for an internal windows
6499 only, we use this slot to save the buffer for the sake of
6500 possible resurrection in Fset_window_configuration. */
6501 wset_combination_limit (w, w->contents);
6502 wset_buffer (w, Qnil);
6505 Vwindow_list = Qnil;
6508 static int
6509 count_windows (register struct window *window)
6511 register int count = 1;
6512 if (!NILP (window->next))
6513 count += count_windows (XWINDOW (window->next));
6514 if (WINDOWP (window->contents))
6515 count += count_windows (XWINDOW (window->contents));
6516 return count;
6520 /* Fill vector FLAT with leaf windows under W, starting at index I.
6521 Value is last index + 1. */
6522 static int
6523 get_leaf_windows (struct window *w, struct window **flat, int i)
6525 while (w)
6527 if (WINDOWP (w->contents))
6528 i = get_leaf_windows (XWINDOW (w->contents), flat, i);
6529 else
6530 flat[i++] = w;
6532 w = NILP (w->next) ? 0 : XWINDOW (w->next);
6535 return i;
6539 /* Return a pointer to the glyph W's physical cursor is on. Value is
6540 null if W's current matrix is invalid, so that no meaningful glyph
6541 can be returned. */
6542 struct glyph *
6543 get_phys_cursor_glyph (struct window *w)
6545 struct glyph_row *row;
6546 struct glyph *glyph;
6547 int hpos = w->phys_cursor.hpos;
6549 if (!(w->phys_cursor.vpos >= 0
6550 && w->phys_cursor.vpos < w->current_matrix->nrows))
6551 return NULL;
6553 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
6554 if (!row->enabled_p)
6555 return NULL;
6557 if (w->hscroll)
6559 /* When the window is hscrolled, cursor hpos can legitimately be
6560 out of bounds, but we draw the cursor at the corresponding
6561 window margin in that case. */
6562 if (!row->reversed_p && hpos < 0)
6563 hpos = 0;
6564 if (row->reversed_p && hpos >= row->used[TEXT_AREA])
6565 hpos = row->used[TEXT_AREA] - 1;
6568 if (0 <= hpos && hpos < row->used[TEXT_AREA])
6569 glyph = row->glyphs[TEXT_AREA] + hpos;
6570 else
6571 glyph = NULL;
6573 return glyph;
6577 static int
6578 save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
6580 register struct saved_window *p;
6581 register struct window *w;
6582 register Lisp_Object tem, pers, par;
6584 for (; !NILP (window); window = w->next)
6586 p = SAVED_WINDOW_N (vector, i);
6587 w = XWINDOW (window);
6589 wset_temslot (w, make_number (i)); i++;
6590 p->window = window;
6591 p->buffer = (WINDOW_LEAF_P (w) ? w->contents : Qnil);
6592 p->pixel_left = make_number (w->pixel_left);
6593 p->pixel_top = make_number (w->pixel_top);
6594 p->pixel_width = make_number (w->pixel_width);
6595 p->pixel_height = make_number (w->pixel_height);
6596 p->left_col = make_number (w->left_col);
6597 p->top_line = make_number (w->top_line);
6598 p->total_cols = make_number (w->total_cols);
6599 p->total_lines = make_number (w->total_lines);
6600 p->normal_cols = w->normal_cols;
6601 p->normal_lines = w->normal_lines;
6602 XSETFASTINT (p->hscroll, w->hscroll);
6603 p->suspend_auto_hscroll = w->suspend_auto_hscroll ? Qt : Qnil;
6604 XSETFASTINT (p->min_hscroll, w->min_hscroll);
6605 XSETFASTINT (p->hscroll_whole, w->hscroll_whole);
6606 p->display_table = w->display_table;
6607 p->left_margin_cols = make_number (w->left_margin_cols);
6608 p->right_margin_cols = make_number (w->right_margin_cols);
6609 p->left_fringe_width = make_number (w->left_fringe_width);
6610 p->right_fringe_width = make_number (w->right_fringe_width);
6611 p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;
6612 p->scroll_bar_width = make_number (w->scroll_bar_width);
6613 p->scroll_bar_height = make_number (w->scroll_bar_height);
6614 p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
6615 p->horizontal_scroll_bar_type = w->horizontal_scroll_bar_type;
6616 p->dedicated = w->dedicated;
6617 p->combination_limit = w->combination_limit;
6618 p->window_parameters = Qnil;
6620 if (!NILP (Vwindow_persistent_parameters))
6622 /* Run cycle detection on Vwindow_persistent_parameters. */
6623 Lisp_Object tortoise, hare;
6625 hare = tortoise = Vwindow_persistent_parameters;
6626 while (CONSP (hare))
6628 hare = XCDR (hare);
6629 if (!CONSP (hare))
6630 break;
6632 hare = XCDR (hare);
6633 tortoise = XCDR (tortoise);
6635 if (EQ (hare, tortoise))
6636 /* Reset Vwindow_persistent_parameters to Qnil. */
6638 Vwindow_persistent_parameters = Qnil;
6639 break;
6643 for (tem = Vwindow_persistent_parameters; CONSP (tem);
6644 tem = XCDR (tem))
6646 pers = XCAR (tem);
6647 /* Save values for persistent window parameters. */
6648 if (CONSP (pers) && !NILP (XCDR (pers)))
6650 par = Fassq (XCAR (pers), w->window_parameters);
6651 if (NILP (par))
6652 /* If the window has no value for the parameter,
6653 make one. */
6654 p->window_parameters = Fcons (Fcons (XCAR (pers), Qnil),
6655 p->window_parameters);
6656 else
6657 /* If the window has a value for the parameter,
6658 save it. */
6659 p->window_parameters = Fcons (Fcons (XCAR (par),
6660 XCDR (par)),
6661 p->window_parameters);
6666 if (BUFFERP (w->contents))
6668 /* Save w's value of point in the window configuration. If w
6669 is the selected window, then get the value of point from
6670 the buffer; pointm is garbage in the selected window. */
6671 if (EQ (window, selected_window))
6672 p->pointm = build_marker (XBUFFER (w->contents),
6673 BUF_PT (XBUFFER (w->contents)),
6674 BUF_PT_BYTE (XBUFFER (w->contents)));
6675 else
6676 p->pointm = Fcopy_marker (w->pointm, Qnil);
6677 p->old_pointm = Fcopy_marker (w->old_pointm, Qnil);
6678 XMARKER (p->pointm)->insertion_type
6679 = !NILP (buffer_local_value /* Don't signal error if void. */
6680 (Qwindow_point_insertion_type, w->contents));
6681 XMARKER (p->old_pointm)->insertion_type
6682 = !NILP (buffer_local_value /* Don't signal error if void. */
6683 (Qwindow_point_insertion_type, w->contents));
6685 p->start = Fcopy_marker (w->start, Qnil);
6686 p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
6688 else
6690 p->pointm = Qnil;
6691 p->old_pointm = Qnil;
6692 p->start = Qnil;
6693 p->start_at_line_beg = Qnil;
6696 p->parent = NILP (w->parent) ? Qnil : XWINDOW (w->parent)->temslot;
6697 p->prev = NILP (w->prev) ? Qnil : XWINDOW (w->prev)->temslot;
6699 if (WINDOWP (w->contents))
6700 i = save_window_save (w->contents, vector, i);
6703 return i;
6706 DEFUN ("current-window-configuration", Fcurrent_window_configuration,
6707 Scurrent_window_configuration, 0, 1, 0,
6708 doc: /* Return an object representing the current window configuration of FRAME.
6709 If FRAME is nil or omitted, use the selected frame.
6710 This describes the number of windows, their sizes and current buffers,
6711 and for each displayed buffer, where display starts, and the position of
6712 point. An exception is made for point in the current buffer:
6713 its value is -not- saved.
6714 This also records the currently selected frame, and FRAME's focus
6715 redirection (see `redirect-frame-focus'). The variable
6716 `window-persistent-parameters' specifies which window parameters are
6717 saved by this function. */)
6718 (Lisp_Object frame)
6720 register Lisp_Object tem;
6721 register int n_windows;
6722 register struct save_window_data *data;
6723 register int i;
6724 struct frame *f = decode_live_frame (frame);
6726 n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
6727 data = ALLOCATE_PSEUDOVECTOR (struct save_window_data, frame_cols,
6728 PVEC_WINDOW_CONFIGURATION);
6730 data->frame_cols = FRAME_COLS (f);
6731 data->frame_lines = FRAME_LINES (f);
6732 data->frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
6733 data->frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
6734 data->frame_text_width = FRAME_TEXT_WIDTH (f);
6735 data->frame_text_height = FRAME_TEXT_HEIGHT (f);
6736 data->frame_menu_bar_height = FRAME_MENU_BAR_HEIGHT (f);
6737 data->frame_tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f);
6738 data->selected_frame = selected_frame;
6739 data->current_window = FRAME_SELECTED_WINDOW (f);
6740 XSETBUFFER (data->current_buffer, current_buffer);
6741 data->minibuf_scroll_window = minibuf_level > 0 ? Vminibuf_scroll_window : Qnil;
6742 data->minibuf_selected_window = minibuf_level > 0 ? minibuf_selected_window : Qnil;
6743 data->root_window = FRAME_ROOT_WINDOW (f);
6744 data->focus_frame = FRAME_FOCUS_FRAME (f);
6745 tem = make_uninit_vector (n_windows);
6746 data->saved_windows = tem;
6747 for (i = 0; i < n_windows; i++)
6748 ASET (tem, i,
6749 Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
6750 save_window_save (FRAME_ROOT_WINDOW (f), XVECTOR (tem), 0);
6751 XSETWINDOW_CONFIGURATION (tem, data);
6752 return (tem);
6755 /* Called after W's margins, fringes or scroll bars was adjusted. */
6757 static void
6758 apply_window_adjustment (struct window *w)
6760 eassert (w);
6761 clear_glyph_matrix (w->current_matrix);
6762 w->window_end_valid = 0;
6763 windows_or_buffers_changed = 30;
6764 wset_redisplay (w);
6765 adjust_frame_glyphs (XFRAME (WINDOW_FRAME (w)));
6769 /***********************************************************************
6770 Marginal Areas
6771 ***********************************************************************/
6773 static struct window *
6774 set_window_margins (struct window *w, Lisp_Object left_width,
6775 Lisp_Object right_width)
6777 int left, right;
6778 int unit = WINDOW_FRAME_COLUMN_WIDTH (w);
6780 left = (NILP (left_width) ? 0
6781 : (CHECK_NATNUM (left_width), XINT (left_width)));
6782 right = (NILP (right_width) ? 0
6783 : (CHECK_NATNUM (right_width), XINT (right_width)));
6785 if (w->left_margin_cols != left || w->right_margin_cols != right)
6787 /* Don't change anything if new margins won't fit. */
6788 if ((WINDOW_PIXEL_WIDTH (w)
6789 - WINDOW_FRINGES_WIDTH (w)
6790 - WINDOW_SCROLL_BAR_AREA_WIDTH (w)
6791 - (left + right) * unit)
6792 >= MIN_SAFE_WINDOW_PIXEL_WIDTH (w))
6794 w->left_margin_cols = left;
6795 w->right_margin_cols = right;
6797 return w;
6799 else
6800 return NULL;
6802 else
6803 return NULL;
6806 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
6807 2, 3, 0,
6808 doc: /* Set width of marginal areas of window WINDOW.
6809 WINDOW must be a live window and defaults to the selected one.
6811 Second arg LEFT-WIDTH specifies the number of character cells to
6812 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6813 does the same for the right marginal area. A nil width parameter
6814 means no margin.
6816 Return t if any margin was actually changed and nil otherwise. */)
6817 (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
6819 struct window *w = set_window_margins (decode_live_window (window),
6820 left_width, right_width);
6821 return w ? (apply_window_adjustment (w), Qt) : Qnil;
6825 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
6826 0, 1, 0,
6827 doc: /* Get width of marginal areas of window WINDOW.
6828 WINDOW must be a live window and defaults to the selected one.
6830 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6831 If a marginal area does not exist, its width will be returned
6832 as nil. */)
6833 (Lisp_Object window)
6835 struct window *w = decode_live_window (window);
6836 return Fcons (w->left_margin_cols
6837 ? make_number (w->left_margin_cols) : Qnil,
6838 w->right_margin_cols
6839 ? make_number (w->right_margin_cols) : Qnil);
6844 /***********************************************************************
6845 Fringes
6846 ***********************************************************************/
6848 static struct window *
6849 set_window_fringes (struct window *w, Lisp_Object left_width,
6850 Lisp_Object right_width, Lisp_Object outside_margins)
6852 int left, right, outside = !NILP (outside_margins);
6854 left = (NILP (left_width) ? -1
6855 : (CHECK_NATNUM (left_width), XINT (left_width)));
6856 right = (NILP (right_width) ? -1
6857 : (CHECK_NATNUM (right_width), XINT (right_width)));
6859 /* Do nothing on a tty or if nothing to actually change. */
6860 if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
6861 && (w->left_fringe_width != left
6862 || w->right_fringe_width != right
6863 || w->fringes_outside_margins != outside))
6865 if (left > 0 || right > 0)
6867 /* Don't change anything if new fringes don't fit. */
6868 if ((WINDOW_PIXEL_WIDTH (w)
6869 - WINDOW_MARGINS_WIDTH (w)
6870 - WINDOW_SCROLL_BAR_AREA_WIDTH (w)
6871 - max (left, 0) - max (right, 0))
6872 < MIN_SAFE_WINDOW_PIXEL_WIDTH (w))
6873 return NULL;
6876 w->left_fringe_width = left;
6877 w->right_fringe_width = right;
6878 w->fringes_outside_margins = outside;
6880 return w;
6882 else
6883 return NULL;
6886 DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
6887 2, 4, 0,
6888 doc: /* Set the fringe widths of window WINDOW.
6889 WINDOW must be a live window and defaults to the selected one.
6891 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6892 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6893 fringe width. If a fringe width arg is nil, that means to use the
6894 frame's default fringe width. Default fringe widths can be set with
6895 the command `set-fringe-style'.
6896 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6897 outside of the display margins. By default, fringes are drawn between
6898 display marginal areas and the text area.
6900 Return t if any fringe was actually changed and nil otherwise. */)
6901 (Lisp_Object window, Lisp_Object left_width,
6902 Lisp_Object right_width, Lisp_Object outside_margins)
6904 struct window *w
6905 = set_window_fringes (decode_live_window (window),
6906 left_width, right_width, outside_margins);
6907 return w ? (apply_window_adjustment (w), Qt) : Qnil;
6911 DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
6912 0, 1, 0,
6913 doc: /* Get width of fringes of window WINDOW.
6914 WINDOW must be a live window and defaults to the selected one.
6916 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6917 (Lisp_Object window)
6919 struct window *w = decode_live_window (window);
6921 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
6922 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
6923 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w) ? Qt : Qnil);
6928 /***********************************************************************
6929 Scroll bars
6930 ***********************************************************************/
6932 static struct window *
6933 set_window_scroll_bars (struct window *w, Lisp_Object width,
6934 Lisp_Object vertical_type, Lisp_Object height,
6935 Lisp_Object horizontal_type)
6937 int iwidth = (NILP (width) ? -1 : (CHECK_NATNUM (width), XINT (width)));
6938 bool changed = 0;
6940 if (iwidth == 0)
6941 vertical_type = Qnil;
6943 if (!(NILP (vertical_type)
6944 || EQ (vertical_type, Qleft)
6945 || EQ (vertical_type, Qright)
6946 || EQ (vertical_type, Qt)))
6947 error ("Invalid type of vertical scroll bar");
6949 if (w->scroll_bar_width != iwidth
6950 || !EQ (w->vertical_scroll_bar_type, vertical_type))
6952 /* Don't change anything if new scroll bar won't fit. */
6953 if ((WINDOW_PIXEL_WIDTH (w)
6954 - WINDOW_MARGINS_WIDTH (w)
6955 - WINDOW_FRINGES_WIDTH (w)
6956 - max (iwidth, 0))
6957 >= MIN_SAFE_WINDOW_PIXEL_WIDTH (w))
6959 w->scroll_bar_width = iwidth;
6960 wset_vertical_scroll_bar_type (w, vertical_type);
6961 changed = 1;
6965 #if USE_HORIZONTAL_SCROLL_BARS
6967 int iheight = (NILP (height) ? -1 : (CHECK_NATNUM (height), XINT (height)));
6969 if (MINI_WINDOW_P (w) || iheight == 0)
6970 horizontal_type = Qnil;
6972 if (!(NILP (horizontal_type)
6973 || EQ (horizontal_type, Qbottom)
6974 || EQ (horizontal_type, Qt)))
6975 error ("Invalid type of horizontal scroll bar");
6977 if (w->scroll_bar_height != iheight
6978 || !EQ (w->horizontal_scroll_bar_type, horizontal_type))
6980 /* Don't change anything if new scroll bar won't fit. */
6981 if ((WINDOW_PIXEL_HEIGHT (w)
6982 - WINDOW_HEADER_LINE_HEIGHT (w)
6983 - WINDOW_MODE_LINE_HEIGHT (w)
6984 - max (iheight, 0))
6985 >= MIN_SAFE_WINDOW_PIXEL_HEIGHT (w))
6987 w->scroll_bar_height = iheight;
6988 wset_horizontal_scroll_bar_type (w, horizontal_type);
6989 changed = 1;
6993 #else
6994 wset_horizontal_scroll_bar_type (w, Qnil);
6995 #endif
6997 return changed ? w : NULL;
7000 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
7001 Sset_window_scroll_bars, 1, 5, 0,
7002 doc: /* Set width and type of scroll bars of window WINDOW.
7003 WINDOW must be a live window and defaults to the selected one.
7005 Second parameter WIDTH specifies the pixel width for the vertical scroll
7006 bar. If WIDTH is nil, use the scroll-bar width of WINDOW's frame.
7007 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
7008 bar: left, right, or nil. If VERTICAL-TYPE is t, this means use the
7009 frame's scroll-bar type.
7011 Fourth parameter HEIGHT specifies the pixel height for the horizontal
7012 scroll bar. If HEIGHT is nil, use the scroll-bar height of WINDOW's
7013 frame. Fifth parameter HORIZONTAL-TYPE specifies the type of the
7014 horizontal scroll bar: nil, bottom, or t. If HORIZONTAL-TYPE is t, this
7015 means to use the frame's horizontal scroll-bar type.
7017 Return t if scroll bars were actually changed and nil otherwise. */)
7018 (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type,
7019 Lisp_Object height, Lisp_Object horizontal_type)
7021 struct window *w
7022 = set_window_scroll_bars (decode_live_window (window),
7023 width, vertical_type, height, horizontal_type);
7024 return w ? (apply_window_adjustment (w), Qt) : Qnil;
7028 DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
7029 0, 1, 0,
7030 doc: /* Get width and type of scroll bars of window WINDOW.
7031 WINDOW must be a live window and defaults to the selected one.
7033 Value is a list of the form (WIDTH COLUMNS VERTICAL-TYPE HEIGHT LINES
7034 HORIZONTAL-TYPE). If WIDTH or HEIGHT is nil or VERTICAL-TYPE or
7035 HORIZONTAL-TYPE is t, the window is using the frame's corresponding
7036 value. */)
7037 (Lisp_Object window)
7039 struct window *w = decode_live_window (window);
7041 return Fcons (((w->scroll_bar_width >= 0)
7042 ? make_number (w->scroll_bar_width)
7043 : Qnil),
7044 list5 (make_number (WINDOW_SCROLL_BAR_COLS (w)),
7045 w->vertical_scroll_bar_type,
7046 ((w->scroll_bar_height >= 0)
7047 ? make_number (w->scroll_bar_height)
7048 : Qnil),
7049 make_number (WINDOW_SCROLL_BAR_LINES (w)),
7050 w->horizontal_scroll_bar_type));
7053 /***********************************************************************
7054 Smooth scrolling
7055 ***********************************************************************/
7057 DEFUN ("window-vscroll", Fwindow_vscroll, Swindow_vscroll, 0, 2, 0,
7058 doc: /* Return the amount by which WINDOW is scrolled vertically.
7059 If WINDOW is omitted or nil, it defaults to the selected window.
7060 Normally, value is a multiple of the canonical character height of WINDOW;
7061 optional second arg PIXELS-P means value is measured in pixels. */)
7062 (Lisp_Object window, Lisp_Object pixels_p)
7064 Lisp_Object result;
7065 struct window *w = decode_live_window (window);
7066 struct frame *f = XFRAME (w->frame);
7068 if (FRAME_WINDOW_P (f))
7069 result = (NILP (pixels_p)
7070 ? FRAME_CANON_Y_FROM_PIXEL_Y (f, -w->vscroll)
7071 : make_number (-w->vscroll));
7072 else
7073 result = make_number (0);
7074 return result;
7078 DEFUN ("set-window-vscroll", Fset_window_vscroll, Sset_window_vscroll,
7079 2, 3, 0,
7080 doc: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
7081 WINDOW nil means use the selected window. Normally, VSCROLL is a
7082 non-negative multiple of the canonical character height of WINDOW;
7083 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
7084 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
7085 corresponds to an integral number of pixels. The return value is the
7086 result of this rounding.
7087 If PIXELS-P is non-nil, the return value is VSCROLL. */)
7088 (Lisp_Object window, Lisp_Object vscroll, Lisp_Object pixels_p)
7090 struct window *w = decode_live_window (window);
7091 struct frame *f = XFRAME (w->frame);
7093 CHECK_NUMBER_OR_FLOAT (vscroll);
7095 if (FRAME_WINDOW_P (f))
7097 int old_dy = w->vscroll;
7099 w->vscroll = - (NILP (pixels_p)
7100 ? FRAME_LINE_HEIGHT (f) * XFLOATINT (vscroll)
7101 : XFLOATINT (vscroll));
7102 w->vscroll = min (w->vscroll, 0);
7104 if (w->vscroll != old_dy)
7106 /* Adjust glyph matrix of the frame if the virtual display
7107 area becomes larger than before. */
7108 if (w->vscroll < 0 && w->vscroll < old_dy)
7109 adjust_frame_glyphs (f);
7111 /* Prevent redisplay shortcuts. */
7112 XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
7116 return Fwindow_vscroll (window, pixels_p);
7120 /* Call FN for all leaf windows on frame F. FN is called with the
7121 first argument being a pointer to the leaf window, and with
7122 additional argument USER_DATA. Stops when FN returns 0. */
7124 static void
7125 foreach_window (struct frame *f, int (*fn) (struct window *, void *),
7126 void *user_data)
7128 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
7129 if (WINDOWP (FRAME_ROOT_WINDOW (f)))
7130 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f)), fn, user_data);
7134 /* Helper function for foreach_window. Call FN for all leaf windows
7135 reachable from W. FN is called with the first argument being a
7136 pointer to the leaf window, and with additional argument USER_DATA.
7137 Stop when FN returns 0. Value is 0 if stopped by FN. */
7139 static int
7140 foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *user_data)
7142 int cont;
7144 for (cont = 1; w && cont;)
7146 if (WINDOWP (w->contents))
7147 cont = foreach_window_1 (XWINDOW (w->contents), fn, user_data);
7148 else
7149 cont = fn (w, user_data);
7151 w = NILP (w->next) ? 0 : XWINDOW (w->next);
7154 return cont;
7157 /***********************************************************************
7158 Initialization
7159 ***********************************************************************/
7161 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
7162 describe the same state of affairs. This is used by Fequal.
7164 IGNORE_POSITIONS means ignore non-matching scroll positions
7165 and the like.
7167 This ignores a couple of things like the dedication status of
7168 window, combination_limit and the like. This might have to be
7169 fixed. */
7171 bool
7172 compare_window_configurations (Lisp_Object configuration1,
7173 Lisp_Object configuration2,
7174 bool ignore_positions)
7176 register struct save_window_data *d1, *d2;
7177 struct Lisp_Vector *sws1, *sws2;
7178 ptrdiff_t i;
7180 CHECK_WINDOW_CONFIGURATION (configuration1);
7181 CHECK_WINDOW_CONFIGURATION (configuration2);
7183 d1 = (struct save_window_data *) XVECTOR (configuration1);
7184 d2 = (struct save_window_data *) XVECTOR (configuration2);
7185 sws1 = XVECTOR (d1->saved_windows);
7186 sws2 = XVECTOR (d2->saved_windows);
7188 /* Frame settings must match. */
7189 if (d1->frame_cols != d2->frame_cols
7190 || d1->frame_lines != d2->frame_lines
7191 || d1->frame_menu_bar_lines != d2->frame_menu_bar_lines
7192 || !EQ (d1->selected_frame, d2->selected_frame)
7193 || !EQ (d1->current_buffer, d2->current_buffer)
7194 || (!ignore_positions
7195 && (!EQ (d1->minibuf_scroll_window, d2->minibuf_scroll_window)
7196 || !EQ (d1->minibuf_selected_window, d2->minibuf_selected_window)))
7197 || !EQ (d1->focus_frame, d2->focus_frame)
7198 /* Verify that the two configurations have the same number of windows. */
7199 || sws1->header.size != sws2->header.size)
7200 return 0;
7202 for (i = 0; i < sws1->header.size; i++)
7204 struct saved_window *sw1, *sw2;
7206 sw1 = SAVED_WINDOW_N (sws1, i);
7207 sw2 = SAVED_WINDOW_N (sws2, i);
7209 if (
7210 /* The "current" windows in the two configurations must
7211 correspond to each other. */
7212 EQ (d1->current_window, sw1->window)
7213 != EQ (d2->current_window, sw2->window)
7214 /* Windows' buffers must match. */
7215 || !EQ (sw1->buffer, sw2->buffer)
7216 || !EQ (sw1->pixel_left, sw2->pixel_left)
7217 || !EQ (sw1->pixel_top, sw2->pixel_top)
7218 || !EQ (sw1->pixel_height, sw2->pixel_height)
7219 || !EQ (sw1->pixel_width, sw2->pixel_width)
7220 || !EQ (sw1->left_col, sw2->left_col)
7221 || !EQ (sw1->top_line, sw2->top_line)
7222 || !EQ (sw1->total_cols, sw2->total_cols)
7223 || !EQ (sw1->total_lines, sw2->total_lines)
7224 || !EQ (sw1->display_table, sw2->display_table)
7225 /* The next two disjuncts check the window structure for
7226 equality. */
7227 || !EQ (sw1->parent, sw2->parent)
7228 || !EQ (sw1->prev, sw2->prev)
7229 || (!ignore_positions
7230 && (!EQ (sw1->hscroll, sw2->hscroll)
7231 || !EQ (sw1->min_hscroll, sw2->min_hscroll)
7232 || !EQ (sw1->start_at_line_beg, sw2->start_at_line_beg)
7233 || NILP (Fequal (sw1->start, sw2->start))
7234 || NILP (Fequal (sw1->pointm, sw2->pointm))))
7235 || !EQ (sw1->left_margin_cols, sw2->left_margin_cols)
7236 || !EQ (sw1->right_margin_cols, sw2->right_margin_cols)
7237 || !EQ (sw1->left_fringe_width, sw2->left_fringe_width)
7238 || !EQ (sw1->right_fringe_width, sw2->right_fringe_width)
7239 || !EQ (sw1->fringes_outside_margins, sw2->fringes_outside_margins)
7240 || !EQ (sw1->scroll_bar_width, sw2->scroll_bar_width)
7241 || !EQ (sw1->scroll_bar_height, sw2->scroll_bar_height)
7242 || !EQ (sw1->vertical_scroll_bar_type, sw2->vertical_scroll_bar_type)
7243 || !EQ (sw1->horizontal_scroll_bar_type, sw2->horizontal_scroll_bar_type))
7244 return 0;
7247 return 1;
7250 DEFUN ("compare-window-configurations", Fcompare_window_configurations,
7251 Scompare_window_configurations, 2, 2, 0,
7252 doc: /* Compare two window configurations as regards the structure of windows.
7253 This function ignores details such as the values of point
7254 and scrolling positions. */)
7255 (Lisp_Object x, Lisp_Object y)
7257 if (compare_window_configurations (x, y, 1))
7258 return Qt;
7259 return Qnil;
7262 void
7263 init_window_once (void)
7265 struct frame *f = make_initial_frame ();
7266 XSETFRAME (selected_frame, f);
7267 Vterminal_frame = selected_frame;
7268 minibuf_window = f->minibuffer_window;
7269 selected_window = f->selected_window;
7272 void
7273 init_window (void)
7275 Vwindow_list = Qnil;
7278 void
7279 syms_of_window (void)
7281 DEFSYM (Qscroll_up, "scroll-up");
7282 DEFSYM (Qscroll_down, "scroll-down");
7283 DEFSYM (Qscroll_command, "scroll-command");
7285 Fput (Qscroll_up, Qscroll_command, Qt);
7286 Fput (Qscroll_down, Qscroll_command, Qt);
7288 DEFSYM (Qwindow_configuration_change_hook, "window-configuration-change-hook");
7289 DEFSYM (Qwindowp, "windowp");
7290 DEFSYM (Qwindow_configuration_p, "window-configuration-p");
7291 DEFSYM (Qwindow_live_p, "window-live-p");
7292 DEFSYM (Qwindow_valid_p, "window-valid-p");
7293 DEFSYM (Qwindow_deletable_p, "window-deletable-p");
7294 DEFSYM (Qdelete_window, "delete-window");
7295 DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");
7296 DEFSYM (Qwindow_resize_root_window_vertically, "window--resize-root-window-vertically");
7297 DEFSYM (Qwindow_sanitize_window_sizes, "window--sanitize-window-sizes");
7298 DEFSYM (Qwindow_pixel_to_total, "window--pixel-to-total");
7299 DEFSYM (Qsafe, "safe");
7300 DEFSYM (Qdisplay_buffer, "display-buffer");
7301 DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
7302 DEFSYM (Qrecord_window_buffer, "record-window-buffer");
7303 DEFSYM (Qget_mru_window, "get-mru-window");
7304 DEFSYM (Qwindow_size, "window-size");
7305 DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
7306 DEFSYM (Qabove, "above");
7307 DEFSYM (Qbelow, "below");
7308 DEFSYM (Qclone_of, "clone-of");
7309 DEFSYM (Qfloor, "floor");
7310 DEFSYM (Qceiling, "ceiling");
7312 staticpro (&Vwindow_list);
7314 minibuf_selected_window = Qnil;
7315 staticpro (&minibuf_selected_window);
7317 window_scroll_pixel_based_preserve_x = -1;
7318 window_scroll_pixel_based_preserve_y = -1;
7319 window_scroll_preserve_hpos = -1;
7320 window_scroll_preserve_vpos = -1;
7322 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function,
7323 doc: /* Non-nil means call as function to display a help buffer.
7324 The function is called with one argument, the buffer to be displayed.
7325 Used by `with-output-to-temp-buffer'.
7326 If this function is used, then it must do the entire job of showing
7327 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7328 Vtemp_buffer_show_function = Qnil;
7330 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window,
7331 doc: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7332 Vminibuf_scroll_window = Qnil;
7334 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows,
7335 doc: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7336 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7337 is displayed in the `mode-line' face. */);
7338 mode_line_in_non_selected_windows = 1;
7340 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer,
7341 doc: /* If this is a live buffer, \\[scroll-other-window] should scroll its window. */);
7342 Vother_window_scroll_buffer = Qnil;
7344 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p,
7345 doc: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7346 auto_window_vscroll_p = 1;
7348 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines,
7349 doc: /* Number of lines of continuity when scrolling by screenfuls. */);
7350 next_screen_context_lines = 2;
7352 DEFVAR_LISP ("scroll-preserve-screen-position",
7353 Vscroll_preserve_screen_position,
7354 doc: /* Controls if scroll commands move point to keep its screen position unchanged.
7355 A value of nil means point does not keep its screen position except
7356 at the scroll margin or window boundary respectively.
7357 A value of t means point keeps its screen position if the scroll
7358 command moved it vertically out of the window, e.g. when scrolling
7359 by full screens.
7360 Any other value means point always keeps its screen position.
7361 Scroll commands should have the `scroll-command' property
7362 on their symbols to be controlled by this variable. */);
7363 Vscroll_preserve_screen_position = Qnil;
7365 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type,
7366 doc: /* Type of marker to use for `window-point'. */);
7367 Vwindow_point_insertion_type = Qnil;
7368 DEFSYM (Qwindow_point_insertion_type, "window_point_insertion_type");
7370 DEFVAR_LISP ("window-configuration-change-hook",
7371 Vwindow_configuration_change_hook,
7372 doc: /* Functions to call when window configuration changes.
7373 The buffer-local part is run once per window, with the relevant window
7374 selected; while the global part is run only once for the modified frame,
7375 with the relevant frame selected. */);
7376 Vwindow_configuration_change_hook = Qnil;
7378 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay,
7379 doc: /* Non-nil means `recenter' redraws entire frame.
7380 If this option is non-nil, then the `recenter' command with a nil
7381 argument will redraw the entire frame; the special value `tty' causes
7382 the frame to be redrawn only if it is a tty frame. */);
7383 Vrecenter_redisplay = Qtty;
7385 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize,
7386 doc: /* If t, resize window combinations proportionally.
7387 If this variable is nil, splitting a window gets the entire screen space
7388 for displaying the new window from the window to split. Deleting and
7389 resizing a window preferably resizes one adjacent window only.
7391 If this variable is t, splitting a window tries to get the space
7392 proportionally from all windows in the same combination. This also
7393 allows to split a window that is otherwise too small or of fixed size.
7394 Resizing and deleting a window proportionally resize all windows in the
7395 same combination.
7397 Other values are reserved for future use.
7399 This variable takes no effect if the variable `window-combination-limit' is
7400 non-nil. */);
7401 Vwindow_combination_resize = Qnil;
7403 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,
7404 doc: /* If non-nil, splitting a window makes a new parent window.
7405 The following values are recognized:
7407 nil means splitting a window will create a new parent window only if the
7408 window has no parent window or the window shall become part of a
7409 combination orthogonal to the one it is part of.
7411 `window-size' means that splitting a window for displaying a buffer
7412 makes a new parent window provided `display-buffer' is supposed to
7413 explicitly set the window's size due to the presence of a
7414 `window-height' or `window-width' entry in the alist used by
7415 `display-buffer'. Otherwise, this value is handled like nil.
7417 `temp-buffer' means that splitting a window for displaying a temporary
7418 buffer always makes a new parent window. Otherwise, this value is
7419 handled like nil.
7421 `display-buffer' means that splitting a window for displaying a buffer
7422 always makes a new parent window. Since temporary buffers are
7423 displayed by the function `display-buffer', this value is stronger
7424 than `temp-buffer'. Splitting a window for other purpose makes a
7425 new parent window only if needed.
7427 t means that splitting a window always creates a new parent window. If
7428 all splits behave this way, each frame's window tree is a binary
7429 tree and every window but the frame's root window has exactly one
7430 sibling.
7432 Other values are reserved for future use. */);
7433 Vwindow_combination_limit = Qwindow_size;
7435 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters,
7436 doc: /* Alist of persistent window parameters.
7437 This alist specifies which window parameters shall get saved by
7438 `current-window-configuration' and `window-state-get' and subsequently
7439 restored to their previous values by `set-window-configuration' and
7440 `window-state-put'.
7442 The car of each entry of this alist is the symbol specifying the
7443 parameter. The cdr is one of the following:
7445 nil means the parameter is neither saved by `window-state-get' nor by
7446 `current-window-configuration'.
7448 t means the parameter is saved by `current-window-configuration' and,
7449 provided its WRITABLE argument is nil, by `window-state-get'.
7451 The symbol `writable' means the parameter is saved unconditionally by
7452 both `current-window-configuration' and `window-state-get'. Do not use
7453 this value for parameters without read syntax (like windows or frames).
7455 Parameters not saved by `current-window-configuration' or
7456 `window-state-get' are left alone by `set-window-configuration'
7457 respectively are not installed by `window-state-put'. */);
7458 Vwindow_persistent_parameters = list1 (Fcons (Qclone_of, Qt));
7460 DEFVAR_BOOL ("window-resize-pixelwise", window_resize_pixelwise,
7461 doc: /* Non-nil means resize windows pixelwise.
7462 This currently affects the functions: `split-window', `maximize-window',
7463 `minimize-window', `fit-window-to-buffer' and `fit-frame-to-buffer', and
7464 all functions that symmetrically resize a parent window.
7466 Note that when a frame's pixel size is not a multiple of the
7467 frame's character size, at least one window may get resized
7468 pixelwise even if this option is nil. */);
7469 window_resize_pixelwise = 0;
7471 defsubr (&Sselected_window);
7472 defsubr (&Sminibuffer_window);
7473 defsubr (&Swindow_minibuffer_p);
7474 defsubr (&Swindowp);
7475 defsubr (&Swindow_valid_p);
7476 defsubr (&Swindow_live_p);
7477 defsubr (&Swindow_frame);
7478 defsubr (&Sframe_root_window);
7479 defsubr (&Sframe_first_window);
7480 defsubr (&Sframe_selected_window);
7481 defsubr (&Sset_frame_selected_window);
7482 defsubr (&Spos_visible_in_window_p);
7483 defsubr (&Swindow_line_height);
7484 defsubr (&Swindow_buffer);
7485 defsubr (&Swindow_parent);
7486 defsubr (&Swindow_top_child);
7487 defsubr (&Swindow_left_child);
7488 defsubr (&Swindow_next_sibling);
7489 defsubr (&Swindow_prev_sibling);
7490 defsubr (&Swindow_combination_limit);
7491 defsubr (&Sset_window_combination_limit);
7492 defsubr (&Swindow_use_time);
7493 defsubr (&Swindow_pixel_width);
7494 defsubr (&Swindow_pixel_height);
7495 defsubr (&Swindow_total_width);
7496 defsubr (&Swindow_total_height);
7497 defsubr (&Swindow_normal_size);
7498 defsubr (&Swindow_new_pixel);
7499 defsubr (&Swindow_new_total);
7500 defsubr (&Swindow_new_normal);
7501 defsubr (&Swindow_pixel_left);
7502 defsubr (&Swindow_pixel_top);
7503 defsubr (&Swindow_left_column);
7504 defsubr (&Swindow_top_line);
7505 defsubr (&Sset_window_new_pixel);
7506 defsubr (&Sset_window_new_total);
7507 defsubr (&Sset_window_new_normal);
7508 defsubr (&Swindow_resize_apply);
7509 defsubr (&Swindow_resize_apply_total);
7510 defsubr (&Swindow_body_height);
7511 defsubr (&Swindow_body_width);
7512 defsubr (&Swindow_hscroll);
7513 defsubr (&Sset_window_hscroll);
7514 defsubr (&Swindow_redisplay_end_trigger);
7515 defsubr (&Sset_window_redisplay_end_trigger);
7516 defsubr (&Swindow_edges);
7517 defsubr (&Swindow_pixel_edges);
7518 defsubr (&Swindow_absolute_pixel_edges);
7519 defsubr (&Swindow_mode_line_height);
7520 defsubr (&Swindow_header_line_height);
7521 defsubr (&Swindow_right_divider_width);
7522 defsubr (&Swindow_bottom_divider_width);
7523 defsubr (&Swindow_scroll_bar_width);
7524 defsubr (&Swindow_scroll_bar_height);
7525 defsubr (&Swindow_inside_edges);
7526 defsubr (&Swindow_inside_pixel_edges);
7527 defsubr (&Swindow_inside_absolute_pixel_edges);
7528 defsubr (&Scoordinates_in_window_p);
7529 defsubr (&Swindow_at);
7530 defsubr (&Swindow_point);
7531 defsubr (&Swindow_old_point);
7532 defsubr (&Swindow_start);
7533 defsubr (&Swindow_end);
7534 defsubr (&Sset_window_point);
7535 defsubr (&Sset_window_start);
7536 defsubr (&Swindow_dedicated_p);
7537 defsubr (&Sset_window_dedicated_p);
7538 defsubr (&Swindow_display_table);
7539 defsubr (&Sset_window_display_table);
7540 defsubr (&Snext_window);
7541 defsubr (&Sprevious_window);
7542 defsubr (&Sget_buffer_window);
7543 defsubr (&Sdelete_other_windows_internal);
7544 defsubr (&Sdelete_window_internal);
7545 defsubr (&Sresize_mini_window_internal);
7546 defsubr (&Sset_window_buffer);
7547 defsubr (&Srun_window_configuration_change_hook);
7548 defsubr (&Srun_window_scroll_functions);
7549 defsubr (&Sselect_window);
7550 defsubr (&Sforce_window_update);
7551 defsubr (&Ssplit_window_internal);
7552 defsubr (&Sscroll_up);
7553 defsubr (&Sscroll_down);
7554 defsubr (&Sscroll_left);
7555 defsubr (&Sscroll_right);
7556 defsubr (&Sother_window_for_scrolling);
7557 defsubr (&Sscroll_other_window);
7558 defsubr (&Sminibuffer_selected_window);
7559 defsubr (&Srecenter);
7560 defsubr (&Swindow_text_width);
7561 defsubr (&Swindow_text_height);
7562 defsubr (&Smove_to_window_line);
7563 defsubr (&Swindow_configuration_p);
7564 defsubr (&Swindow_configuration_frame);
7565 defsubr (&Sset_window_configuration);
7566 defsubr (&Scurrent_window_configuration);
7567 defsubr (&Sset_window_margins);
7568 defsubr (&Swindow_margins);
7569 defsubr (&Sset_window_fringes);
7570 defsubr (&Swindow_fringes);
7571 defsubr (&Sset_window_scroll_bars);
7572 defsubr (&Swindow_scroll_bars);
7573 defsubr (&Swindow_vscroll);
7574 defsubr (&Sset_window_vscroll);
7575 defsubr (&Scompare_window_configurations);
7576 defsubr (&Swindow_list);
7577 defsubr (&Swindow_list_1);
7578 defsubr (&Swindow_prev_buffers);
7579 defsubr (&Sset_window_prev_buffers);
7580 defsubr (&Swindow_next_buffers);
7581 defsubr (&Sset_window_next_buffers);
7582 defsubr (&Swindow_parameters);
7583 defsubr (&Swindow_parameter);
7584 defsubr (&Sset_window_parameter);
7587 void
7588 keys_of_window (void)
7590 initial_define_key (control_x_map, '<', "scroll-left");
7591 initial_define_key (control_x_map, '>', "scroll-right");
7593 initial_define_key (global_map, Ctl ('V'), "scroll-up-command");
7594 initial_define_key (meta_map, Ctl ('V'), "scroll-other-window");
7595 initial_define_key (meta_map, 'v', "scroll-down-command");