1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2013 Free Software
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/>. */
23 #define WINDOW_INLINE EXTERN_INLINE
28 #include "character.h"
38 #include "dispextern.h"
39 #include "blockinput.h"
40 #include "intervals.h"
41 #include "termhooks.h" /* For FRAME_TERMINAL. */
45 #endif /* HAVE_X_WINDOWS */
56 Lisp_Object Qwindowp
, Qwindow_live_p
;
57 static Lisp_Object Qwindow_valid_p
;
58 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
59 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
60 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
61 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
62 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
63 static Lisp_Object Qsafe
, Qabove
, Qbelow
, Qwindow_size
, Qclone_of
;
65 static int displayed_window_lines (struct window
*);
66 static int count_windows (struct window
*);
67 static int get_leaf_windows (struct window
*, struct window
**, int);
68 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
69 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
70 static void window_scroll_line_based (Lisp_Object
, int, int, int);
71 static int freeze_window_start (struct window
*, void *);
72 static Lisp_Object
window_list (void);
73 static int add_window_to_list (struct window
*, void *);
74 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
80 static void foreach_window (struct frame
*,
81 int (* fn
) (struct window
*, void *),
83 static int foreach_window_1 (struct window
*,
84 int (* fn
) (struct window
*, void *),
86 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
87 static int window_resize_check (struct window
*, bool);
88 static void window_resize_apply (struct window
*, bool);
89 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
90 static void select_window_1 (Lisp_Object
, bool);
92 /* This is the window in which the terminal's cursor should
93 be left when nothing is being done with it. This must
94 always be a leaf window, and its buffer is selected by
95 the top level editing loop at the end of each command.
97 This value is always the same as
98 FRAME_SELECTED_WINDOW (selected_frame). */
99 Lisp_Object selected_window
;
101 /* A list of all windows for use by next_window and Fwindow_list.
102 Functions creating or deleting windows should invalidate this cache
103 by setting it to nil. */
104 Lisp_Object Vwindow_list
;
106 /* The mini-buffer window of the selected frame.
107 Note that you cannot test for mini-bufferness of an arbitrary window
108 by comparing against this; but you can test for mini-bufferness of
109 the selected window. */
110 Lisp_Object minibuf_window
;
112 /* Non-nil means it is the window whose mode line should be
113 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Hook run at end of temp_output_buffer_show. */
117 static Lisp_Object Qtemp_buffer_show_hook
;
119 /* Nonzero after init_window_once has finished. */
120 static int window_initialized
;
122 /* Hook to run when window config changes. */
123 static Lisp_Object Qwindow_configuration_change_hook
;
125 /* Used by the function window_scroll_pixel_based */
126 static int window_scroll_pixel_based_preserve_x
;
127 static int window_scroll_pixel_based_preserve_y
;
129 /* Same for window_scroll_line_based. */
130 static EMACS_INT window_scroll_preserve_hpos
;
131 static EMACS_INT window_scroll_preserve_vpos
;
133 /* These setters are used only in this file, so they can be private. */
135 wset_combination_limit (struct window
*w
, Lisp_Object val
)
137 w
->combination_limit
= val
;
140 wset_dedicated (struct window
*w
, Lisp_Object val
)
145 wset_display_table (struct window
*w
, Lisp_Object val
)
147 w
->display_table
= val
;
150 wset_hchild (struct window
*w
, Lisp_Object val
)
155 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
157 w
->left_fringe_width
= val
;
160 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
162 w
->left_margin_cols
= val
;
165 wset_new_normal (struct window
*w
, Lisp_Object val
)
170 wset_new_total (struct window
*w
, Lisp_Object val
)
175 wset_normal_cols (struct window
*w
, Lisp_Object val
)
177 w
->normal_cols
= val
;
180 wset_normal_lines (struct window
*w
, Lisp_Object val
)
182 w
->normal_lines
= val
;
185 wset_parent (struct window
*w
, Lisp_Object val
)
190 wset_pointm (struct window
*w
, Lisp_Object val
)
195 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
197 w
->right_fringe_width
= val
;
200 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
202 w
->right_margin_cols
= val
;
205 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
207 w
->scroll_bar_width
= val
;
210 wset_start (struct window
*w
, Lisp_Object val
)
215 wset_temslot (struct window
*w
, Lisp_Object val
)
220 wset_vchild (struct window
*w
, Lisp_Object val
)
225 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
227 w
->vertical_scroll_bar_type
= val
;
230 wset_window_parameters (struct window
*w
, Lisp_Object val
)
232 w
->window_parameters
= val
;
236 decode_live_window (register Lisp_Object window
)
239 return XWINDOW (selected_window
);
241 CHECK_LIVE_WINDOW (window
);
242 return XWINDOW (window
);
246 decode_any_window (register Lisp_Object window
)
251 return XWINDOW (selected_window
);
253 CHECK_WINDOW (window
);
254 w
= XWINDOW (window
);
258 static struct window
*
259 decode_valid_window (register Lisp_Object window
)
264 return XWINDOW (selected_window
);
266 CHECK_VALID_WINDOW (window
);
267 w
= XWINDOW (window
);
271 /* Called when W's buffer slot is changed. ARG -1 means that W is about to
272 cease its buffer, and 1 means that W is about to set up the new one. */
275 adjust_window_count (struct window
*w
, int arg
)
277 eassert (eabs (arg
) == 1);
278 if (BUFFERP (w
->buffer
))
280 struct buffer
*b
= XBUFFER (w
->buffer
);
284 b
->window_count
+= arg
;
285 eassert (b
->window_count
>= 0);
286 /* These should be recalculated by redisplay code. */
287 w
->window_end_valid
= 0;
288 w
->base_line_pos
= 0;
292 /* Set W's buffer slot to VAL and recompute number
293 of windows showing VAL if it is a buffer. */
296 wset_buffer (struct window
*w
, Lisp_Object val
)
298 adjust_window_count (w
, -1);
300 adjust_window_count (w
, 1);
303 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
304 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
307 return WINDOWP (object
) ? Qt
: Qnil
;
310 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
311 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
312 A valid window is either a window that displays a buffer or an internal
313 window. Deleted windows are not live. */)
316 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
319 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
320 doc
: /* Return t if OBJECT is a live window and nil otherwise.
321 A live window is a window that displays a buffer.
322 Internal windows and deleted windows are not live. */)
325 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
328 /* Frames and windows. */
329 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
330 doc
: /* Return the frame that window WINDOW is on.
331 WINDOW must be a valid window and defaults to the selected one. */)
334 return decode_valid_window (window
)->frame
;
337 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
338 doc
: /* Return the root window of FRAME-OR-WINDOW.
339 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
340 With a frame argument, return that frame's root window.
341 With a window argument, return the root window of that window's frame. */)
342 (Lisp_Object frame_or_window
)
346 if (NILP (frame_or_window
))
347 window
= SELECTED_FRAME ()->root_window
;
348 else if (WINDOW_VALID_P (frame_or_window
))
349 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
352 CHECK_LIVE_FRAME (frame_or_window
);
353 window
= XFRAME (frame_or_window
)->root_window
;
359 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
360 doc
: /* Return the minibuffer window for frame FRAME.
361 If FRAME is omitted or nil, it defaults to the selected frame. */)
364 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
367 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
368 Swindow_minibuffer_p
, 0, 1, 0,
369 doc
: /* Return non-nil if WINDOW is a minibuffer window.
370 WINDOW must be a valid window and defaults to the selected one. */)
373 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
376 /* Don't move this to window.el - this must be a safe routine. */
377 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
378 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
379 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
380 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
381 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
382 the first window of that frame. */)
383 (Lisp_Object frame_or_window
)
387 if (NILP (frame_or_window
))
388 window
= SELECTED_FRAME ()->root_window
;
389 else if (WINDOW_VALID_P (frame_or_window
))
390 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
393 CHECK_LIVE_FRAME (frame_or_window
);
394 window
= XFRAME (frame_or_window
)->root_window
;
397 while (NILP (XWINDOW (window
)->buffer
))
399 if (! NILP (XWINDOW (window
)->hchild
))
400 window
= XWINDOW (window
)->hchild
;
401 else if (! NILP (XWINDOW (window
)->vchild
))
402 window
= XWINDOW (window
)->vchild
;
410 DEFUN ("frame-selected-window", Fframe_selected_window
,
411 Sframe_selected_window
, 0, 1, 0,
412 doc
: /* Return the selected window of FRAME-OR-WINDOW.
413 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
414 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
415 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
416 return the selected window of that frame. */)
417 (Lisp_Object frame_or_window
)
421 if (NILP (frame_or_window
))
422 window
= SELECTED_FRAME ()->selected_window
;
423 else if (WINDOW_VALID_P (frame_or_window
))
424 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
427 CHECK_LIVE_FRAME (frame_or_window
);
428 window
= XFRAME (frame_or_window
)->selected_window
;
434 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
435 Sset_frame_selected_window
, 2, 3, 0,
436 doc
: /* Set selected window of FRAME to WINDOW.
437 FRAME must be a live frame and defaults to the selected one. If FRAME
438 is the selected frame, this makes WINDOW the selected window. Optional
439 argument NORECORD non-nil means to neither change the order of recently
440 selected windows nor the buffer list. WINDOW must denote a live window.
442 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
445 frame
= selected_frame
;
447 CHECK_LIVE_FRAME (frame
);
448 CHECK_LIVE_WINDOW (window
);
450 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
451 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
453 if (EQ (frame
, selected_frame
))
454 return Fselect_window (window
, norecord
);
457 fset_selected_window (XFRAME (frame
), window
);
462 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
463 doc
: /* Return the selected window.
464 The selected window is the window in which the standard cursor for
465 selected windows appears and to which many commands apply. */)
468 return selected_window
;
471 int window_select_count
;
473 /* If select_window is called with inhibit_point_swap non-zero it will
474 not store point of the old selected window's buffer back into that
475 window's pointm slot. This is needed by Fset_window_configuration to
476 avoid that the display routine is called with selected_window set to
477 Qnil causing a subsequent crash. */
479 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
481 register struct window
*w
;
484 CHECK_LIVE_WINDOW (window
);
486 w
= XWINDOW (window
);
487 w
->frozen_window_start_p
= 0;
491 w
->use_time
= ++window_select_count
;
492 record_buffer (w
->buffer
);
495 /* Make the selected window's buffer current. */
496 Fset_buffer (w
->buffer
);
498 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
501 sf
= SELECTED_FRAME ();
502 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
504 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
505 /* Use this rather than Fhandle_switch_frame
506 so that FRAME_FOCUS_FRAME is moved appropriately as we
507 move around in the state where a minibuffer in a separate
509 Fselect_frame (WINDOW_FRAME (w
), norecord
);
510 /* Fselect_frame called us back so we've done all the work already. */
511 eassert (EQ (window
, selected_window
));
515 fset_selected_window (sf
, window
);
517 select_window_1 (window
, inhibit_point_swap
);
519 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
520 windows_or_buffers_changed
++;
524 /* Select window with a minimum of fuss, i.e. don't record the change anywhere
525 (not even for redisplay's benefit), and assume that the window's frame is
528 select_window_1 (Lisp_Object window
, bool inhibit_point_swap
)
530 /* Store the old selected window's buffer's point in pointm of the old
531 selected window. It belongs to that window, and when the window is
532 not selected, must be in the window. */
533 if (!inhibit_point_swap
)
535 struct window
*ow
= XWINDOW (selected_window
);
536 if (! NILP (ow
->buffer
))
537 set_marker_both (ow
->pointm
, ow
->buffer
,
538 BUF_PT (XBUFFER (ow
->buffer
)),
539 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
542 selected_window
= window
;
544 /* Go to the point recorded in the window.
545 This is important when the buffer is in more
546 than one window. It also matters when
547 redisplay_window has altered point after scrolling,
548 because it makes the change only in the window. */
550 register ptrdiff_t new_point
= marker_position (XWINDOW (window
)->pointm
);
551 if (new_point
< BEGV
)
553 else if (new_point
> ZV
)
560 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
561 doc
: /* Select WINDOW which must be a live window.
562 Also make WINDOW's frame the selected frame and WINDOW that frame's
563 selected window. In addition, make WINDOW's buffer current and set that
564 buffer's value of `point' to the value of WINDOW's `window-point'.
567 Optional second arg NORECORD non-nil means do not put this buffer at the
568 front of the buffer list and do not make this window the most recently
571 Note that the main editor command loop sets the current buffer to the
572 buffer of the selected window before each command. */)
573 (register Lisp_Object window
, Lisp_Object norecord
)
575 return select_window (window
, norecord
, 0);
578 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
579 doc
: /* Return the buffer displayed in window WINDOW.
580 If WINDOW is omitted or nil, it defaults to the selected window.
581 Return nil for an internal window or a deleted window. */)
584 return decode_any_window (window
)->buffer
;
587 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
588 doc
: /* Return the parent window of window WINDOW.
589 WINDOW must be a valid window and defaults to the selected one.
590 Return nil for a window with no parent (e.g. a root window). */)
593 return decode_valid_window (window
)->parent
;
596 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
597 doc
: /* Return the topmost child window of window WINDOW.
598 WINDOW must be a valid window and defaults to the selected one.
599 Return nil if WINDOW is a live window (live windows have no children).
600 Return nil if WINDOW is an internal window whose children form a
601 horizontal combination. */)
604 return decode_valid_window (window
)->vchild
;
607 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
608 doc
: /* Return the leftmost child window of window WINDOW.
609 WINDOW must be a valid window and defaults to the selected one.
610 Return nil if WINDOW is a live window (live windows have no children).
611 Return nil if WINDOW is an internal window whose children form a
612 vertical combination. */)
615 return decode_valid_window (window
)->hchild
;
618 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
619 doc
: /* Return the next sibling window of window WINDOW.
620 WINDOW must be a valid window and defaults to the selected one.
621 Return nil if WINDOW has no next sibling. */)
624 return decode_valid_window (window
)->next
;
627 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
628 doc
: /* Return the previous sibling window of window WINDOW.
629 WINDOW must be a valid window and defaults to the selected one.
630 Return nil if WINDOW has no previous sibling. */)
633 return decode_valid_window (window
)->prev
;
636 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
637 doc
: /* Return combination limit of window WINDOW.
638 WINDOW must be a valid window used in horizontal or vertical combination.
639 If the return value is nil, child windows of WINDOW can be recombined with
640 WINDOW's siblings. A return value of t means that child windows of
641 WINDOW are never \(re-)combined with WINDOW's siblings. */)
646 CHECK_VALID_WINDOW (window
);
647 w
= XWINDOW (window
);
648 if (!NILP (w
->buffer
))
649 error ("Combination limit is meaningful for internal windows only");
650 return XWINDOW (window
)->combination_limit
;
653 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
654 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
655 WINDOW must be a valid window used in horizontal or vertical combination.
656 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
657 siblings. LIMIT t means that child windows of WINDOW are never
658 \(re-)combined with WINDOW's siblings. Other values are reserved for
660 (Lisp_Object window
, Lisp_Object limit
)
664 CHECK_VALID_WINDOW (window
);
665 w
= XWINDOW (window
);
666 if (!NILP (w
->buffer
))
667 error ("Combination limit is meaningful for internal windows only");
668 wset_combination_limit (w
, limit
);
672 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
673 doc
: /* Return the use time of window WINDOW.
674 WINDOW must be a live window and defaults to the selected one.
675 The window with the highest use time is the most recently selected
676 one. The window with the lowest use time is the least recently
680 return make_number (decode_live_window (window
)->use_time
);
683 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
684 doc
: /* Return the total height, in lines, of window WINDOW.
685 WINDOW must be a valid window and defaults to the selected one.
687 The return value includes the mode line and header line, if any.
688 If WINDOW is an internal window, the total height is the height
689 of the screen areas spanned by its children.
691 On a graphical display, this total height is reported as an
692 integer multiple of the default character height. */)
695 return decode_valid_window (window
)->total_lines
;
698 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
699 doc
: /* Return the total width, in columns, of window WINDOW.
700 WINDOW must be a valid window and defaults to the selected one.
702 The return value includes any vertical dividers or scroll bars
703 belonging to WINDOW. If WINDOW is an internal window, the total width
704 is the width of the screen areas spanned by its children.
706 On a graphical display, this total width is reported as an
707 integer multiple of the default character width. */)
710 return decode_valid_window (window
)->total_cols
;
713 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
714 doc
: /* Return the new total size of window WINDOW.
715 WINDOW must be a valid window and defaults to the selected one. */)
718 return decode_valid_window (window
)->new_total
;
721 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
722 doc
: /* Return the normal height of window WINDOW.
723 WINDOW must be a valid window and defaults to the selected one.
724 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
725 (Lisp_Object window
, Lisp_Object horizontal
)
727 struct window
*w
= decode_valid_window (window
);
729 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
732 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
733 doc
: /* Return new normal size of window WINDOW.
734 WINDOW must be a valid window and defaults to the selected one. */)
737 return decode_valid_window (window
)->new_normal
;
740 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
741 doc
: /* Return left column of window WINDOW.
742 This is the distance, in columns, between the left edge of WINDOW and
743 the left edge of the frame's window area. For instance, the return
744 value is 0 if there is no window to the left of WINDOW.
746 WINDOW must be a valid window and defaults to the selected one. */)
749 return decode_valid_window (window
)->left_col
;
752 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
753 doc
: /* Return top line of window WINDOW.
754 This is the distance, in lines, between the top of WINDOW and the top
755 of the frame's window area. For instance, the return value is 0 if
756 there is no window above WINDOW.
758 WINDOW must be a valid window and defaults to the selected one. */)
761 return decode_valid_window (window
)->top_line
;
764 /* Return the number of lines of W's body. Don't count any mode or
768 window_body_lines (struct window
*w
)
770 int height
= XFASTINT (w
->total_lines
);
772 if (!MINI_WINDOW_P (w
))
774 if (WINDOW_WANTS_MODELINE_P (w
))
776 if (WINDOW_WANTS_HEADER_LINE_P (w
))
783 /* Return the number of columns of W's body. Don't count columns
784 occupied by the scroll bar or the vertical bar separating W from its
785 right sibling. On window-systems don't count fringes or display
789 window_body_cols (struct window
*w
)
791 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
792 int width
= XINT (w
->total_cols
);
794 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
795 /* Scroll bars occupy a few columns. */
796 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
797 else if (!FRAME_WINDOW_P (f
)
798 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
799 /* The column of `|' characters separating side-by-side windows
800 occupies one column only. */
803 /* Display margins cannot be used for normal text. */
804 width
-= WINDOW_LEFT_MARGIN_COLS (w
) + WINDOW_RIGHT_MARGIN_COLS (w
);
806 if (FRAME_WINDOW_P (f
))
807 /* On window-systems, fringes cannot be used for normal text. */
808 width
-= WINDOW_FRINGE_COLS (w
);
813 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
814 doc
: /* Return the height, in lines, of WINDOW's text area.
815 WINDOW must be a live window and defaults to the selected one.
817 The returned height does not include the mode line or header line.
818 On a graphical display, the height is expressed as an integer multiple
819 of the default character height. If a line at the bottom of the text
820 area is only partially visible, that counts as a whole line; to
821 exclude partially-visible lines, use `window-text-height'. */)
824 return make_number (window_body_lines (decode_live_window (window
)));
827 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
828 doc
: /* Return the width, in columns, of WINDOW's text area.
829 WINDOW must be a live window and defaults to the selected one.
831 The return value does not include any vertical dividers, fringe or
832 marginal areas, or scroll bars. On a graphical display, the width is
833 expressed as an integer multiple of the default character width. */)
836 return make_number (window_body_cols (decode_live_window (window
)));
839 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
840 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
841 WINDOW must be a live window and defaults to the selected one. */)
844 return make_number (decode_live_window (window
)->hscroll
);
847 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
848 range, returning the new amount as a fixnum. */
850 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
852 /* Horizontal scrolling has problems with large scroll amounts.
853 It's too slow with long lines, and even with small lines the
854 display can be messed up. For now, though, impose only the limits
855 required by the internal representation: horizontal scrolling must
856 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
857 (since it's stored in a ptrdiff_t). */
858 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
859 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
861 /* Prevent redisplay shortcuts when changing the hscroll. */
862 if (w
->hscroll
!= new_hscroll
)
863 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
865 w
->hscroll
= new_hscroll
;
866 return make_number (new_hscroll
);
869 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
870 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
871 WINDOW must be a live window and defaults to the selected one.
872 Clip the number to a reasonable value if out of range.
873 Return the new number. NCOL should be zero or positive.
875 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
876 window so that the location of point moves off-window. */)
877 (Lisp_Object window
, Lisp_Object ncol
)
880 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
883 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
884 Swindow_redisplay_end_trigger
, 0, 1, 0,
885 doc
: /* Return WINDOW's redisplay end trigger value.
886 WINDOW must be a live window and defaults to the selected one.
887 See `set-window-redisplay-end-trigger' for more information. */)
890 return decode_live_window (window
)->redisplay_end_trigger
;
893 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
894 Sset_window_redisplay_end_trigger
, 2, 2, 0,
895 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
896 WINDOW must be a live window and defaults to the selected one. VALUE
897 should be a buffer position (typically a marker) or nil. If it is a
898 buffer position, then if redisplay in WINDOW reaches a position beyond
899 VALUE, the functions in `redisplay-end-trigger-functions' are called
900 with two arguments: WINDOW, and the end trigger value. Afterwards the
901 end-trigger value is reset to nil. */)
902 (register Lisp_Object window
, Lisp_Object value
)
904 wset_redisplay_end_trigger (decode_live_window (window
), value
);
908 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
909 doc
: /* Return a list of the edge coordinates of WINDOW.
910 WINDOW must be a valid window and defaults to the selected one.
912 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
913 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
914 0 at top left corner of frame.
916 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
917 is one more than the bottommost row occupied by WINDOW. The edges
918 include the space used by WINDOW's scroll bar, display margins, fringes,
919 header line, and/or mode line. For the edges of just the text area, use
920 `window-inside-edges'. */)
923 register struct window
*w
= decode_valid_window (window
);
925 return list4i (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
926 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
929 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
930 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
931 WINDOW must be a valid window and defaults to the selected one.
933 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
934 0, 0 at the top left corner of the frame.
936 RIGHT is one more than the rightmost x position occupied by WINDOW.
937 BOTTOM is one more than the bottommost y position occupied by WINDOW.
938 The pixel edges include the space used by WINDOW's scroll bar, display
939 margins, fringes, header line, and/or mode line. For the pixel edges
940 of just the text area, use `window-inside-pixel-edges'. */)
943 register struct window
*w
= decode_valid_window (window
);
945 return list4i (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
946 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
950 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
952 struct frame
*f
= XFRAME (w
->frame
);
954 #ifdef FRAME_MENUBAR_HEIGHT
955 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
957 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
958 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
959 #elif FRAME_TOOLBAR_HEIGHT
960 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
962 #ifdef FRAME_NS_TITLEBAR_HEIGHT
963 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
965 *add_x
= f
->left_pos
;
966 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
967 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
971 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
972 Swindow_absolute_pixel_edges
, 0, 1, 0,
973 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
974 WINDOW must be a valid window and defaults to the selected one.
976 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
977 0, 0 at the top left corner of the display.
979 RIGHT is one more than the rightmost x position occupied by WINDOW.
980 BOTTOM is one more than the bottommost y position occupied by WINDOW.
981 The pixel edges include the space used by WINDOW's scroll bar, display
982 margins, fringes, header line, and/or mode line. For the pixel edges
983 of just the text area, use `window-inside-absolute-pixel-edges'. */)
986 register struct window
*w
= decode_valid_window (window
);
989 calc_absolute_offset (w
, &add_x
, &add_y
);
991 return list4i (WINDOW_LEFT_EDGE_X (w
) + add_x
,
992 WINDOW_TOP_EDGE_Y (w
) + add_y
,
993 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
994 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
997 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
998 doc
: /* Return a list of the edge coordinates of WINDOW.
999 WINDOW must be a live window and defaults to the selected one.
1001 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
1002 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
1003 0 at top left corner of frame.
1005 RIGHT is one more than the rightmost column of WINDOW's text area.
1006 BOTTOM is one more than the bottommost row of WINDOW's text area. The
1007 inside edges do not include the space used by the WINDOW's scroll bar,
1008 display margins, fringes, header line, and/or mode line. */)
1009 (Lisp_Object window
)
1011 register struct window
*w
= decode_live_window (window
);
1013 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w
)
1014 + WINDOW_LEFT_MARGIN_COLS (w
)
1015 + WINDOW_LEFT_FRINGE_COLS (w
)),
1016 (WINDOW_TOP_EDGE_LINE (w
)
1017 + WINDOW_HEADER_LINE_LINES (w
)),
1018 (WINDOW_BOX_RIGHT_EDGE_COL (w
)
1019 - WINDOW_RIGHT_MARGIN_COLS (w
)
1020 - WINDOW_RIGHT_FRINGE_COLS (w
)),
1021 (WINDOW_BOTTOM_EDGE_LINE (w
)
1022 - WINDOW_MODE_LINE_LINES (w
)));
1025 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
1026 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1027 WINDOW must be a live window and defaults to the selected one.
1029 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1030 (0,0) at the top left corner of the frame's window area.
1032 RIGHT is one more than the rightmost x position of WINDOW's text area.
1033 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1034 The inside edges do not include the space used by WINDOW's scroll bar,
1035 display margins, fringes, header line, and/or mode line. */)
1036 (Lisp_Object window
)
1038 register struct window
*w
= decode_live_window (window
);
1040 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1041 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1042 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1043 (WINDOW_TOP_EDGE_Y (w
)
1044 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1045 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1046 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1047 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1048 (WINDOW_BOTTOM_EDGE_Y (w
)
1049 - WINDOW_MODE_LINE_HEIGHT (w
)));
1052 DEFUN ("window-inside-absolute-pixel-edges",
1053 Fwindow_inside_absolute_pixel_edges
,
1054 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1055 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1056 WINDOW must be a live window and defaults to the selected one.
1058 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1059 (0,0) at the top left corner of the frame's window area.
1061 RIGHT is one more than the rightmost x position of WINDOW's text area.
1062 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1063 The inside edges do not include the space used by WINDOW's scroll bar,
1064 display margins, fringes, header line, and/or mode line. */)
1065 (Lisp_Object window
)
1067 register struct window
*w
= decode_live_window (window
);
1070 calc_absolute_offset (w
, &add_x
, &add_y
);
1072 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1073 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1074 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1075 (WINDOW_TOP_EDGE_Y (w
)
1076 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1077 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1078 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1079 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1080 (WINDOW_BOTTOM_EDGE_Y (w
)
1081 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1084 /* Test if the character at column X, row Y is within window W.
1085 If it is not, return ON_NOTHING;
1086 if it is in the window's text area, return ON_TEXT;
1087 if it is on the window's modeline, return ON_MODE_LINE;
1088 if it is on the border between the window and its right sibling,
1089 return ON_VERTICAL_BORDER.
1090 if it is on a scroll bar, return ON_SCROLL_BAR.
1091 if it is on the window's top line, return ON_HEADER_LINE;
1092 if it is in left or right fringe of the window,
1093 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1094 if it is in the marginal area to the left/right of the window,
1095 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1097 X and Y are frame relative pixel coordinates. */
1099 static enum window_part
1100 coordinates_in_window (register struct window
*w
, int x
, int y
)
1102 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1103 enum window_part part
;
1104 int ux
= FRAME_COLUMN_WIDTH (f
);
1105 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1106 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1107 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1108 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1109 /* The width of the area where the vertical line can be dragged.
1110 (Between mode lines for instance. */
1111 int grabbable_width
= ux
;
1112 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1114 /* Outside any interesting row or column? */
1115 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1118 /* On the mode line or header line? */
1119 if ((WINDOW_WANTS_MODELINE_P (w
)
1120 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1121 && (part
= ON_MODE_LINE
))
1122 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1123 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1124 && (part
= ON_HEADER_LINE
)))
1126 /* If it's under/over the scroll bar portion of the mode/header
1127 line, say it's on the vertical line. That's to be able to
1128 resize windows horizontally in case we're using toolkit scroll
1129 bars. Note: If scrollbars are on the left, the window that
1130 must be eventually resized is that on the left of WINDOW. */
1131 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1132 && !WINDOW_LEFTMOST_P (w
)
1133 && eabs (x
- left_x
) < grabbable_width
)
1134 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1135 && !WINDOW_RIGHTMOST_P (w
)
1136 && eabs (x
- right_x
) < grabbable_width
))
1137 return ON_VERTICAL_BORDER
;
1142 /* In what's below, we subtract 1 when computing right_x because we
1143 want the rightmost pixel, which is given by left_pixel+width-1. */
1144 if (w
->pseudo_window_p
)
1147 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1151 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1152 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1155 /* Outside any interesting column? */
1156 if (x
< left_x
|| x
> right_x
)
1157 return ON_SCROLL_BAR
;
1159 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1160 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1162 text_left
= window_box_left (w
, TEXT_AREA
);
1163 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1165 if (FRAME_WINDOW_P (f
))
1167 if (!w
->pseudo_window_p
1168 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1169 && !WINDOW_RIGHTMOST_P (w
)
1170 && (eabs (x
- right_x
) < grabbable_width
))
1171 return ON_VERTICAL_BORDER
;
1173 /* Need to say "x > right_x" rather than >=, since on character
1174 terminals, the vertical line's x coordinate is right_x. */
1175 else if (!w
->pseudo_window_p
1176 && !WINDOW_RIGHTMOST_P (w
)
1177 && x
> right_x
- ux
)
1178 return ON_VERTICAL_BORDER
;
1182 if (lmargin_width
> 0
1183 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1184 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1185 : (x
< left_x
+ lmargin_width
)))
1186 return ON_LEFT_MARGIN
;
1188 return ON_LEFT_FRINGE
;
1191 if (x
>= text_right
)
1193 if (rmargin_width
> 0
1194 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1195 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1196 : (x
>= right_x
- rmargin_width
)))
1197 return ON_RIGHT_MARGIN
;
1199 return ON_RIGHT_FRINGE
;
1202 /* Everything special ruled out - must be on text area */
1206 /* Take X is the frame-relative pixel x-coordinate, and return the
1207 x-coordinate relative to part PART of window W. */
1209 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1211 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1216 return x
- window_box_left (w
, TEXT_AREA
);
1218 case ON_LEFT_FRINGE
:
1221 case ON_RIGHT_FRINGE
:
1222 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1224 case ON_LEFT_MARGIN
:
1226 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1227 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1229 case ON_RIGHT_MARGIN
:
1231 - ((w
->pseudo_window_p
)
1232 ? WINDOW_TOTAL_WIDTH (w
)
1233 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1234 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1235 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1236 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1239 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1244 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1245 Scoordinates_in_window_p
, 2, 2, 0,
1246 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1247 WINDOW must be a live window and defaults to the selected one.
1248 COORDINATES is a cons of the form (X . Y), X and Y being distances
1249 measured in characters from the upper-left corner of the frame.
1250 \(0 . 0) denotes the character in the upper left corner of the
1252 If COORDINATES are in the text portion of WINDOW,
1253 the coordinates relative to the window are returned.
1254 If they are in the mode line of WINDOW, `mode-line' is returned.
1255 If they are in the top mode line of WINDOW, `header-line' is returned.
1256 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1257 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1258 If they are on the border between WINDOW and its right sibling,
1259 `vertical-line' is returned.
1260 If they are in the windows's left or right marginal areas, `left-margin'\n\
1261 or `right-margin' is returned. */)
1262 (register Lisp_Object coordinates
, Lisp_Object window
)
1269 w
= decode_live_window (window
);
1270 f
= XFRAME (w
->frame
);
1271 CHECK_CONS (coordinates
);
1272 lx
= Fcar (coordinates
);
1273 ly
= Fcdr (coordinates
);
1274 CHECK_NUMBER_OR_FLOAT (lx
);
1275 CHECK_NUMBER_OR_FLOAT (ly
);
1276 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1277 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1279 switch (coordinates_in_window (w
, x
, y
))
1285 /* Convert X and Y to window relative pixel coordinates, and
1286 return the canonical char units. */
1287 x
-= window_box_left (w
, TEXT_AREA
);
1288 y
-= WINDOW_TOP_EDGE_Y (w
);
1289 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1290 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1295 case ON_VERTICAL_BORDER
:
1296 return Qvertical_line
;
1298 case ON_HEADER_LINE
:
1299 return Qheader_line
;
1301 case ON_LEFT_FRINGE
:
1302 return Qleft_fringe
;
1304 case ON_RIGHT_FRINGE
:
1305 return Qright_fringe
;
1307 case ON_LEFT_MARGIN
:
1308 return Qleft_margin
;
1310 case ON_RIGHT_MARGIN
:
1311 return Qright_margin
;
1314 /* Historically we are supposed to return nil in this case. */
1323 /* Callback for foreach_window, used in window_from_coordinates.
1324 Check if window W contains coordinates specified by USER_DATA which
1325 is actually a pointer to a struct check_window_data CW.
1327 Check if window W contains coordinates *CW->x and *CW->y. If it
1328 does, return W in *CW->window, as Lisp_Object, and return in
1329 *CW->part the part of the window under coordinates *X,*Y. Return
1330 zero from this function to stop iterating over windows. */
1332 struct check_window_data
1334 Lisp_Object
*window
;
1336 enum window_part
*part
;
1340 check_window_containing (struct window
*w
, void *user_data
)
1342 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1343 enum window_part found
;
1346 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1347 if (found
!= ON_NOTHING
)
1350 XSETWINDOW (*cw
->window
, w
);
1358 /* Find the window containing frame-relative pixel position X/Y and
1359 return it as a Lisp_Object.
1361 If X, Y is on one of the window's special `window_part' elements,
1362 set *PART to the id of that element.
1364 If there is no window under X, Y return nil and leave *PART
1365 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1367 This function was previously implemented with a loop cycling over
1368 windows with Fnext_window, and starting with the frame's selected
1369 window. It turned out that this doesn't work with an
1370 implementation of next_window using Vwindow_list, because
1371 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1372 tree of F when this function is called asynchronously from
1373 note_mouse_highlight. The original loop didn't terminate in this
1377 window_from_coordinates (struct frame
*f
, int x
, int y
,
1378 enum window_part
*part
, bool tool_bar_p
)
1381 struct check_window_data cw
;
1382 enum window_part dummy
;
1388 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1389 foreach_window (f
, check_window_containing
, &cw
);
1391 /* If not found above, see if it's in the tool bar window, if a tool
1395 && WINDOWP (f
->tool_bar_window
)
1396 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1397 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1401 window
= f
->tool_bar_window
;
1407 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1408 doc
: /* Return window containing coordinates X and Y on FRAME.
1409 FRAME must be a live frame and defaults to the selected one.
1410 The top left corner of the frame is considered to be row 0,
1412 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1414 struct frame
*f
= decode_live_frame (frame
);
1416 /* Check that arguments are integers or floats. */
1417 CHECK_NUMBER_OR_FLOAT (x
);
1418 CHECK_NUMBER_OR_FLOAT (y
);
1420 return window_from_coordinates (f
,
1421 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1422 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1423 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1424 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1428 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1429 doc
: /* Return current value of point in WINDOW.
1430 WINDOW must be a live window and defaults to the selected one.
1432 For a nonselected window, this is the value point would have if that
1433 window were selected.
1435 Note that, when WINDOW is selected, the value returned is the same as
1436 that returned by `point' for WINDOW's buffer. It would be more strictly
1437 correct to return the top-level value of `point', outside of any
1438 `save-excursion' forms. But that is hard to define. */)
1439 (Lisp_Object window
)
1441 register struct window
*w
= decode_live_window (window
);
1443 if (w
== XWINDOW (selected_window
))
1444 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1446 return Fmarker_position (w
->pointm
);
1449 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1450 doc
: /* Return position at which display currently starts in WINDOW.
1451 WINDOW must be a live window and defaults to the selected one.
1452 This is updated by redisplay or by calling `set-window-start'. */)
1453 (Lisp_Object window
)
1455 return Fmarker_position (decode_live_window (window
)->start
);
1458 /* This is text temporarily removed from the doc string below.
1460 This function returns nil if the position is not currently known.
1461 That happens when redisplay is preempted and doesn't finish.
1462 If in that case you want to compute where the end of the window would
1463 have been if redisplay had finished, do this:
1465 (goto-char (window-start window))
1466 (vertical-motion (1- (window-height window)) window)
1469 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1470 doc
: /* Return position at which display currently ends in WINDOW.
1471 WINDOW must be a live window and defaults to the selected one.
1472 This is updated by redisplay, when it runs to completion.
1473 Simply changing the buffer text or setting `window-start'
1474 does not update this value.
1475 Return nil if there is no recorded value. (This can happen if the
1476 last redisplay of WINDOW was preempted, and did not finish.)
1477 If UPDATE is non-nil, compute the up-to-date position
1478 if it isn't already recorded. */)
1479 (Lisp_Object window
, Lisp_Object update
)
1482 struct window
*w
= decode_live_window (window
);
1491 && (windows_or_buffers_changed
|| !w
->window_end_valid
)
1494 struct text_pos startp
;
1495 ptrdiff_t charpos
= marker_position (w
->start
);
1497 struct buffer
*old_buffer
= NULL
;
1498 void *itdata
= NULL
;
1500 /* Cannot use Fvertical_motion because that function doesn't
1501 cope with variable-height lines. */
1502 if (b
!= current_buffer
)
1504 old_buffer
= current_buffer
;
1505 set_buffer_internal (b
);
1508 /* In case W->start is out of the range, use something
1509 reasonable. This situation occurred when loading a file with
1510 `-l' containing a call to `rmail' with subsequent other
1511 commands. At the end, W->start happened to be BEG, while
1512 rmail had already narrowed the buffer. */
1514 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1515 else if (charpos
> ZV
)
1516 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1518 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1520 itdata
= bidi_shelve_cache ();
1521 start_display (&it
, w
, startp
);
1522 move_it_vertically (&it
, window_box_height (w
));
1523 if (it
.current_y
< it
.last_visible_y
)
1524 move_it_past_eol (&it
);
1525 value
= make_number (IT_CHARPOS (it
));
1526 bidi_unshelve_cache (itdata
, 0);
1529 set_buffer_internal (old_buffer
);
1532 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1537 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1538 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1539 WINDOW must be a live window and defaults to the selected one.
1541 (Lisp_Object window
, Lisp_Object pos
)
1543 register struct window
*w
= decode_live_window (window
);
1545 /* Type of POS is checked by Fgoto_char or set_marker_restricted ... */
1547 if (w
== XWINDOW (selected_window
))
1549 if (XBUFFER (w
->buffer
) == current_buffer
)
1553 struct buffer
*old_buffer
= current_buffer
;
1555 /* ... but here we want to catch type error before buffer change. */
1556 CHECK_NUMBER_COERCE_MARKER (pos
);
1557 set_buffer_internal (XBUFFER (w
->buffer
));
1559 set_buffer_internal (old_buffer
);
1564 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1565 /* We have to make sure that redisplay updates the window to show
1566 the new value of point. */
1567 ++windows_or_buffers_changed
;
1573 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1574 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1575 WINDOW must be a live window and defaults to the selected one. Return
1576 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1577 overriding motion of point in order to display at this exact start. */)
1578 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1580 register struct window
*w
= decode_live_window (window
);
1582 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1583 /* This is not right, but much easier than doing what is right. */
1584 w
->start_at_line_beg
= 0;
1587 w
->update_mode_line
= 1;
1588 w
->last_modified
= 0;
1589 w
->last_overlay_modified
= 0;
1590 if (!EQ (window
, selected_window
))
1591 windows_or_buffers_changed
++;
1596 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1597 Spos_visible_in_window_p
, 0, 3, 0,
1598 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1599 WINDOW must be a live window and defaults to the selected one.
1601 Return nil if that position is scrolled vertically out of view. If a
1602 character is only partially visible, nil is returned, unless the
1603 optional argument PARTIALLY is non-nil. If POS is only out of view
1604 because of horizontal scrolling, return non-nil. If POS is t, it
1605 specifies the position of the last visible glyph in WINDOW. POS
1606 defaults to point in WINDOW; WINDOW defaults to the selected window.
1608 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1609 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1610 where X and Y are the pixel coordinates relative to the top left corner
1611 of the window. The remaining elements are omitted if the character after
1612 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1613 off-window at the top and bottom of the row, ROWH is the height of the
1614 display row, and VPOS is the row number (0-based) containing POS. */)
1615 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1617 register struct window
*w
;
1618 register EMACS_INT posint
;
1619 register struct buffer
*buf
;
1620 struct text_pos top
;
1621 Lisp_Object in_window
= Qnil
;
1622 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1625 w
= decode_live_window (window
);
1626 buf
= XBUFFER (w
->buffer
);
1627 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1631 else if (!NILP (pos
))
1633 CHECK_NUMBER_COERCE_MARKER (pos
);
1634 posint
= XINT (pos
);
1636 else if (w
== XWINDOW (selected_window
))
1639 posint
= marker_position (w
->pointm
);
1641 /* If position is above window start or outside buffer boundaries,
1642 or if window start is out of range, position is not visible. */
1644 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1645 && CHARPOS (top
) >= BUF_BEGV (buf
)
1646 && CHARPOS (top
) <= BUF_ZV (buf
)
1647 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1648 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1651 if (!NILP (in_window
) && !NILP (partially
))
1653 Lisp_Object part
= Qnil
;
1655 part
= list4i (rtop
, rbot
, rowh
, vpos
);
1656 in_window
= Fcons (make_number (x
),
1657 Fcons (make_number (y
), part
));
1663 DEFUN ("window-line-height", Fwindow_line_height
,
1664 Swindow_line_height
, 0, 2, 0,
1665 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1666 WINDOW must be a live window and defaults to the selected one.
1668 Return height of current line if LINE is omitted or nil. Return height of
1669 header or mode line if LINE is `header-line' or `mode-line'.
1670 Otherwise, LINE is a text line number starting from 0. A negative number
1671 counts from the end of the window.
1673 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1674 in pixels of the visible part of the line, VPOS and YPOS are the
1675 vertical position in lines and pixels of the line, relative to the top
1676 of the first text line, and OFFBOT is the number of off-window pixels at
1677 the bottom of the text line. If there are off-window pixels at the top
1678 of the (first) text line, YPOS is negative.
1680 Return nil if window display is not up-to-date. In that case, use
1681 `pos-visible-in-window-p' to obtain the information. */)
1682 (Lisp_Object line
, Lisp_Object window
)
1684 register struct window
*w
;
1685 register struct buffer
*b
;
1686 struct glyph_row
*row
, *end_row
;
1690 w
= decode_live_window (window
);
1692 if (noninteractive
|| w
->pseudo_window_p
)
1695 CHECK_BUFFER (w
->buffer
);
1696 b
= XBUFFER (w
->buffer
);
1698 /* Fail if current matrix is not up-to-date. */
1699 if (!w
->window_end_valid
1700 || current_buffer
->clip_changed
1701 || current_buffer
->prevent_redisplay_optimizations_p
1702 || w
->last_modified
< BUF_MODIFF (b
)
1703 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1709 if (i
< 0 || i
>= w
->current_matrix
->nrows
1710 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1712 max_y
= window_text_bottom_y (w
);
1716 if (EQ (line
, Qheader_line
))
1718 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1720 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1721 return row
->enabled_p
? list4i (row
->height
, 0, 0, 0) : Qnil
;
1724 if (EQ (line
, Qmode_line
))
1726 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1727 return (row
->enabled_p
?
1728 list4i (row
->height
,
1729 0, /* not accurate */
1730 (WINDOW_HEADER_LINE_HEIGHT (w
)
1731 + window_text_bottom_y (w
)),
1736 CHECK_NUMBER (line
);
1739 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1740 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1741 max_y
= window_text_bottom_y (w
);
1744 while ((n
< 0 || i
< n
)
1745 && row
<= end_row
&& row
->enabled_p
1746 && row
->y
+ row
->height
< max_y
)
1749 if (row
> end_row
|| !row
->enabled_p
)
1761 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1762 return list4i (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1765 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1767 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1768 More precisely, return the value assigned by the last call of
1769 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1770 never called with WINDOW as its argument, or the value set by that
1771 function was internally reset since its last call. WINDOW must be a
1772 live window and defaults to the selected one.
1774 When a window is dedicated to its buffer, `display-buffer' will refrain
1775 from displaying another buffer in it. `get-lru-window' and
1776 `get-largest-window' treat dedicated windows specially.
1777 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1778 `kill-buffer' can delete a dedicated window and the containing frame.
1780 Functions like `set-window-buffer' may change the buffer displayed by a
1781 window, unless that window is "strongly" dedicated to its buffer, that
1782 is the value returned by `window-dedicated-p' is t. */)
1783 (Lisp_Object window
)
1785 return decode_live_window (window
)->dedicated
;
1788 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1789 Sset_window_dedicated_p
, 2, 2, 0,
1790 doc
: /* Mark WINDOW as dedicated according to FLAG.
1791 WINDOW must be a live window and defaults to the selected one. FLAG
1792 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1793 mark WINDOW as non-dedicated. Return FLAG.
1795 When a window is dedicated to its buffer, `display-buffer' will refrain
1796 from displaying another buffer in it. `get-lru-window' and
1797 `get-largest-window' treat dedicated windows specially.
1798 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1799 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1800 and the containing frame.
1802 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1803 its buffer. Functions like `set-window-buffer' may change the buffer
1804 displayed by a window, unless that window is strongly dedicated to its
1805 buffer. If and when `set-window-buffer' displays another buffer in a
1806 window, it also makes sure that the window is no more dedicated. */)
1807 (Lisp_Object window
, Lisp_Object flag
)
1809 wset_dedicated (decode_live_window (window
), flag
);
1813 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1815 doc
: /* Return buffers previously shown in WINDOW.
1816 WINDOW must be a live window and defaults to the selected one.
1818 The return value is a list of elements (BUFFER WINDOW-START POS),
1819 where BUFFER is a buffer, WINDOW-START is the start position of the
1820 window for that buffer, and POS is a window-specific point value. */)
1821 (Lisp_Object window
)
1823 return decode_live_window (window
)->prev_buffers
;
1826 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1827 Sset_window_prev_buffers
, 2, 2, 0,
1828 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1829 WINDOW must be a live window and defaults to the selected one.
1831 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1832 where BUFFER is a buffer, WINDOW-START is the start position of the
1833 window for that buffer, and POS is a window-specific point value. */)
1834 (Lisp_Object window
, Lisp_Object prev_buffers
)
1836 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1837 return prev_buffers
;
1840 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1842 doc
: /* Return list of buffers recently re-shown in WINDOW.
1843 WINDOW must be a live window and defaults to the selected one. */)
1844 (Lisp_Object window
)
1846 return decode_live_window (window
)->next_buffers
;
1849 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1850 Sset_window_next_buffers
, 2, 2, 0,
1851 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1852 WINDOW must be a live window and defaults to the selected one.
1853 NEXT-BUFFERS should be a list of buffers. */)
1854 (Lisp_Object window
, Lisp_Object next_buffers
)
1856 wset_next_buffers (decode_live_window (window
), next_buffers
);
1857 return next_buffers
;
1860 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1862 doc
: /* Return the parameters of WINDOW and their values.
1863 WINDOW must be a valid window and defaults to the selected one. The
1864 return value is a list of elements of the form (PARAMETER . VALUE). */)
1865 (Lisp_Object window
)
1867 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1870 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1872 doc
: /* Return WINDOW's value for PARAMETER.
1873 WINDOW can be any window and defaults to the selected one. */)
1874 (Lisp_Object window
, Lisp_Object parameter
)
1878 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1879 return CDR_SAFE (result
);
1882 DEFUN ("set-window-parameter", Fset_window_parameter
,
1883 Sset_window_parameter
, 3, 3, 0,
1884 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1885 WINDOW can be any window and defaults to the selected one.
1887 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1889 register struct window
*w
= decode_any_window (window
);
1890 Lisp_Object old_alist_elt
;
1892 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1893 if (NILP (old_alist_elt
))
1894 wset_window_parameters
1895 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1897 Fsetcdr (old_alist_elt
, value
);
1901 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1903 doc
: /* Return the display-table that WINDOW is using.
1904 WINDOW must be a live window and defaults to the selected one. */)
1905 (Lisp_Object window
)
1907 return decode_live_window (window
)->display_table
;
1910 /* Get the display table for use on window W. This is either W's
1911 display table or W's buffer's display table. Ignore the specified
1912 tables if they are not valid; if no valid table is specified,
1915 struct Lisp_Char_Table
*
1916 window_display_table (struct window
*w
)
1918 struct Lisp_Char_Table
*dp
= NULL
;
1920 if (DISP_TABLE_P (w
->display_table
))
1921 dp
= XCHAR_TABLE (w
->display_table
);
1922 else if (BUFFERP (w
->buffer
))
1924 struct buffer
*b
= XBUFFER (w
->buffer
);
1926 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1927 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1928 else if (DISP_TABLE_P (Vstandard_display_table
))
1929 dp
= XCHAR_TABLE (Vstandard_display_table
);
1935 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1936 doc
: /* Set WINDOW's display-table to TABLE.
1937 WINDOW must be a live window and defaults to the selected one. */)
1938 (register Lisp_Object window
, Lisp_Object table
)
1940 wset_display_table (decode_live_window (window
), table
);
1944 /* Record info on buffer window W is displaying
1945 when it is about to cease to display that buffer. */
1947 unshow_buffer (register struct window
*w
)
1954 if (b
!= XMARKER (w
->pointm
)->buffer
)
1958 if (w
== XWINDOW (selected_window
)
1959 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1960 /* Do this except when the selected window's buffer
1961 is being removed from some other window. */
1963 /* last_window_start records the start position that this buffer
1964 had in the last window to be disconnected from it.
1965 Now that this statement is unconditional,
1966 it is possible for the buffer to be displayed in the
1967 selected window, while last_window_start reflects another
1968 window which was recently showing the same buffer.
1969 Some people might say that might be a good thing. Let's see. */
1970 b
->last_window_start
= marker_position (w
->start
);
1972 /* Point in the selected window's buffer
1973 is actually stored in that buffer, and the window's pointm isn't used.
1974 So don't clobber point in that buffer. */
1975 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1976 /* Don't clobber point in current buffer either (this could be
1977 useful in connection with bug#12208).
1978 && XBUFFER (buf) != current_buffer */
1979 /* This line helps to fix Horsley's testbug.el bug. */
1980 && !(WINDOWP (BVAR (b
, last_selected_window
))
1981 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1982 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1983 temp_set_point_both (b
,
1984 clip_to_bounds (BUF_BEGV (b
),
1985 marker_position (w
->pointm
),
1987 clip_to_bounds (BUF_BEGV_BYTE (b
),
1988 marker_byte_position (w
->pointm
),
1991 if (WINDOWP (BVAR (b
, last_selected_window
))
1992 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1993 bset_last_selected_window (b
, Qnil
);
1996 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1997 means change window structure only. Otherwise store geometry and
1998 other settings as well. */
2000 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
2002 register Lisp_Object tem
;
2003 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
2005 /* If OLD is its frame's root window, then NEW is the new
2006 root window for that frame. */
2007 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
2008 fset_root_window (XFRAME (o
->frame
), new);
2012 wset_left_col (n
, o
->left_col
);
2013 wset_top_line (n
, o
->top_line
);
2014 wset_total_cols (n
, o
->total_cols
);
2015 wset_total_lines (n
, o
->total_lines
);
2016 wset_normal_cols (n
, o
->normal_cols
);
2017 wset_normal_cols (o
, make_float (1.0));
2018 wset_normal_lines (n
, o
->normal_lines
);
2019 wset_normal_lines (o
, make_float (1.0));
2020 n
->desired_matrix
= n
->current_matrix
= 0;
2022 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
2023 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
2024 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
2025 n
->phys_cursor_type
= -1;
2026 n
->phys_cursor_width
= -1;
2027 n
->must_be_updated_p
= 0;
2028 n
->pseudo_window_p
= 0;
2029 wset_window_end_vpos (n
, make_number (0));
2030 wset_window_end_pos (n
, make_number (0));
2031 n
->window_end_valid
= 0;
2032 n
->frozen_window_start_p
= 0;
2038 wset_prev (XWINDOW (tem
), new);
2043 wset_next (XWINDOW (tem
), new);
2046 wset_parent (n
, tem
);
2049 if (EQ (XWINDOW (tem
)->vchild
, old
))
2050 wset_vchild (XWINDOW (tem
), new);
2051 if (EQ (XWINDOW (tem
)->hchild
, old
))
2052 wset_hchild (XWINDOW (tem
), new);
2056 /* If window WINDOW and its parent window are iso-combined, merge
2057 WINDOW's children into those of its parent window and mark WINDOW as
2061 recombine_windows (Lisp_Object window
)
2063 struct window
*w
, *p
, *c
;
2064 Lisp_Object parent
, child
;
2067 w
= XWINDOW (window
);
2069 if (!NILP (parent
) && NILP (w
->combination_limit
))
2071 p
= XWINDOW (parent
);
2072 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2073 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2074 /* WINDOW and PARENT are both either a vertical or a horizontal
2077 horflag
= NILP (w
->vchild
);
2078 child
= horflag
? w
->hchild
: w
->vchild
;
2079 c
= XWINDOW (child
);
2081 /* Splice WINDOW's children into its parent's children and
2082 assign new normal sizes. */
2085 wset_hchild (p
, child
);
2087 wset_vchild (p
, child
);
2090 wset_prev (c
, w
->prev
);
2091 wset_next (XWINDOW (w
->prev
), child
);
2096 wset_parent (c
, parent
);
2099 wset_normal_cols (c
,
2100 make_float (XFLOATINT (c
->total_cols
)
2101 / XFLOATINT (p
->total_cols
)));
2103 wset_normal_lines (c
,
2104 make_float (XFLOATINT (c
->total_lines
)
2105 / XFLOATINT (p
->total_lines
)));
2109 if (!NILP (w
->next
))
2111 wset_next (c
, w
->next
);
2112 wset_prev (XWINDOW (c
->next
), child
);
2120 c
= XWINDOW (child
);
2124 /* WINDOW can be deleted now. */
2125 wset_vchild (w
, Qnil
);
2126 wset_hchild (w
, Qnil
);
2131 /* If WINDOW can be deleted, delete it. */
2133 delete_deletable_window (Lisp_Object window
)
2135 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2136 call1 (Qdelete_window
, window
);
2139 /***********************************************************************
2141 ***********************************************************************/
2143 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2144 pointer. This is a callback function for foreach_window, used in
2145 the window_list function. */
2148 add_window_to_list (struct window
*w
, void *user_data
)
2150 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2152 XSETWINDOW (window
, w
);
2153 *list
= Fcons (window
, *list
);
2158 /* Return a list of all windows, for use by next_window. If
2159 Vwindow_list is a list, return that list. Otherwise, build a new
2160 list, cache it in Vwindow_list, and return that. */
2165 if (!CONSP (Vwindow_list
))
2167 Lisp_Object tail
, frame
;
2169 Vwindow_list
= Qnil
;
2170 FOR_EACH_FRAME (tail
, frame
)
2172 Lisp_Object args
[2];
2174 /* We are visiting windows in canonical order, and add
2175 new windows at the front of args[1], which means we
2176 have to reverse this list at the end. */
2178 foreach_window (XFRAME (frame
), add_window_to_list
, &args
[1]);
2179 args
[0] = Vwindow_list
;
2180 args
[1] = Fnreverse (args
[1]);
2181 Vwindow_list
= Fnconc (2, args
);
2185 return Vwindow_list
;
2189 /* Value is non-zero if WINDOW satisfies the constraints given by
2190 OWINDOW, MINIBUF and ALL_FRAMES.
2192 MINIBUF t means WINDOW may be minibuffer windows.
2193 `lambda' means WINDOW may not be a minibuffer window.
2194 a window means a specific minibuffer window
2196 ALL_FRAMES t means search all frames,
2197 nil means search just current frame,
2198 `visible' means search just visible frames on the
2200 0 means search visible and iconified frames on the
2202 a window means search the frame that window belongs to,
2203 a frame means consider windows on that frame, only. */
2206 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2208 struct window
*w
= XWINDOW (window
);
2209 struct frame
*f
= XFRAME (w
->frame
);
2210 int candidate_p
= 1;
2212 if (!BUFFERP (w
->buffer
))
2214 else if (MINI_WINDOW_P (w
)
2215 && (EQ (minibuf
, Qlambda
)
2216 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2218 /* If MINIBUF is `lambda' don't consider any mini-windows.
2219 If it is a window, consider only that one. */
2222 else if (EQ (all_frames
, Qt
))
2224 else if (NILP (all_frames
))
2226 eassert (WINDOWP (owindow
));
2227 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2229 else if (EQ (all_frames
, Qvisible
))
2231 candidate_p
= FRAME_VISIBLE_P (f
)
2232 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2233 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2236 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2238 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2239 #ifdef HAVE_X_WINDOWS
2240 /* Yuck!! If we've just created the frame and the
2241 window-manager requested the user to place it
2242 manually, the window may still not be considered
2243 `visible'. I'd argue it should be at least
2244 something like `iconified', but don't know how to do
2246 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2247 && !f
->output_data
.x
->has_been_visible
)
2250 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2251 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2253 else if (WINDOWP (all_frames
))
2254 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2255 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2256 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2257 else if (FRAMEP (all_frames
))
2258 candidate_p
= EQ (all_frames
, w
->frame
);
2264 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2265 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2266 MINIBUF, and ALL_FRAMES. */
2269 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2271 struct window
*w
= decode_live_window (*window
);
2273 XSETWINDOW (*window
, w
);
2274 /* MINIBUF nil may or may not include minibuffers. Decide if it
2276 if (NILP (*minibuf
))
2277 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2278 else if (!EQ (*minibuf
, Qt
))
2281 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2282 => count none of them, or a specific minibuffer window (the
2283 active one) to count. */
2285 /* ALL_FRAMES nil doesn't specify which frames to include. */
2286 if (NILP (*all_frames
))
2288 = (!EQ (*minibuf
, Qlambda
)
2289 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2291 else if (EQ (*all_frames
, Qvisible
))
2293 else if (EQ (*all_frames
, make_number (0)))
2295 else if (FRAMEP (*all_frames
))
2297 else if (!EQ (*all_frames
, Qt
))
2302 /* Return the next or previous window of WINDOW in cyclic ordering
2303 of windows. NEXT_P non-zero means return the next window. See the
2304 documentation string of next-window for the meaning of MINIBUF and
2308 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2310 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2312 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2313 return the first window on the frame. */
2314 if (FRAMEP (all_frames
)
2315 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2316 return Fframe_first_window (all_frames
);
2322 /* Find WINDOW in the list of all windows. */
2323 list
= Fmemq (window
, window_list ());
2325 /* Scan forward from WINDOW to the end of the window list. */
2327 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2328 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2331 /* Scan from the start of the window list up to WINDOW. */
2333 for (list
= Vwindow_list
;
2334 CONSP (list
) && !EQ (XCAR (list
), window
);
2336 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2340 window
= XCAR (list
);
2344 Lisp_Object candidate
, list
;
2346 /* Scan through the list of windows for candidates. If there are
2347 candidate windows in front of WINDOW, the last one of these
2348 is the one we want. If there are candidates following WINDOW
2349 in the list, again the last one of these is the one we want. */
2351 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2353 if (EQ (XCAR (list
), window
))
2355 if (WINDOWP (candidate
))
2358 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2360 candidate
= XCAR (list
);
2363 if (WINDOWP (candidate
))
2371 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2372 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2373 WINDOW must be a live window and defaults to the selected one. The
2374 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2377 MINIBUF nil or omitted means consider the minibuffer window only if the
2378 minibuffer is active. MINIBUF t means consider the minibuffer window
2379 even if the minibuffer is not active. Any other value means do not
2380 consider the minibuffer window even if the minibuffer is active.
2382 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2383 plus the minibuffer window if specified by the MINIBUF argument. If the
2384 minibuffer counts, consider all windows on all frames that share that
2385 minibuffer too. The following non-nil values of ALL-FRAMES have special
2388 - t means consider all windows on all existing frames.
2390 - `visible' means consider all windows on all visible frames.
2392 - 0 (the number zero) means consider all windows on all visible and
2395 - A frame means consider all windows on that frame only.
2397 Anything else means consider all windows on WINDOW's frame and no
2400 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2401 `next-window' to iterate through the entire cycle of acceptable
2402 windows, eventually ending up back at the window you started with.
2403 `previous-window' traverses the same cycle, in the reverse order. */)
2404 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2406 return next_window (window
, minibuf
, all_frames
, 1);
2410 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2411 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2412 WINDOW must be a live window and defaults to the selected one. The
2413 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2416 MINIBUF nil or omitted means consider the minibuffer window only if the
2417 minibuffer is active. MINIBUF t means consider the minibuffer window
2418 even if the minibuffer is not active. Any other value means do not
2419 consider the minibuffer window even if the minibuffer is active.
2421 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2422 plus the minibuffer window if specified by the MINIBUF argument. If the
2423 minibuffer counts, consider all windows on all frames that share that
2424 minibuffer too. The following non-nil values of ALL-FRAMES have special
2427 - t means consider all windows on all existing frames.
2429 - `visible' means consider all windows on all visible frames.
2431 - 0 (the number zero) means consider all windows on all visible and
2434 - A frame means consider all windows on that frame only.
2436 Anything else means consider all windows on WINDOW's frame and no
2439 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2440 use `previous-window' to iterate through the entire cycle of
2441 acceptable windows, eventually ending up back at the window you
2442 started with. `next-window' traverses the same cycle, in the
2444 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2446 return next_window (window
, minibuf
, all_frames
, 0);
2450 /* Return a list of windows in cyclic ordering. Arguments are like
2451 for `next-window'. */
2454 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2456 Lisp_Object tail
, list
, rest
;
2458 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2461 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2462 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2463 list
= Fcons (XCAR (tail
), list
);
2465 /* Rotate the list to start with WINDOW. */
2466 list
= Fnreverse (list
);
2467 rest
= Fmemq (window
, list
);
2468 if (!NILP (rest
) && !EQ (rest
, list
))
2470 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2472 XSETCDR (tail
, Qnil
);
2473 list
= nconc2 (rest
, list
);
2479 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2480 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2481 FRAME nil or omitted means use the selected frame.
2482 WINDOW nil or omitted means use the window selected within FRAME.
2483 MINIBUF t means include the minibuffer window, even if it isn't active.
2484 MINIBUF nil or omitted means include the minibuffer window only
2486 MINIBUF neither nil nor t means never include the minibuffer window. */)
2487 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2490 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2491 CHECK_WINDOW (window
);
2493 frame
= selected_frame
;
2495 if (!EQ (frame
, XWINDOW (window
)->frame
))
2496 error ("Window is on a different frame");
2498 return window_list_1 (window
, minibuf
, frame
);
2502 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2503 doc
: /* Return a list of all live windows.
2504 WINDOW specifies the first window to list and defaults to the selected
2507 Optional argument MINIBUF nil or omitted means consider the minibuffer
2508 window only if the minibuffer is active. MINIBUF t means consider the
2509 minibuffer window even if the minibuffer is not active. Any other value
2510 means do not consider the minibuffer window even if the minibuffer is
2513 Optional argument ALL-FRAMES nil or omitted means consider all windows
2514 on WINDOW's frame, plus the minibuffer window if specified by the
2515 MINIBUF argument. If the minibuffer counts, consider all windows on all
2516 frames that share that minibuffer too. The following non-nil values of
2517 ALL-FRAMES have special meanings:
2519 - t means consider all windows on all existing frames.
2521 - `visible' means consider all windows on all visible frames.
2523 - 0 (the number zero) means consider all windows on all visible and
2526 - A frame means consider all windows on that frame only.
2528 Anything else means consider all windows on WINDOW's frame and no
2531 If WINDOW is not on the list of windows returned, some other window will
2532 be listed first but no error is signaled. */)
2533 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2535 return window_list_1 (window
, minibuf
, all_frames
);
2538 /* Look at all windows, performing an operation specified by TYPE
2540 If FRAMES is Qt, look at all frames;
2541 Qnil, look at just the selected frame;
2542 Qvisible, look at visible frames;
2543 a frame, just look at windows on that frame.
2544 If MINI is non-zero, perform the operation on minibuffer windows too. */
2549 GET_BUFFER_WINDOW
, /* Arg is buffer */
2550 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2551 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2556 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2558 Lisp_Object window
, windows
, best_window
, frame_arg
;
2559 int frame_best_window_flag
= 0;
2561 struct gcpro gcpro1
;
2563 /* If we're only looping through windows on a particular frame,
2564 frame points to that frame. If we're looping through windows
2565 on all frames, frame is 0. */
2566 if (FRAMEP (frames
))
2567 f
= XFRAME (frames
);
2568 else if (NILP (frames
))
2569 f
= SELECTED_FRAME ();
2574 frame_arg
= Qlambda
;
2575 else if (EQ (frames
, make_number (0)))
2577 else if (EQ (frames
, Qvisible
))
2582 /* frame_arg is Qlambda to stick to one frame,
2583 Qvisible to consider all visible frames,
2586 /* Pick a window to start with. */
2590 window
= FRAME_SELECTED_WINDOW (f
);
2592 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2594 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2598 for (; CONSP (windows
); windows
= XCDR (windows
))
2602 window
= XCAR (windows
);
2603 w
= XWINDOW (window
);
2605 /* Note that we do not pay attention here to whether the frame
2606 is visible, since Fwindow_list skips non-visible frames if
2607 that is desired, under the control of frame_arg. */
2608 if (!MINI_WINDOW_P (w
)
2609 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2610 consider all windows. */
2611 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2612 || (mini
&& minibuf_level
> 0))
2615 case GET_BUFFER_WINDOW
:
2616 if (EQ (w
->buffer
, obj
)
2617 /* Don't find any minibuffer window except the one that
2618 is currently in use. */
2619 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2621 if (EQ (window
, selected_window
))
2622 /* Preferably return the selected window. */
2623 RETURN_UNGCPRO (window
);
2624 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2625 && !frame_best_window_flag
)
2626 /* Prefer windows on the current frame (but don't
2627 choose another one if we have one already). */
2629 best_window
= window
;
2630 frame_best_window_flag
= 1;
2632 else if (NILP (best_window
))
2633 best_window
= window
;
2637 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2638 /* We could simply check whether the buffer shown by window
2639 is live, and show another buffer in case it isn't. */
2640 if (EQ (w
->buffer
, obj
))
2642 /* Undedicate WINDOW. */
2643 wset_dedicated (w
, Qnil
);
2644 /* Make WINDOW show the buffer returned by
2645 other_buffer_safely, don't run any hooks. */
2647 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2648 /* If WINDOW is the selected window, make its buffer
2649 current. But do so only if the window shows the
2650 current buffer (Bug#6454). */
2651 if (EQ (window
, selected_window
)
2652 && XBUFFER (w
->buffer
) == current_buffer
)
2653 Fset_buffer (w
->buffer
);
2657 case REDISPLAY_BUFFER_WINDOWS
:
2658 if (EQ (w
->buffer
, obj
))
2660 mark_window_display_accurate (window
, 0);
2661 w
->update_mode_line
= 1;
2662 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2663 ++update_mode_lines
;
2664 best_window
= window
;
2668 /* Check for a window that has a killed buffer. */
2669 case CHECK_ALL_WINDOWS
:
2670 if (! NILP (w
->buffer
)
2671 && !BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
2675 case WINDOW_LOOP_UNUSED
:
2684 /* Used for debugging. Abort if any window has a dead buffer. */
2686 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2688 check_all_windows (void)
2690 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2693 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2694 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2695 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2698 The optional argument ALL-FRAMES specifies the frames to consider:
2700 - t means consider all windows on all existing frames.
2702 - `visible' means consider all windows on all visible frames.
2704 - 0 (the number zero) means consider all windows on all visible
2705 and iconified frames.
2707 - A frame means consider all windows on that frame only.
2709 Any other value of ALL-FRAMES means consider all windows on the
2710 selected frame and no others. */)
2711 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2715 if (NILP (buffer_or_name
))
2716 buffer
= Fcurrent_buffer ();
2718 buffer
= Fget_buffer (buffer_or_name
);
2720 if (BUFFERP (buffer
))
2721 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2727 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2729 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2733 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2734 Sdelete_other_windows_internal
, 0, 2, "",
2735 doc
: /* Make WINDOW fill its frame.
2736 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2737 and defaults to the selected one.
2739 Optional argument ROOT, if non-nil, must specify an internal window such
2740 that WINDOW is in its window subtree. If this is the case, replace ROOT
2741 by WINDOW and leave alone any windows not part of ROOT's subtree.
2743 When WINDOW is live try to reduce display jumps by keeping the text
2744 previously visible in WINDOW in the same place on the frame. Doing this
2745 depends on the value of (window-start WINDOW), so if calling this
2746 function in a program gives strange scrolling, make sure the
2747 window-start value is reasonable when this function is called. */)
2748 (Lisp_Object window
, Lisp_Object root
)
2750 struct window
*w
, *r
, *s
;
2752 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2753 ptrdiff_t startpos
IF_LINT (= 0), startbyte
IF_LINT (= 0);
2754 int top
IF_LINT (= 0), new_top
, resize_failed
;
2756 w
= decode_valid_window (window
);
2757 XSETWINDOW (window
, w
);
2758 f
= XFRAME (w
->frame
);
2761 /* ROOT is the frame's root window. */
2763 root
= FRAME_ROOT_WINDOW (f
);
2767 /* ROOT must be an ancestor of WINDOW. */
2769 r
= decode_valid_window (root
);
2770 pwindow
= XWINDOW (window
)->parent
;
2771 while (!NILP (pwindow
))
2772 if (EQ (pwindow
, root
))
2775 pwindow
= XWINDOW (pwindow
)->parent
;
2776 if (!EQ (pwindow
, root
))
2777 error ("Specified root is not an ancestor of specified window");
2780 if (EQ (window
, root
))
2783 /* I don't understand the "top > 0" part below. If we deal with a
2784 standalone minibuffer it would have been caught by the preceding
2786 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2787 error ("Can't expand minibuffer to full frame");
2789 if (!NILP (w
->buffer
))
2791 startpos
= marker_position (w
->start
);
2792 startbyte
= marker_byte_position (w
->start
);
2793 top
= WINDOW_TOP_EDGE_LINE (w
)
2794 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2795 /* Make sure WINDOW is the frame's selected window. */
2796 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2798 if (EQ (selected_frame
, w
->frame
))
2799 Fselect_window (window
, Qnil
);
2801 fset_selected_window (f
, window
);
2806 /* See if the frame's selected window is a part of the window
2807 subtree rooted at WINDOW, by finding all the selected window's
2808 parents and comparing each one with WINDOW. If it isn't we
2809 need a new selected window for this frame. */
2810 swindow
= FRAME_SELECTED_WINDOW (f
);
2814 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2815 pwindow
= XWINDOW (pwindow
)->parent
;
2817 if (EQ (window
, pwindow
))
2818 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2819 as the new selected window. */
2822 /* Else try the previous window of SWINDOW. */
2823 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2826 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2828 if (EQ (selected_frame
, w
->frame
))
2829 Fselect_window (swindow
, Qnil
);
2831 fset_selected_window (f
, swindow
);
2836 if (!FRAME_INITIAL_P (f
))
2838 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2840 /* We are going to free the glyph matrices of WINDOW, and with
2841 that we might lose any information about glyph rows that have
2842 some of their glyphs highlighted in mouse face. (These rows
2843 are marked with a non-zero mouse_face_p flag.) If WINDOW
2844 indeed has some glyphs highlighted in mouse face, signal to
2845 frame's up-to-date hook that mouse highlight was overwritten,
2846 so that it will arrange for redisplaying the highlight. */
2847 if (EQ (hlinfo
->mouse_face_window
, window
))
2849 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2850 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2851 hlinfo
->mouse_face_window
= Qnil
;
2854 free_window_matrices (r
);
2856 windows_or_buffers_changed
++;
2857 Vwindow_list
= Qnil
;
2858 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2861 if (NILP (w
->buffer
))
2863 /* Resize child windows vertically. */
2864 XSETINT (delta
, XINT (r
->total_lines
)
2865 - XINT (w
->total_lines
));
2866 wset_top_line (w
, r
->top_line
);
2867 resize_root_window (window
, delta
, Qnil
, Qnil
);
2868 if (window_resize_check (w
, 0))
2869 window_resize_apply (w
, 0);
2872 resize_root_window (window
, delta
, Qnil
, Qt
);
2873 if (window_resize_check (w
, 0))
2874 window_resize_apply (w
, 0);
2879 /* Resize child windows horizontally. */
2882 wset_left_col (w
, r
->left_col
);
2884 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2885 wset_left_col (w
, r
->left_col
);
2886 resize_root_window (window
, delta
, Qt
, Qnil
);
2887 if (window_resize_check (w
, 1))
2888 window_resize_apply (w
, 1);
2891 resize_root_window (window
, delta
, Qt
, Qt
);
2892 if (window_resize_check (w
, 1))
2893 window_resize_apply (w
, 1);
2900 /* Play safe, if we still can ... */
2903 w
= XWINDOW (window
);
2907 /* Cleanly unlink WINDOW from window-tree. */
2908 if (!NILP (w
->prev
))
2909 /* Get SIBLING above (on the left of) WINDOW. */
2912 s
= XWINDOW (sibling
);
2913 wset_next (s
, w
->next
);
2914 if (!NILP (s
->next
))
2915 wset_prev (XWINDOW (s
->next
), sibling
);
2918 /* Get SIBLING below (on the right of) WINDOW. */
2921 s
= XWINDOW (sibling
);
2922 wset_prev (s
, Qnil
);
2923 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2924 wset_vchild (XWINDOW (w
->parent
), sibling
);
2926 wset_hchild (XWINDOW (w
->parent
), sibling
);
2929 /* Delete ROOT and all child windows of ROOT. */
2930 if (!NILP (r
->vchild
))
2932 delete_all_child_windows (r
->vchild
);
2933 wset_vchild (r
, Qnil
);
2935 else if (!NILP (r
->hchild
))
2937 delete_all_child_windows (r
->hchild
);
2938 wset_hchild (r
, Qnil
);
2941 replace_window (root
, window
, 1);
2943 /* This must become SWINDOW anyway ....... */
2944 if (!NILP (w
->buffer
) && !resize_failed
)
2946 /* Try to minimize scrolling, by setting the window start to the
2947 point will cause the text at the old window start to be at the
2948 same place on the frame. But don't try to do this if the
2949 window start is outside the visible portion (as might happen
2950 when the display is not current, due to typeahead). */
2951 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2953 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2954 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2956 struct position pos
;
2957 struct buffer
*obuf
= current_buffer
;
2959 Fset_buffer (w
->buffer
);
2960 /* This computation used to temporarily move point, but that
2961 can have unwanted side effects due to text properties. */
2962 pos
= *vmotion (startpos
, startbyte
, -top
, w
);
2964 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2965 w
->window_end_valid
= 0;
2966 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2967 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2968 /* We need to do this, so that the window-scroll-functions
2970 w
->optional_new_start
= 1;
2972 set_buffer_internal (obuf
);
2979 run_window_configuration_change_hook (f
);
2986 replace_buffer_in_windows (Lisp_Object buffer
)
2988 call1 (Qreplace_buffer_in_windows
, buffer
);
2991 /* If BUFFER is shown in a window, safely replace it with some other
2992 buffer in all windows of all frames, even those on other keyboards. */
2995 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2997 if (buffer_window_count (XBUFFER (buffer
)))
2999 Lisp_Object tail
, frame
;
3001 /* A single call to window_loop won't do the job because it only
3002 considers frames on the current keyboard. So loop manually over
3003 frames, and handle each one. */
3004 FOR_EACH_FRAME (tail
, frame
)
3005 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
3009 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
3010 minimum allowable size. */
3013 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
3015 /* For height, we have to see:
3016 how many windows the frame has at minimum (one or two),
3017 and whether it has a menu bar or other special stuff at the top. */
3019 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
3020 ? MIN_SAFE_WINDOW_HEIGHT
3021 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
3023 if (FRAME_TOP_MARGIN (frame
) > 0)
3024 min_height
+= FRAME_TOP_MARGIN (frame
);
3026 if (*rows
< min_height
)
3028 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
3029 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3032 /* Adjust the margins of window W if text area is too small.
3033 Return 1 if window width is ok after adjustment; 0 if window
3034 is still too narrow. */
3037 adjust_window_margins (struct window
*w
)
3039 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3040 - WINDOW_FRINGE_COLS (w
)
3041 - WINDOW_SCROLL_BAR_COLS (w
));
3042 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3043 + WINDOW_RIGHT_MARGIN_COLS (w
));
3045 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3048 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3051 /* Window's text area is too narrow, but reducing the window
3052 margins will fix that. */
3053 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3054 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3056 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3058 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3059 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3062 wset_right_margin_cols (w
, make_number (margin_cols
));
3065 wset_left_margin_cols (w
, make_number (margin_cols
));
3069 /* The following three routines are needed for running a window's
3070 configuration change hook. */
3072 run_funs (Lisp_Object funs
)
3074 for (; CONSP (funs
); funs
= XCDR (funs
))
3075 if (!EQ (XCAR (funs
), Qt
))
3076 call0 (XCAR (funs
));
3080 select_window_norecord (Lisp_Object window
)
3082 return WINDOW_LIVE_P (window
)
3083 ? Fselect_window (window
, Qt
) : selected_window
;
3087 select_frame_norecord (Lisp_Object frame
)
3089 return FRAME_LIVE_P (XFRAME (frame
))
3090 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3094 run_window_configuration_change_hook (struct frame
*f
)
3096 ptrdiff_t count
= SPECPDL_INDEX ();
3097 Lisp_Object frame
, global_wcch
3098 = Fdefault_value (Qwindow_configuration_change_hook
);
3099 XSETFRAME (frame
, f
);
3101 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3104 /* Use the right buffer. Matters when running the local hooks. */
3105 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3107 record_unwind_current_buffer ();
3108 Fset_buffer (Fwindow_buffer (Qnil
));
3111 if (SELECTED_FRAME () != f
)
3113 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3114 select_frame_norecord (frame
);
3117 /* Look for buffer-local values. */
3119 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3120 for (; CONSP (windows
); windows
= XCDR (windows
))
3122 Lisp_Object window
= XCAR (windows
);
3123 Lisp_Object buffer
= Fwindow_buffer (window
);
3124 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3127 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3128 record_unwind_protect (select_window_norecord
, Fselected_window ());
3129 select_window_norecord (window
);
3130 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3132 unbind_to (inner_count
, Qnil
);
3137 run_funs (global_wcch
);
3138 unbind_to (count
, Qnil
);
3141 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3142 Srun_window_configuration_change_hook
, 0, 1, 0,
3143 doc
: /* Run `window-configuration-change-hook' for FRAME.
3144 If FRAME is omitted or nil, it defaults to the selected frame. */)
3147 run_window_configuration_change_hook (decode_live_frame (frame
));
3151 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3152 means it's allowed to run hooks. See make_frame for a case where
3153 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3154 margins, fringes, and scroll-bar settings of the window are not
3155 reset from the buffer's local settings. */
3158 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
,
3159 bool run_hooks_p
, bool keep_margins_p
)
3161 struct window
*w
= XWINDOW (window
);
3162 struct buffer
*b
= XBUFFER (buffer
);
3163 ptrdiff_t count
= SPECPDL_INDEX ();
3164 int samebuf
= EQ (buffer
, w
->buffer
);
3166 wset_buffer (w
, buffer
);
3168 if (EQ (window
, selected_window
))
3169 bset_last_selected_window (b
, window
);
3171 /* Let redisplay errors through. */
3172 b
->display_error_modiff
= 0;
3174 /* Update time stamps of buffer display. */
3175 if (INTEGERP (BVAR (b
, display_count
)))
3176 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3177 bset_display_time (b
, Fcurrent_time ());
3179 wset_window_end_pos (w
, make_number (0));
3180 wset_window_end_vpos (w
, make_number (0));
3181 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3183 if (!(keep_margins_p
&& samebuf
))
3184 { /* If we're not actually changing the buffer, don't reset hscroll and
3185 vscroll. This case happens for example when called from
3186 change_frame_size_1, where we use a dummy call to
3187 Fset_window_buffer on the frame's selected window (and no other)
3188 just in order to run window-configuration-change-hook.
3189 Resetting hscroll and vscroll here is problematic for things like
3190 image-mode and doc-view-mode since it resets the image's position
3191 whenever we resize the frame. */
3192 w
->hscroll
= w
->min_hscroll
= 0;
3194 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3195 set_marker_restricted (w
->start
,
3196 make_number (b
->last_window_start
),
3198 w
->start_at_line_beg
= 0;
3200 w
->last_modified
= 0;
3201 w
->last_overlay_modified
= 0;
3203 /* Maybe we could move this into the `if' but it's not obviously safe and
3204 I doubt it's worth the trouble. */
3205 windows_or_buffers_changed
++;
3207 /* We must select BUFFER for running the window-scroll-functions. */
3208 /* We can't check ! NILP (Vwindow_scroll_functions) here
3209 because that might itself be a local variable. */
3210 if (window_initialized
)
3212 record_unwind_current_buffer ();
3213 Fset_buffer (buffer
);
3216 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3218 if (!keep_margins_p
)
3220 /* Set left and right marginal area width etc. from buffer. */
3222 /* This may call adjust_window_margins three times, so
3223 temporarily disable window margins. */
3224 Lisp_Object save_left
= w
->left_margin_cols
;
3225 Lisp_Object save_right
= w
->right_margin_cols
;
3227 wset_left_margin_cols (w
, Qnil
);
3228 wset_right_margin_cols (w
, Qnil
);
3230 Fset_window_fringes (window
,
3231 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3232 BVAR (b
, fringes_outside_margins
));
3234 Fset_window_scroll_bars (window
,
3235 BVAR (b
, scroll_bar_width
),
3236 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3238 wset_left_margin_cols (w
, save_left
);
3239 wset_right_margin_cols (w
, save_right
);
3241 Fset_window_margins (window
,
3242 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3247 if (! NILP (Vwindow_scroll_functions
))
3248 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3249 Fmarker_position (w
->start
));
3250 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3253 unbind_to (count
, Qnil
);
3256 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3257 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3258 WINDOW must be a live window and defaults to the selected one.
3259 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3261 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3262 display margins, fringe widths, and scroll bar settings are preserved;
3263 the default is to reset these from the local settings for BUFFER-OR-NAME
3264 or the frame defaults. Return nil.
3266 This function throws an error when WINDOW is strongly dedicated to its
3267 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3268 already display BUFFER-OR-NAME.
3270 This function runs `window-scroll-functions' before running
3271 `window-configuration-change-hook'. */)
3272 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3274 register Lisp_Object tem
, buffer
;
3275 register struct window
*w
= decode_live_window (window
);
3277 XSETWINDOW (window
, w
);
3278 buffer
= Fget_buffer (buffer_or_name
);
3279 CHECK_BUFFER (buffer
);
3280 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3281 error ("Attempt to display deleted buffer");
3285 error ("Window is deleted");
3288 if (!EQ (tem
, buffer
))
3290 if (EQ (w
->dedicated
, Qt
))
3291 /* WINDOW is strongly dedicated to its buffer, signal an
3293 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3295 /* WINDOW is weakly dedicated to its buffer, reset
3297 wset_dedicated (w
, Qnil
);
3299 call1 (Qrecord_window_buffer
, window
);
3305 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3311 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3313 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3316 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3318 doc
: /* Force all windows to be updated on next redisplay.
3319 If optional arg OBJECT is a window, force redisplay of that window only.
3320 If OBJECT is a buffer or buffer name, force redisplay of all windows
3321 displaying that buffer. */)
3322 (Lisp_Object object
)
3326 windows_or_buffers_changed
++;
3327 update_mode_lines
++;
3331 if (WINDOWP (object
))
3333 struct window
*w
= XWINDOW (object
);
3334 mark_window_display_accurate (object
, 0);
3335 w
->update_mode_line
= 1;
3336 if (BUFFERP (w
->buffer
))
3337 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3338 ++update_mode_lines
;
3342 if (STRINGP (object
))
3343 object
= Fget_buffer (object
);
3344 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
))
3345 && buffer_window_count (XBUFFER (object
)))
3347 /* If buffer is live and shown in at least one window, find
3348 all windows showing this buffer and force update of them. */
3349 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3350 return NILP (object
) ? Qnil
: Qt
;
3353 /* If nothing suitable was found, just return.
3354 We could signal an error, but this feature will typically be used
3355 asynchronously in timers or process sentinels, so we don't. */
3359 /* Obsolete since 24.3. */
3361 temp_output_buffer_show (register Lisp_Object buf
)
3363 register struct buffer
*old
= current_buffer
;
3364 register Lisp_Object window
;
3365 register struct window
*w
;
3367 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3370 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3374 set_buffer_internal (old
);
3376 if (!NILP (Vtemp_buffer_show_function
))
3377 call1 (Vtemp_buffer_show_function
, buf
);
3380 window
= display_buffer (buf
, Qnil
, Qnil
);
3382 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3383 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3384 Vminibuf_scroll_window
= window
;
3385 w
= XWINDOW (window
);
3388 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3389 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3391 /* Run temp-buffer-show-hook, with the chosen window selected
3392 and its buffer current. */
3394 ptrdiff_t count
= SPECPDL_INDEX ();
3395 Lisp_Object prev_window
, prev_buffer
;
3396 prev_window
= selected_window
;
3397 XSETBUFFER (prev_buffer
, old
);
3399 /* Select the window that was chosen, for running the hook.
3400 Note: Both Fselect_window and select_window_norecord may
3401 set-buffer to the buffer displayed in the window,
3402 so we need to save the current buffer. --stef */
3403 record_unwind_protect (Fset_buffer
, prev_buffer
);
3404 record_unwind_protect (select_window_norecord
, prev_window
);
3405 Fselect_window (window
, Qt
);
3406 Fset_buffer (w
->buffer
);
3407 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3408 unbind_to (count
, Qnil
);
3413 /* Make new window, have it replace WINDOW in window-tree, and make
3414 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3415 horizontal child). */
3417 make_parent_window (Lisp_Object window
, bool horflag
)
3420 register struct window
*o
, *p
;
3422 o
= XWINDOW (window
);
3423 p
= allocate_window ();
3424 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3425 (char *) o
+ sizeof (struct vectorlike_header
),
3426 word_size
* VECSIZE (struct window
));
3427 /* P's buffer slot may change from nil to a buffer. */
3428 adjust_window_count (p
, 1);
3429 XSETWINDOW (parent
, p
);
3431 replace_window (window
, parent
, 1);
3433 wset_next (o
, Qnil
);
3434 wset_prev (o
, Qnil
);
3435 wset_parent (o
, parent
);
3437 wset_hchild (p
, horflag
? window
: Qnil
);
3438 wset_vchild (p
, horflag
? Qnil
: window
);
3439 wset_start (p
, Qnil
);
3440 wset_pointm (p
, Qnil
);
3441 wset_buffer (p
, Qnil
);
3442 wset_combination_limit (p
, Qnil
);
3443 wset_window_parameters (p
, Qnil
);
3446 /* Make new window from scratch. */
3451 register struct window
*w
;
3453 w
= allocate_window ();
3454 /* Initialize Lisp data. Note that allocate_window initializes all
3455 Lisp data to nil, so do it only for slots which should not be nil. */
3456 wset_left_col (w
, make_number (0));
3457 wset_top_line (w
, make_number (0));
3458 wset_total_lines (w
, make_number (0));
3459 wset_total_cols (w
, make_number (0));
3460 wset_normal_lines (w
, make_float (1.0));
3461 wset_normal_cols (w
, make_float (1.0));
3462 wset_new_total (w
, make_number (0));
3463 wset_new_normal (w
, make_number (0));
3464 wset_start (w
, Fmake_marker ());
3465 wset_pointm (w
, Fmake_marker ());
3466 wset_vertical_scroll_bar_type (w
, Qt
);
3467 wset_window_end_pos (w
, make_number (0));
3468 wset_window_end_vpos (w
, make_number (0));
3469 /* These Lisp fields are marked specially so they're not set to nil by
3471 wset_prev_buffers (w
, Qnil
);
3472 wset_next_buffers (w
, Qnil
);
3474 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3475 non-Lisp data, so do it only for slots which should not be zero. */
3476 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3477 w
->phys_cursor_type
= -1;
3478 w
->phys_cursor_width
= -1;
3479 w
->column_number_displayed
= -1;
3481 /* Reset window_list. */
3482 Vwindow_list
= Qnil
;
3483 /* Return window. */
3484 XSETWINDOW (window
, w
);
3488 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3489 doc
: /* Set new total size of WINDOW to SIZE.
3490 WINDOW must be a valid window and defaults to the selected one.
3493 Optional argument ADD non-nil means add SIZE to the new total size of
3494 WINDOW and return the sum.
3496 Note: This function does not operate on any child windows of WINDOW. */)
3497 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3499 struct window
*w
= decode_valid_window (window
);
3501 CHECK_NUMBER (size
);
3503 wset_new_total (w
, size
);
3505 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3507 return w
->new_total
;
3510 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3511 doc
: /* Set new normal size of WINDOW to SIZE.
3512 WINDOW must be a valid window and defaults to the selected one.
3515 Note: This function does not operate on any child windows of WINDOW. */)
3516 (Lisp_Object window
, Lisp_Object size
)
3518 wset_new_normal (decode_valid_window (window
), size
);
3522 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3523 non-zero) to w->new_total would result in correct heights (widths)
3524 for window W and recursively all child windows of W.
3526 Note: This function does not check any of `window-fixed-size-p',
3527 `window-min-height' or `window-min-width'. It does check that window
3528 sizes do not drop below one line (two columns). */
3530 window_resize_check (struct window
*w
, bool horflag
)
3534 if (!NILP (w
->vchild
))
3535 /* W is a vertical combination. */
3537 c
= XWINDOW (w
->vchild
);
3539 /* All child windows of W must have the same width as W. */
3543 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3544 || !window_resize_check (c
, horflag
))
3546 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3551 /* The sum of the heights of the child windows of W must equal
3554 int sum_of_sizes
= 0;
3557 if (!window_resize_check (c
, horflag
))
3559 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3560 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3562 return (sum_of_sizes
== XINT (w
->new_total
));
3565 else if (!NILP (w
->hchild
))
3566 /* W is a horizontal combination. */
3568 c
= XWINDOW (w
->hchild
);
3570 /* The sum of the widths of the child windows of W must equal W's
3573 int sum_of_sizes
= 0;
3576 if (!window_resize_check (c
, horflag
))
3578 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3579 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3581 return (sum_of_sizes
== XINT (w
->new_total
));
3584 /* All child windows of W must have the same height as W. */
3588 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3589 || !window_resize_check (c
, horflag
))
3591 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3597 /* A leaf window. Make sure it's not too small. The following
3598 hardcodes the values of `window-safe-min-width' (2) and
3599 `window-safe-min-height' (1) which are defined in window.el. */
3600 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3603 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3604 w->new_total for window W and recursively all child windows of W.
3605 Also calculate and assign the new vertical (horizontal) start
3606 positions of each of these windows.
3608 This function does not perform any error checks. Make sure you have
3609 run window_resize_check on W before applying this function. */
3611 window_resize_apply (struct window
*w
, bool horflag
)
3616 /* Note: Assigning new_normal requires that the new total size of the
3617 parent window has been set *before*. */
3620 wset_total_cols (w
, w
->new_total
);
3621 if (NUMBERP (w
->new_normal
))
3622 wset_normal_cols (w
, w
->new_normal
);
3624 pos
= XINT (w
->left_col
);
3628 wset_total_lines (w
, w
->new_total
);
3629 if (NUMBERP (w
->new_normal
))
3630 wset_normal_lines (w
, w
->new_normal
);
3632 pos
= XINT (w
->top_line
);
3635 if (!NILP (w
->vchild
))
3636 /* W is a vertical combination. */
3638 c
= XWINDOW (w
->vchild
);
3642 wset_left_col (c
, make_number (pos
));
3644 wset_top_line (c
, make_number (pos
));
3645 window_resize_apply (c
, horflag
);
3647 pos
= pos
+ XINT (c
->total_lines
);
3648 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3651 else if (!NILP (w
->hchild
))
3652 /* W is a horizontal combination. */
3654 c
= XWINDOW (w
->hchild
);
3658 wset_left_col (c
, make_number (pos
));
3660 wset_top_line (c
, make_number (pos
));
3661 window_resize_apply (c
, horflag
);
3663 pos
= pos
+ XINT (c
->total_cols
);
3664 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3668 /* Clear out some redisplay caches. */
3669 w
->last_modified
= 0;
3670 w
->last_overlay_modified
= 0;
3674 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3675 doc
: /* Apply requested size values for window-tree of FRAME.
3676 If FRAME is omitted or nil, it defaults to the selected frame.
3678 Optional argument HORIZONTAL omitted or nil means apply requested
3679 height values. HORIZONTAL non-nil means apply requested width values.
3681 This function checks whether the requested values sum up to a valid
3682 window layout, recursively assigns the new sizes of all child windows
3683 and calculates and assigns the new start positions of these windows.
3685 Note: This function does not check any of `window-fixed-size-p',
3686 `window-min-height' or `window-min-width'. All these checks have to
3687 be applied on the Elisp level. */)
3688 (Lisp_Object frame
, Lisp_Object horizontal
)
3690 struct frame
*f
= decode_live_frame (frame
);
3691 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3692 bool horflag
= !NILP (horizontal
);
3694 if (!window_resize_check (r
, horflag
)
3695 || ! EQ (r
->new_total
,
3696 (horflag
? r
->total_cols
: r
->total_lines
)))
3700 window_resize_apply (r
, horflag
);
3702 windows_or_buffers_changed
++;
3703 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3708 run_window_configuration_change_hook (f
);
3714 /* Resize frame F's windows when number of lines of F is set to SIZE.
3715 HORFLAG 1 means resize windows when number of columns of F is set to
3718 This function can delete all windows but the selected one in order to
3719 satisfy the request. The result will be meaningful if and only if
3720 F's windows have meaningful sizes when you call this. */
3722 resize_frame_windows (struct frame
*f
, int size
, bool horflag
)
3724 Lisp_Object root
= f
->root_window
;
3725 struct window
*r
= XWINDOW (root
);
3726 Lisp_Object mini
= f
->minibuffer_window
;
3728 /* new_size is the new size of the frame's root window. */
3729 int new_size
= (horflag
3732 - FRAME_TOP_MARGIN (f
)
3733 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3736 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3737 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3738 /* For a leaf root window just set the size. */
3740 wset_total_cols (r
, make_number (new_size
));
3742 wset_total_lines (r
, make_number (new_size
));
3745 /* old_size is the old size of the frame's root window. */
3746 int old_size
= XFASTINT (horflag
? r
->total_cols
3750 XSETINT (delta
, new_size
- old_size
);
3751 /* Try a "normal" resize first. */
3752 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3753 if (window_resize_check (r
, horflag
)
3754 && new_size
== XINT (r
->new_total
))
3755 window_resize_apply (r
, horflag
);
3758 /* Try with "reasonable" minimum sizes next. */
3759 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3760 if (window_resize_check (r
, horflag
)
3761 && new_size
== XINT (r
->new_total
))
3762 window_resize_apply (r
, horflag
);
3765 /* Finally, try with "safe" minimum sizes. */
3766 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3767 if (window_resize_check (r
, horflag
)
3768 && new_size
== XINT (r
->new_total
))
3769 window_resize_apply (r
, horflag
);
3772 /* We lost. Delete all windows but the frame's
3774 root
= f
->selected_window
;
3775 Fdelete_other_windows_internal (root
, Qnil
);
3777 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3779 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3785 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3789 wset_total_cols (m
, make_number (size
));
3792 /* Are we sure we always want 1 line here? */
3793 wset_total_lines (m
, make_number (1));
3795 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3799 windows_or_buffers_changed
++;
3803 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3804 doc
: /* Split window OLD.
3805 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3806 new window. In any case TOTAL-SIZE must be a positive integer.
3808 Third argument SIDE nil (or `below') specifies that the new window shall
3809 be located below WINDOW. SIDE `above' means the new window shall be
3810 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3811 lines of the new window including space reserved for the mode and/or
3814 SIDE t (or `right') specifies that the new window shall be located on
3815 the right side of WINDOW. SIDE `left' means the new window shall be
3816 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3817 number of columns of the new window including space reserved for fringes
3818 and the scrollbar or a divider column.
3820 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3821 according to the SIDE argument.
3823 The new total and normal sizes of all involved windows must have been
3824 set correctly. See the code of `split-window' for how this is done. */)
3825 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3827 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3828 parent window or an internal window we have to install as OLD's new
3829 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3830 provided OLD is a leaf window, or to the frame's selected window.
3831 NEW (*n) is the new window created with some parameters taken from
3833 register Lisp_Object
new, frame
, reference
;
3834 register struct window
*o
, *p
, *n
, *r
;
3837 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3838 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3839 int combination_limit
= 0;
3843 frame
= WINDOW_FRAME (o
);
3846 CHECK_NUMBER (total_size
);
3848 /* Set combination_limit to 1 if we have to make a new parent window.
3849 We do that if either `window-combination-limit' is t, or OLD has no
3850 parent, or OLD is ortho-combined. */
3852 EQ (Vwindow_combination_limit
, Qt
)
3855 ? (XWINDOW (o
->parent
)->hchild
)
3856 : (XWINDOW (o
->parent
)->vchild
));
3858 /* We need a live reference window to initialize some parameters. */
3859 if (WINDOW_LIVE_P (old
))
3860 /* OLD is live, use it as reference window. */
3863 /* Use the frame's selected window as reference window. */
3864 reference
= FRAME_SELECTED_WINDOW (f
);
3865 r
= XWINDOW (reference
);
3867 /* The following bugs are caught by `split-window'. */
3868 if (MINI_WINDOW_P (o
))
3869 error ("Attempt to split minibuffer window");
3870 else if (XINT (total_size
) < (horflag
? 2 : 1))
3871 error ("Size of new window too small (after split)");
3872 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3873 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3876 p
= XWINDOW (o
->parent
);
3877 /* Temporarily pretend we split the parent window. */
3879 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3880 - XINT (total_size
)));
3881 if (!window_resize_check (p
, horflag
))
3882 error ("Window sizes don't fit");
3884 /* Undo the temporary pretension. */
3885 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3889 if (!window_resize_check (o
, horflag
))
3890 error ("Resizing old window failed");
3891 else if (XINT (total_size
) + XINT (o
->new_total
)
3892 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3893 error ("Sum of sizes of old and new window don't fit");
3896 /* This is our point of no return. */
3897 if (combination_limit
)
3899 /* Save the old value of o->normal_cols/lines. It gets corrupted
3900 by make_parent_window and we need it below for assigning it to
3902 Lisp_Object new_normal
3903 = horflag
? o
->normal_cols
: o
->normal_lines
;
3905 make_parent_window (old
, horflag
);
3906 p
= XWINDOW (o
->parent
);
3907 if (EQ (Vwindow_combination_limit
, Qt
))
3908 /* Store t in the new parent's combination_limit slot to avoid
3909 that its children get merged into another window. */
3910 wset_combination_limit (p
, Qt
);
3911 /* These get applied below. */
3912 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3913 wset_new_normal (p
, new_normal
);
3916 p
= XWINDOW (o
->parent
);
3918 windows_or_buffers_changed
++;
3919 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3920 new = make_window ();
3922 wset_frame (n
, frame
);
3923 wset_parent (n
, o
->parent
);
3924 wset_vchild (n
, Qnil
);
3925 wset_hchild (n
, Qnil
);
3927 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3929 wset_prev (n
, o
->prev
);
3932 wset_hchild (p
, new);
3934 wset_vchild (p
, new);
3936 wset_next (XWINDOW (n
->prev
), new);
3942 wset_next (n
, o
->next
);
3943 if (!NILP (n
->next
))
3944 wset_prev (XWINDOW (n
->next
), new);
3949 n
->window_end_valid
= 0;
3950 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3952 /* Get special geometry settings from reference window. */
3953 wset_left_margin_cols (n
, r
->left_margin_cols
);
3954 wset_right_margin_cols (n
, r
->right_margin_cols
);
3955 wset_left_fringe_width (n
, r
->left_fringe_width
);
3956 wset_right_fringe_width (n
, r
->right_fringe_width
);
3957 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3958 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3959 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3961 /* Directly assign orthogonal coordinates and sizes. */
3964 wset_top_line (n
, o
->top_line
);
3965 wset_total_lines (n
, o
->total_lines
);
3969 wset_left_col (n
, o
->left_col
);
3970 wset_total_cols (n
, o
->total_cols
);
3973 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3974 get them ready here. */
3975 wset_new_total (n
, total_size
);
3976 wset_new_normal (n
, normal_size
);
3979 window_resize_apply (p
, horflag
);
3981 /* Set buffer of NEW to buffer of reference window. Don't run
3983 set_window_buffer (new, r
->buffer
, 0, 1);
3986 /* Maybe we should run the scroll functions in Elisp (which already
3987 runs the configuration change hook). */
3988 if (! NILP (Vwindow_scroll_functions
))
3989 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3990 Fmarker_position (n
->start
));
3996 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3997 doc
: /* Remove WINDOW from its frame.
3998 WINDOW defaults to the selected window. Return nil.
3999 Signal an error when WINDOW is the only window on its frame. */)
4000 (register Lisp_Object window
)
4002 register Lisp_Object parent
, sibling
, frame
, root
;
4003 struct window
*w
, *p
, *s
, *r
;
4006 int before_sibling
= 0;
4008 w
= decode_any_window (window
);
4009 XSETWINDOW (window
, w
);
4010 if (NILP (w
->buffer
)
4011 && NILP (w
->hchild
) && NILP (w
->vchild
))
4012 /* It's a no-op to delete an already deleted window. */
4017 /* Never delete a minibuffer or frame root window. */
4018 error ("Attempt to delete minibuffer or sole ordinary window");
4019 else if (NILP (w
->prev
) && NILP (w
->next
))
4020 /* Rather bow out here, this case should be handled on the Elisp
4022 error ("Attempt to delete sole window of parent");
4024 p
= XWINDOW (parent
);
4025 horflag
= NILP (p
->vchild
);
4027 frame
= WINDOW_FRAME (w
);
4030 root
= FRAME_ROOT_WINDOW (f
);
4033 /* Unlink WINDOW from window tree. */
4035 /* Get SIBLING below (on the right of) WINDOW. */
4037 /* before_sibling 1 means WINDOW is the first child of its
4038 parent and thus before the sibling. */
4041 s
= XWINDOW (sibling
);
4042 wset_prev (s
, Qnil
);
4044 wset_hchild (p
, sibling
);
4046 wset_vchild (p
, sibling
);
4049 /* Get SIBLING above (on the left of) WINDOW. */
4052 s
= XWINDOW (sibling
);
4053 wset_next (s
, w
->next
);
4054 if (!NILP (s
->next
))
4055 wset_prev (XWINDOW (s
->next
), sibling
);
4058 if (window_resize_check (r
, horflag
)
4059 && EQ (r
->new_total
,
4060 (horflag
? r
->total_cols
: r
->total_lines
)))
4061 /* We can delete WINDOW now. */
4066 window_resize_apply (p
, horflag
);
4068 /* If this window is referred to by the dpyinfo's mouse
4069 highlight, invalidate that slot to be safe (Bug#9904). */
4070 if (!FRAME_INITIAL_P (f
))
4072 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4074 if (EQ (hlinfo
->mouse_face_window
, window
))
4075 hlinfo
->mouse_face_window
= Qnil
;
4078 windows_or_buffers_changed
++;
4079 Vwindow_list
= Qnil
;
4080 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4082 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4083 free_window_matrices (w
);
4085 if (!NILP (w
->vchild
))
4087 delete_all_child_windows (w
->vchild
);
4088 wset_vchild (w
, Qnil
);
4090 else if (!NILP (w
->hchild
))
4092 delete_all_child_windows (w
->hchild
);
4093 wset_hchild (w
, Qnil
);
4095 else if (!NILP (w
->buffer
))
4098 unchain_marker (XMARKER (w
->pointm
));
4099 unchain_marker (XMARKER (w
->start
));
4100 wset_buffer (w
, Qnil
);
4103 if (NILP (s
->prev
) && NILP (s
->next
))
4104 /* A matrjoshka where SIBLING has become the only child of
4107 /* Put SIBLING into PARENT's place. */
4108 replace_window (parent
, sibling
, 0);
4109 /* Have SIBLING inherit the following three slot values from
4110 PARENT (the combination_limit slot is not inherited). */
4111 wset_normal_cols (s
, p
->normal_cols
);
4112 wset_normal_lines (s
, p
->normal_lines
);
4113 /* Mark PARENT as deleted. */
4114 wset_vchild (p
, Qnil
);
4115 wset_hchild (p
, Qnil
);
4116 /* Try to merge SIBLING into its new parent. */
4117 recombine_windows (sibling
);
4122 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4123 /* We deleted the frame's selected window. */
4125 /* Use the frame's first window as fallback ... */
4126 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4127 /* ... but preferably use its most recently used window. */
4128 Lisp_Object mru_window
;
4130 /* `get-mru-window' might fail for some reason so play it safe
4131 - promote the first window _without recording it_ first. */
4132 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4133 Fselect_window (new_selected_window
, Qt
);
4135 fset_selected_window (f
, new_selected_window
);
4139 /* Now look whether `get-mru-window' gets us something. */
4140 mru_window
= call1 (Qget_mru_window
, frame
);
4141 if (WINDOW_LIVE_P (mru_window
)
4142 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4143 new_selected_window
= mru_window
;
4145 /* If all ended up well, we now promote the mru window. */
4146 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4147 Fselect_window (new_selected_window
, Qnil
);
4149 fset_selected_window (f
, new_selected_window
);
4154 /* Must be run by the caller:
4155 run_window_configuration_change_hook (f); */
4158 /* We failed: Relink WINDOW into window tree. */
4162 wset_prev (s
, window
);
4164 wset_hchild (p
, window
);
4166 wset_vchild (p
, window
);
4170 wset_next (s
, window
);
4171 if (!NILP (w
->next
))
4172 wset_prev (XWINDOW (w
->next
), window
);
4174 error ("Deletion failed");
4180 /***********************************************************************
4181 Resizing Mini-Windows
4182 ***********************************************************************/
4184 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4187 grow_mini_window (struct window
*w
, int delta
)
4189 struct frame
*f
= XFRAME (w
->frame
);
4191 Lisp_Object root
, value
;
4193 eassert (MINI_WINDOW_P (w
));
4194 eassert (delta
>= 0);
4196 root
= FRAME_ROOT_WINDOW (f
);
4198 value
= call2 (Qwindow_resize_root_window_vertically
,
4199 root
, make_number (- delta
));
4200 if (INTEGERP (value
) && window_resize_check (r
, 0))
4203 window_resize_apply (r
, 0);
4205 /* Grow the mini-window. */
4207 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4209 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4210 w
->last_modified
= 0;
4211 w
->last_overlay_modified
= 0;
4213 windows_or_buffers_changed
++;
4220 /* Shrink mini-window W. */
4222 shrink_mini_window (struct window
*w
)
4224 struct frame
*f
= XFRAME (w
->frame
);
4226 Lisp_Object root
, value
;
4229 eassert (MINI_WINDOW_P (w
));
4231 size
= XINT (w
->total_lines
);
4234 root
= FRAME_ROOT_WINDOW (f
);
4236 value
= call2 (Qwindow_resize_root_window_vertically
,
4237 root
, make_number (size
- 1));
4238 if (INTEGERP (value
) && window_resize_check (r
, 0))
4241 window_resize_apply (r
, 0);
4243 /* Shrink the mini-window. */
4244 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4245 + XFASTINT (r
->total_lines
)));
4246 wset_total_lines (w
, make_number (1));
4248 w
->last_modified
= 0;
4249 w
->last_overlay_modified
= 0;
4251 windows_or_buffers_changed
++;
4255 /* If the above failed for whatever strange reason we must make a
4256 one window frame here. The same routine will be needed when
4257 shrinking the frame (and probably when making the initial
4258 *scratch* window). For the moment leave things as they are. */
4262 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4263 doc
: /* Resize minibuffer window WINDOW. */)
4264 (Lisp_Object window
)
4266 struct window
*w
= XWINDOW (window
);
4271 CHECK_WINDOW (window
);
4272 f
= XFRAME (w
->frame
);
4274 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4275 error ("Not a valid minibuffer window");
4276 else if (FRAME_MINIBUF_ONLY_P (f
))
4277 error ("Cannot resize a minibuffer-only frame");
4279 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4280 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4281 if (window_resize_check (r
, 0)
4282 && XINT (w
->new_total
) > 0
4283 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4286 window_resize_apply (r
, 0);
4288 wset_total_lines (w
, w
->new_total
);
4289 wset_top_line (w
, make_number (XINT (r
->top_line
)
4290 + XINT (r
->total_lines
)));
4292 windows_or_buffers_changed
++;
4293 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4297 run_window_configuration_change_hook (f
);
4300 else error ("Failed to resize minibuffer window");
4303 /* Mark window cursors off for all windows in the window tree rooted
4304 at W by setting their phys_cursor_on_p flag to zero. Called from
4305 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4306 the frame are cleared. */
4309 mark_window_cursors_off (struct window
*w
)
4313 if (!NILP (w
->hchild
))
4314 mark_window_cursors_off (XWINDOW (w
->hchild
));
4315 else if (!NILP (w
->vchild
))
4316 mark_window_cursors_off (XWINDOW (w
->vchild
));
4318 w
->phys_cursor_on_p
= 0;
4320 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4325 /* Return number of lines of text (not counting mode lines) in W. */
4328 window_internal_height (struct window
*w
)
4330 int ht
= XFASTINT (w
->total_lines
);
4332 if (!MINI_WINDOW_P (w
))
4334 if (!NILP (w
->parent
)
4335 || !NILP (w
->vchild
)
4336 || !NILP (w
->hchild
)
4339 || WINDOW_WANTS_MODELINE_P (w
))
4342 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4349 /************************************************************************
4351 ***********************************************************************/
4353 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4354 N screen-fulls, which is defined as the height of the window minus
4355 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4356 instead. Negative values of N mean scroll down. NOERROR non-zero
4357 means don't signal an error if we try to move over BEGV or ZV,
4361 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4364 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4366 /* If we must, use the pixel-based version which is much slower than
4367 the line-based one but can handle varying line heights. */
4368 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4369 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4371 window_scroll_line_based (window
, n
, whole
, noerror
);
4377 /* Implementation of window_scroll that works based on pixel line
4378 heights. See the comment of window_scroll for parameter
4382 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4385 struct window
*w
= XWINDOW (window
);
4386 struct text_pos start
;
4387 int this_scroll_margin
;
4388 /* True if we fiddled the window vscroll field without really scrolling. */
4390 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4391 void *itdata
= NULL
;
4393 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4394 /* Scrolling a minibuffer window via scroll bar when the echo area
4395 shows long text sometimes resets the minibuffer contents behind
4397 if (CHARPOS (start
) > ZV
)
4398 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4400 /* If PT is not visible in WINDOW, move back one half of
4401 the screen. Allow PT to be partially visible, otherwise
4402 something like (scroll-down 1) with PT in the line before
4403 the partially visible one would recenter. */
4405 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4407 itdata
= bidi_shelve_cache ();
4408 /* Move backward half the height of the window. Performance note:
4409 vmotion used here is about 10% faster, but would give wrong
4410 results for variable height lines. */
4411 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4412 it
.current_y
= it
.last_visible_y
;
4413 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4415 /* The function move_iterator_vertically may move over more than
4416 the specified y-distance. If it->w is small, e.g. a
4417 mini-buffer window, we may end up in front of the window's
4418 display area. This is the case when Start displaying at the
4419 start of the line containing PT in this case. */
4420 if (it
.current_y
<= 0)
4422 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4423 move_it_vertically_backward (&it
, 0);
4427 start
= it
.current
.pos
;
4428 bidi_unshelve_cache (itdata
, 0);
4430 else if (auto_window_vscroll_p
)
4432 if (rtop
|| rbot
) /* partially visible */
4435 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4437 dy
= max ((window_box_height (w
)
4438 - next_screen_context_lines
* dy
),
4444 /* Only vscroll backwards if already vscrolled forwards. */
4445 if (w
->vscroll
< 0 && rtop
> 0)
4447 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4448 Fset_window_vscroll (window
, make_number (px
), Qt
);
4454 /* Do vscroll if already vscrolled or only display line. */
4455 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4457 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4458 Fset_window_vscroll (window
, make_number (px
), Qt
);
4462 /* Maybe modify window start instead of scrolling. */
4463 if (rbot
> 0 || w
->vscroll
< 0)
4467 Fset_window_vscroll (window
, make_number (0), Qt
);
4468 /* If there are other text lines above the current row,
4469 move window start to current row. Else to next row. */
4471 spos
= XINT (Fline_beginning_position (Qnil
));
4473 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4474 set_marker_restricted (w
->start
, make_number (spos
),
4476 w
->start_at_line_beg
= 1;
4477 w
->update_mode_line
= 1;
4478 w
->last_modified
= 0;
4479 w
->last_overlay_modified
= 0;
4480 /* Set force_start so that redisplay_window will run the
4481 window-scroll-functions. */
4487 /* Cancel previous vscroll. */
4488 Fset_window_vscroll (window
, make_number (0), Qt
);
4491 itdata
= bidi_shelve_cache ();
4492 /* If scroll_preserve_screen_position is non-nil, we try to set
4493 point in the same window line as it is now, so get that line. */
4494 if (!NILP (Vscroll_preserve_screen_position
))
4496 /* We preserve the goal pixel coordinate across consecutive
4497 calls to scroll-up, scroll-down and other commands that
4498 have the `scroll-command' property. This avoids the
4499 possibility of point becoming "stuck" on a tall line when
4500 scrolling by one line. */
4501 if (window_scroll_pixel_based_preserve_y
< 0
4502 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4503 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4505 start_display (&it
, w
, start
);
4506 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4507 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4508 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4512 window_scroll_pixel_based_preserve_y
4513 = window_scroll_pixel_based_preserve_x
= -1;
4515 /* Move iterator it from start the specified distance forward or
4516 backward. The result is the new window start. */
4517 start_display (&it
, w
, start
);
4520 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4521 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4522 dy
= max ((window_box_height (w
)
4523 - next_screen_context_lines
* dy
),
4526 /* Note that move_it_vertically always moves the iterator to the
4527 start of a line. So, if the last line doesn't have a newline,
4528 we would end up at the start of the line ending at ZV. */
4531 move_it_vertically_backward (&it
, -dy
);
4532 /* Ensure we actually do move, e.g. in case we are currently
4533 looking at an image that is taller that the window height. */
4534 while (start_pos
== IT_CHARPOS (it
)
4535 && start_pos
> BEGV
)
4536 move_it_by_lines (&it
, -1);
4540 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4541 MOVE_TO_POS
| MOVE_TO_Y
);
4542 /* Ensure we actually do move, e.g. in case we are currently
4543 looking at an image that is taller that the window height. */
4544 while (start_pos
== IT_CHARPOS (it
)
4546 move_it_by_lines (&it
, 1);
4550 move_it_by_lines (&it
, n
);
4552 /* We failed if we find ZV is already on the screen (scrolling up,
4553 means there's nothing past the end), or if we can't start any
4554 earlier (scrolling down, means there's nothing past the top). */
4555 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4556 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4558 if (IT_CHARPOS (it
) == ZV
)
4560 if (it
.current_y
< it
.last_visible_y
4561 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4562 > it
.last_visible_y
))
4564 /* The last line was only partially visible, make it fully
4566 w
->vscroll
= (it
.last_visible_y
4567 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4568 adjust_glyphs (it
.f
);
4572 bidi_unshelve_cache (itdata
, 0);
4575 else if (n
< 0) /* could happen with empty buffers */
4576 xsignal0 (Qbeginning_of_buffer
);
4578 xsignal0 (Qend_of_buffer
);
4583 if (w
->vscroll
!= 0)
4584 /* The first line was only partially visible, make it fully
4589 bidi_unshelve_cache (itdata
, 0);
4593 xsignal0 (Qbeginning_of_buffer
);
4597 /* If control gets here, then we vscrolled. */
4599 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4601 /* Don't try to change the window start below. */
4607 ptrdiff_t pos
= IT_CHARPOS (it
);
4610 /* If in the middle of a multi-glyph character move forward to
4611 the next character. */
4612 if (in_display_vector_p (&it
))
4615 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4618 /* Set the window start, and set up the window for redisplay. */
4619 set_marker_restricted_both (w
->start
, w
->buffer
, IT_CHARPOS (it
),
4621 bytepos
= marker_byte_position (w
->start
);
4622 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4623 w
->update_mode_line
= 1;
4624 w
->last_modified
= 0;
4625 w
->last_overlay_modified
= 0;
4626 /* Set force_start so that redisplay_window will run the
4627 window-scroll-functions. */
4631 /* The rest of this function uses current_y in a nonstandard way,
4632 not including the height of the header line if any. */
4633 it
.current_y
= it
.vpos
= 0;
4635 /* Move PT out of scroll margins.
4636 This code wants current_y to be zero at the window start position
4637 even if there is a header line. */
4638 this_scroll_margin
= max (0, scroll_margin
);
4640 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4641 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4645 /* We moved the window start towards ZV, so PT may be now
4646 in the scroll margin at the top. */
4647 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4648 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4649 && (NILP (Vscroll_preserve_screen_position
)
4650 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4651 /* We found PT at a legitimate height. Leave it alone. */
4653 else if (window_scroll_pixel_based_preserve_y
>= 0)
4655 /* If we have a header line, take account of it.
4656 This is necessary because we set it.current_y to 0, above. */
4657 move_it_to (&it
, -1,
4658 window_scroll_pixel_based_preserve_x
,
4659 window_scroll_pixel_based_preserve_y
4660 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4661 -1, MOVE_TO_Y
| MOVE_TO_X
);
4662 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4666 while (it
.current_y
< this_scroll_margin
)
4668 int prev
= it
.current_y
;
4669 move_it_by_lines (&it
, 1);
4670 if (prev
== it
.current_y
)
4673 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4678 ptrdiff_t charpos
, bytepos
;
4681 /* Save our position, for the
4682 window_scroll_pixel_based_preserve_y case. */
4683 charpos
= IT_CHARPOS (it
);
4684 bytepos
= IT_BYTEPOS (it
);
4686 /* We moved the window start towards BEGV, so PT may be now
4687 in the scroll margin at the bottom. */
4688 move_it_to (&it
, PT
, -1,
4689 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4690 - this_scroll_margin
- 1),
4692 MOVE_TO_POS
| MOVE_TO_Y
);
4694 /* Save our position, in case it's correct. */
4695 charpos
= IT_CHARPOS (it
);
4696 bytepos
= IT_BYTEPOS (it
);
4698 /* See if point is on a partially visible line at the end. */
4699 if (it
.what
== IT_EOB
)
4700 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4703 move_it_by_lines (&it
, 1);
4704 partial_p
= it
.current_y
> it
.last_visible_y
;
4707 if (charpos
== PT
&& !partial_p
4708 && (NILP (Vscroll_preserve_screen_position
)
4709 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4710 /* We found PT before we found the display margin, so PT is ok. */
4712 else if (window_scroll_pixel_based_preserve_y
>= 0)
4714 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4715 start_display (&it
, w
, start
);
4716 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4717 here because we called start_display again and did not
4718 alter it.current_y this time. */
4719 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4720 window_scroll_pixel_based_preserve_y
, -1,
4721 MOVE_TO_Y
| MOVE_TO_X
);
4722 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4727 /* The last line was only partially visible, so back up two
4728 lines to make sure we're on a fully visible line. */
4730 move_it_by_lines (&it
, -2);
4731 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4734 /* No, the position we saved is OK, so use it. */
4735 SET_PT_BOTH (charpos
, bytepos
);
4738 bidi_unshelve_cache (itdata
, 0);
4742 /* Implementation of window_scroll that works based on screen lines.
4743 See the comment of window_scroll for parameter descriptions. */
4746 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4748 register struct window
*w
= XWINDOW (window
);
4749 /* Fvertical_motion enters redisplay, which can trigger
4750 fontification, which in turn can modify buffer text (e.g., if the
4751 fontification functions replace escape sequences with faces, as
4752 in `grep-mode-font-lock-keywords'). So we use a marker to record
4753 the old point position, to prevent crashes in SET_PT_BOTH. */
4754 Lisp_Object opoint_marker
= Fpoint_marker ();
4755 register ptrdiff_t pos
, pos_byte
;
4756 register int ht
= window_internal_height (w
);
4757 register Lisp_Object tem
;
4760 ptrdiff_t startpos
= marker_position (w
->start
);
4761 ptrdiff_t startbyte
= marker_byte_position (w
->start
);
4762 Lisp_Object original_pos
= Qnil
;
4764 /* If scrolling screen-fulls, compute the number of lines to
4765 scroll from the window's height. */
4767 n
*= max (1, ht
- next_screen_context_lines
);
4769 if (!NILP (Vscroll_preserve_screen_position
))
4771 if (window_scroll_preserve_vpos
<= 0
4772 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4773 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4775 struct position posit
4776 = *compute_motion (startpos
, startbyte
, 0, 0, 0,
4777 PT
, ht
, 0, -1, w
->hscroll
, 0, w
);
4778 window_scroll_preserve_vpos
= posit
.vpos
;
4779 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4782 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4783 make_number (window_scroll_preserve_vpos
));
4786 XSETFASTINT (tem
, PT
);
4787 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4791 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4793 startbyte
= PT_BYTE
;
4796 SET_PT_BOTH (startpos
, startbyte
);
4797 lose
= n
< 0 && PT
== BEGV
;
4798 Fvertical_motion (make_number (n
), window
);
4802 SET_PT_BOTH (marker_position (opoint_marker
),
4803 marker_byte_position (opoint_marker
));
4810 xsignal0 (Qbeginning_of_buffer
);
4815 /* Don't use a scroll margin that is negative or too large. */
4816 int this_scroll_margin
=
4817 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4819 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4820 w
->start_at_line_beg
= !NILP (bolp
);
4821 w
->update_mode_line
= 1;
4822 w
->last_modified
= 0;
4823 w
->last_overlay_modified
= 0;
4824 /* Set force_start so that redisplay_window will run
4825 the window-scroll-functions. */
4828 if (!NILP (Vscroll_preserve_screen_position
)
4829 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4831 SET_PT_BOTH (pos
, pos_byte
);
4832 Fvertical_motion (original_pos
, window
);
4834 /* If we scrolled forward, put point enough lines down
4835 that it is outside the scroll margin. */
4840 if (this_scroll_margin
> 0)
4842 SET_PT_BOTH (pos
, pos_byte
);
4843 Fvertical_motion (make_number (this_scroll_margin
), window
);
4849 if (top_margin
<= marker_position (opoint_marker
))
4850 SET_PT_BOTH (marker_position (opoint_marker
),
4851 marker_byte_position (opoint_marker
));
4852 else if (!NILP (Vscroll_preserve_screen_position
))
4854 SET_PT_BOTH (pos
, pos_byte
);
4855 Fvertical_motion (original_pos
, window
);
4858 SET_PT (top_margin
);
4864 /* If we scrolled backward, put point near the end of the window
4865 but not within the scroll margin. */
4866 SET_PT_BOTH (pos
, pos_byte
);
4867 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4868 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4871 bottom_margin
= PT
+ 1;
4873 if (bottom_margin
> marker_position (opoint_marker
))
4874 SET_PT_BOTH (marker_position (opoint_marker
),
4875 marker_byte_position (opoint_marker
));
4878 if (!NILP (Vscroll_preserve_screen_position
))
4880 SET_PT_BOTH (pos
, pos_byte
);
4881 Fvertical_motion (original_pos
, window
);
4884 Fvertical_motion (make_number (-1), window
);
4893 xsignal0 (Qend_of_buffer
);
4898 /* Scroll selected_window up or down. If N is nil, scroll a
4899 screen-full which is defined as the height of the window minus
4900 next_screen_context_lines. If N is the symbol `-', scroll.
4901 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4902 up. This is the guts of Fscroll_up and Fscroll_down. */
4905 scroll_command (Lisp_Object n
, int direction
)
4907 ptrdiff_t count
= SPECPDL_INDEX ();
4909 eassert (eabs (direction
) == 1);
4911 /* If selected window's buffer isn't current, make it current for
4912 the moment. But don't screw up if window_scroll gets an error. */
4913 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4915 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4916 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4918 /* Make redisplay consider other windows than just selected_window. */
4919 ++windows_or_buffers_changed
;
4923 window_scroll (selected_window
, direction
, 1, 0);
4924 else if (EQ (n
, Qminus
))
4925 window_scroll (selected_window
, -direction
, 1, 0);
4928 n
= Fprefix_numeric_value (n
);
4929 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4932 unbind_to (count
, Qnil
);
4935 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4936 doc
: /* Scroll text of selected window upward ARG lines.
4937 If ARG is omitted or nil, scroll upward by a near full screen.
4938 A near full screen is `next-screen-context-lines' less than a full screen.
4939 Negative ARG means scroll downward.
4940 If ARG is the atom `-', scroll downward by nearly full screen.
4941 When calling from a program, supply as argument a number, nil, or `-'. */)
4944 scroll_command (arg
, 1);
4948 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4949 doc
: /* Scroll text of selected window down ARG lines.
4950 If ARG is omitted or nil, scroll down by a near full screen.
4951 A near full screen is `next-screen-context-lines' less than a full screen.
4952 Negative ARG means scroll upward.
4953 If ARG is the atom `-', scroll upward by nearly full screen.
4954 When calling from a program, supply as argument a number, nil, or `-'. */)
4957 scroll_command (arg
, -1);
4961 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4962 doc
: /* Return the other window for \"other window scroll\" commands.
4963 If `other-window-scroll-buffer' is non-nil, a window
4964 showing that buffer is used.
4965 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4966 specifies the window. This takes precedence over
4967 `other-window-scroll-buffer'. */)
4972 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4973 && !NILP (Vminibuf_scroll_window
))
4974 window
= Vminibuf_scroll_window
;
4975 /* If buffer is specified, scroll that buffer. */
4976 else if (!NILP (Vother_window_scroll_buffer
))
4978 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4980 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4984 /* Nothing specified; look for a neighboring window on the same
4986 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4988 if (EQ (window
, selected_window
))
4989 /* That didn't get us anywhere; look for a window on another
4992 window
= Fnext_window (window
, Qnil
, Qt
);
4993 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4994 && ! EQ (window
, selected_window
));
4997 CHECK_LIVE_WINDOW (window
);
4999 if (EQ (window
, selected_window
))
5000 error ("There is no other window");
5005 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5006 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5007 A near full screen is `next-screen-context-lines' less than a full screen.
5008 The next window is the one below the current one; or the one at the top
5009 if the current one is at the bottom. Negative ARG means scroll downward.
5010 If ARG is the atom `-', scroll downward by nearly full screen.
5011 When calling from a program, supply as argument a number, nil, or `-'.
5013 If `other-window-scroll-buffer' is non-nil, scroll the window
5014 showing that buffer, popping the buffer up if necessary.
5015 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5016 specifies the window to scroll. This takes precedence over
5017 `other-window-scroll-buffer'. */)
5022 ptrdiff_t count
= SPECPDL_INDEX ();
5024 window
= Fother_window_for_scrolling ();
5025 w
= XWINDOW (window
);
5027 /* Don't screw up if window_scroll gets an error. */
5028 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5029 ++windows_or_buffers_changed
;
5031 Fset_buffer (w
->buffer
);
5032 SET_PT_BOTH (marker_position (w
->pointm
), marker_byte_position (w
->pointm
));
5035 window_scroll (window
, 1, 1, 1);
5036 else if (EQ (arg
, Qminus
))
5037 window_scroll (window
, -1, 1, 1);
5043 window_scroll (window
, XINT (arg
), 0, 1);
5046 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5047 unbind_to (count
, Qnil
);
5052 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5053 doc
: /* Scroll selected window display ARG columns left.
5054 Default for ARG is window width minus 2.
5055 Value is the total amount of leftward horizontal scrolling in
5056 effect after the change.
5057 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5058 lower bound for automatic scrolling, i.e. automatic scrolling
5059 will not scroll a window to a column less than the value returned
5060 by this function. This happens in an interactive call. */)
5061 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5063 struct window
*w
= XWINDOW (selected_window
);
5064 EMACS_INT requested_arg
= (NILP (arg
)
5065 ? window_body_cols (w
) - 2
5066 : XINT (Fprefix_numeric_value (arg
)));
5067 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5069 if (!NILP (set_minimum
))
5070 w
->min_hscroll
= w
->hscroll
;
5075 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5076 doc
: /* Scroll selected window display ARG columns right.
5077 Default for ARG is window width minus 2.
5078 Value is the total amount of leftward horizontal scrolling in
5079 effect after the change.
5080 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5081 lower bound for automatic scrolling, i.e. automatic scrolling
5082 will not scroll a window to a column less than the value returned
5083 by this function. This happens in an interactive call. */)
5084 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5086 struct window
*w
= XWINDOW (selected_window
);
5087 EMACS_INT requested_arg
= (NILP (arg
)
5088 ? window_body_cols (w
) - 2
5089 : XINT (Fprefix_numeric_value (arg
)));
5090 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5092 if (!NILP (set_minimum
))
5093 w
->min_hscroll
= w
->hscroll
;
5098 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5099 doc
: /* Return the window which was selected when entering the minibuffer.
5100 Returns nil, if selected window is not a minibuffer window. */)
5103 if (minibuf_level
> 0
5104 && MINI_WINDOW_P (XWINDOW (selected_window
))
5105 && WINDOW_LIVE_P (minibuf_selected_window
))
5106 return minibuf_selected_window
;
5111 /* Value is the number of lines actually displayed in window W,
5112 as opposed to its height. */
5115 displayed_window_lines (struct window
*w
)
5118 struct text_pos start
;
5119 ptrdiff_t charpos
= marker_position (w
->start
);
5120 int height
= window_box_height (w
);
5121 struct buffer
*old_buffer
;
5123 void *itdata
= NULL
;
5125 if (XBUFFER (w
->buffer
) != current_buffer
)
5127 old_buffer
= current_buffer
;
5128 set_buffer_internal (XBUFFER (w
->buffer
));
5133 /* In case W->start is out of the accessible range, do something
5134 reasonable. This happens in Info mode when Info-scroll-down
5135 calls (recenter -1) while W->start is 1. */
5137 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5138 else if (charpos
> ZV
)
5139 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5141 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5143 itdata
= bidi_shelve_cache ();
5144 start_display (&it
, w
, start
);
5145 move_it_vertically (&it
, height
);
5146 bottom_y
= line_bottom_y (&it
);
5147 bidi_unshelve_cache (itdata
, 0);
5149 /* rms: On a non-window display,
5150 the value of it.vpos at the bottom of the screen
5151 seems to be 1 larger than window_box_height (w).
5152 This kludge fixes a bug whereby (move-to-window-line -1)
5153 when ZV is on the last screen line
5154 moves to the previous screen line instead of the last one. */
5155 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5158 /* Add in empty lines at the bottom of the window. */
5159 if (bottom_y
< height
)
5161 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5162 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5166 set_buffer_internal (old_buffer
);
5172 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5173 doc
: /* Center point in selected window and maybe redisplay frame.
5174 With a numeric prefix argument ARG, recenter putting point on screen line ARG
5175 relative to the selected window. If ARG is negative, it counts up from the
5176 bottom of the window. (ARG should be less than the height of the window.)
5178 If ARG is omitted or nil, then recenter with point on the middle line of
5179 the selected window; if the variable `recenter-redisplay' is non-nil,
5180 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5181 is set to `grow-only', this resets the tool-bar's height to the minimum
5182 height needed); if `recenter-redisplay' has the special value `tty',
5183 then only tty frames are redrawn.
5185 Just C-u as prefix means put point in the center of the window
5186 and redisplay normally--don't erase and redraw the frame. */)
5187 (register Lisp_Object arg
)
5189 struct window
*w
= XWINDOW (selected_window
);
5190 struct buffer
*buf
= XBUFFER (w
->buffer
);
5191 struct buffer
*obuf
= current_buffer
;
5193 ptrdiff_t charpos
, bytepos
;
5194 EMACS_INT iarg
IF_LINT (= 0);
5195 int this_scroll_margin
;
5197 /* If redisplay is suppressed due to an error, try again. */
5198 obuf
->display_error_modiff
= 0;
5202 if (!NILP (Vrecenter_redisplay
)
5203 && (!EQ (Vrecenter_redisplay
, Qtty
)
5204 || !NILP (Ftty_type (selected_frame
))))
5208 /* Invalidate pixel data calculated for all compositions. */
5209 for (i
= 0; i
< n_compositions
; i
++)
5210 composition_table
[i
]->font
= NULL
;
5212 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5214 Fredraw_frame (WINDOW_FRAME (w
));
5215 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5220 else if (CONSP (arg
)) /* Just C-u. */
5224 arg
= Fprefix_numeric_value (arg
);
5229 set_buffer_internal (buf
);
5231 /* Do this after making BUF current
5232 in case scroll_margin is buffer-local. */
5233 this_scroll_margin
=
5234 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5236 /* Handle centering on a graphical frame specially. Such frames can
5237 have variable-height lines and centering point on the basis of
5238 line counts would lead to strange effects. */
5239 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5245 void *itdata
= bidi_shelve_cache ();
5247 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5248 start_display (&it
, w
, pt
);
5249 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5250 charpos
= IT_CHARPOS (it
);
5251 bytepos
= IT_BYTEPOS (it
);
5252 bidi_unshelve_cache (itdata
, 0);
5258 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5259 int extra_line_spacing
;
5260 int h
= window_box_height (w
);
5261 void *itdata
= bidi_shelve_cache ();
5263 iarg
= - max (-iarg
, this_scroll_margin
);
5265 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5266 start_display (&it
, w
, pt
);
5268 /* Be sure we have the exact height of the full line containing PT. */
5269 move_it_by_lines (&it
, 0);
5271 /* The amount of pixels we have to move back is the window
5272 height minus what's displayed in the line containing PT,
5273 and the lines below. */
5276 move_it_by_lines (&it
, nlines
);
5278 if (it
.vpos
== nlines
)
5282 /* Last line has no newline */
5283 h
-= line_bottom_y (&it
);
5287 /* Don't reserve space for extra line spacing of last line. */
5288 extra_line_spacing
= it
.max_extra_line_spacing
;
5290 /* If we can't move down NLINES lines because we hit
5291 the end of the buffer, count in some empty lines. */
5292 if (it
.vpos
< nlines
)
5295 extra_line_spacing
= it
.extra_line_spacing
;
5296 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5300 bidi_unshelve_cache (itdata
, 0);
5304 /* Now find the new top line (starting position) of the window. */
5305 start_display (&it
, w
, pt
);
5307 move_it_vertically_backward (&it
, h
);
5309 /* If extra line spacing is present, we may move too far
5310 back. This causes the last line to be only partially
5311 visible (which triggers redisplay to recenter that line
5312 in the middle), so move forward.
5313 But ignore extra line spacing on last line, as it is not
5314 considered to be part of the visible height of the line.
5316 h
+= extra_line_spacing
;
5317 while (-it
.current_y
> h
)
5318 move_it_by_lines (&it
, 1);
5320 charpos
= IT_CHARPOS (it
);
5321 bytepos
= IT_BYTEPOS (it
);
5323 bidi_unshelve_cache (itdata
, 0);
5327 struct position pos
;
5329 iarg
= max (iarg
, this_scroll_margin
);
5331 pos
= *vmotion (PT
, PT_BYTE
, -iarg
, w
);
5332 charpos
= pos
.bufpos
;
5333 bytepos
= pos
.bytepos
;
5338 struct position pos
;
5339 int ht
= window_internal_height (w
);
5346 /* Don't let it get into the margin at either top or bottom. */
5347 iarg
= clip_to_bounds (this_scroll_margin
, iarg
,
5348 ht
- this_scroll_margin
- 1);
5350 pos
= *vmotion (PT
, PT_BYTE
, - iarg
, w
);
5351 charpos
= pos
.bufpos
;
5352 bytepos
= pos
.bytepos
;
5355 /* Set the new window start. */
5356 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5357 w
->window_end_valid
= 0;
5359 w
->optional_new_start
= 1;
5361 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5362 FETCH_BYTE (bytepos
- 1) == '\n');
5364 set_buffer_internal (obuf
);
5368 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5370 doc
: /* Return the height in lines of the text display area of WINDOW.
5371 WINDOW must be a live window and defaults to the selected one.
5373 The returned height does not include the mode line, any header line,
5374 nor any partial-height lines at the bottom of the text area. */)
5375 (Lisp_Object window
)
5377 struct window
*w
= decode_live_window (window
);
5378 int pixel_height
= window_box_height (w
);
5379 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5380 return make_number (line_height
);
5385 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5387 doc
: /* Position point relative to window.
5388 ARG nil means position point at center of window.
5389 Else, ARG specifies vertical position within the window;
5390 zero means top of window, negative means relative to bottom of window. */)
5393 struct window
*w
= XWINDOW (selected_window
);
5397 int this_scroll_margin
;
5400 if (!(BUFFERP (w
->buffer
)
5401 && XBUFFER (w
->buffer
) == current_buffer
))
5402 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5403 when passed below to set_marker_both. */
5404 error ("move-to-window-line called from unrelated buffer");
5406 window
= selected_window
;
5407 start
= marker_position (w
->start
);
5408 if (start
< BEGV
|| start
> ZV
)
5410 int height
= window_internal_height (w
);
5411 Fvertical_motion (make_number (- (height
/ 2)), window
);
5412 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5413 w
->start_at_line_beg
= !NILP (Fbolp ());
5417 Fgoto_char (w
->start
);
5419 lines
= displayed_window_lines (w
);
5422 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5426 XSETFASTINT (arg
, lines
/ 2);
5429 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5432 iarg
= iarg
+ lines
;
5434 #if 0 /* This code would prevent move-to-window-line from moving point
5435 to a place inside the scroll margins (which would cause the
5436 next redisplay to scroll). I wrote this code, but then concluded
5437 it is probably better not to install it. However, it is here
5438 inside #if 0 so as not to lose it. -- rms. */
5440 /* Don't let it get into the margin at either top or bottom. */
5441 iarg
= max (iarg
, this_scroll_margin
);
5442 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5445 arg
= make_number (iarg
);
5448 /* Skip past a partially visible first line. */
5450 XSETINT (arg
, XINT (arg
) + 1);
5452 return Fvertical_motion (arg
, window
);
5457 /***********************************************************************
5458 Window Configuration
5459 ***********************************************************************/
5461 struct save_window_data
5463 struct vectorlike_header header
;
5464 Lisp_Object selected_frame
;
5465 Lisp_Object current_window
;
5466 Lisp_Object current_buffer
;
5467 Lisp_Object minibuf_scroll_window
;
5468 Lisp_Object minibuf_selected_window
;
5469 Lisp_Object root_window
;
5470 Lisp_Object focus_frame
;
5471 /* A vector, each of whose elements is a struct saved_window
5473 Lisp_Object saved_windows
;
5475 /* All fields above are traced by the GC.
5476 From `fame-cols' down, the fields are ignored by the GC. */
5478 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5479 int frame_tool_bar_lines
;
5482 /* This is saved as a Lisp_Vector */
5485 struct vectorlike_header header
;
5487 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5488 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5489 Lisp_Object normal_cols
, normal_lines
;
5490 Lisp_Object hscroll
, min_hscroll
;
5491 Lisp_Object parent
, prev
;
5492 Lisp_Object start_at_line_beg
;
5493 Lisp_Object display_table
;
5494 Lisp_Object left_margin_cols
, right_margin_cols
;
5495 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5496 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5497 Lisp_Object combination_limit
, window_parameters
;
5500 #define SAVED_WINDOW_N(swv,n) \
5501 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5503 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5504 doc
: /* Return t if OBJECT is a window-configuration object. */)
5505 (Lisp_Object object
)
5507 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5510 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5511 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5512 (Lisp_Object config
)
5514 register struct save_window_data
*data
;
5515 struct Lisp_Vector
*saved_windows
;
5517 CHECK_WINDOW_CONFIGURATION (config
);
5519 data
= (struct save_window_data
*) XVECTOR (config
);
5520 saved_windows
= XVECTOR (data
->saved_windows
);
5521 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5524 DEFUN ("set-window-configuration", Fset_window_configuration
,
5525 Sset_window_configuration
, 1, 1, 0,
5526 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5527 CONFIGURATION must be a value previously returned
5528 by `current-window-configuration' (which see).
5529 If CONFIGURATION was made from a frame that is now deleted,
5530 only frame-independent values can be restored. In this case,
5531 the return value is nil. Otherwise the value is t. */)
5532 (Lisp_Object configuration
)
5534 register struct save_window_data
*data
;
5535 struct Lisp_Vector
*saved_windows
;
5536 Lisp_Object new_current_buffer
;
5539 ptrdiff_t old_point
= -1;
5541 CHECK_WINDOW_CONFIGURATION (configuration
);
5543 data
= (struct save_window_data
*) XVECTOR (configuration
);
5544 saved_windows
= XVECTOR (data
->saved_windows
);
5546 new_current_buffer
= data
->current_buffer
;
5547 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5548 new_current_buffer
= Qnil
;
5551 if (XBUFFER (new_current_buffer
) == current_buffer
)
5552 /* The code further down "preserves point" by saving here PT in
5553 old_point and then setting it later back into PT. When the
5554 current-selected-window and the final-selected-window both show
5555 the current buffer, this suffers from the problem that the
5556 current PT is the window-point of the current-selected-window,
5557 while the final PT is the point of the final-selected-window, so
5558 this copy from one PT to the other would end up moving the
5559 window-point of the final-selected-window to the window-point of
5560 the current-selected-window. So we have to be careful which
5561 point of the current-buffer we copy into old_point. */
5562 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5563 && WINDOWP (selected_window
)
5564 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5565 && !EQ (selected_window
, data
->current_window
))
5566 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5570 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5571 point in new_current_buffer as of the last time this buffer was
5572 used. This can be non-deterministic since it can be changed by
5573 things like jit-lock by mere temporary selection of some random
5574 window that happens to show this buffer.
5575 So if possible we want this arbitrary choice of "which point" to
5576 be the one from the to-be-selected-window so as to prevent this
5577 window's cursor from being copied from another window. */
5578 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5579 /* If current_window = selected_window, its point is in BUF_PT. */
5580 && !EQ (selected_window
, data
->current_window
))
5581 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5583 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5586 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5589 /* If f is a dead frame, don't bother rebuilding its window tree.
5590 However, there is other stuff we should still try to do below. */
5591 if (FRAME_LIVE_P (f
))
5594 Lisp_Object dead_windows
= Qnil
;
5595 register Lisp_Object tem
, par
, pers
;
5596 register struct window
*w
;
5597 register struct saved_window
*p
;
5598 struct window
*root_window
;
5599 struct window
**leaf_windows
;
5604 /* If the frame has been resized since this window configuration was
5605 made, we change the frame to the size specified in the
5606 configuration, restore the configuration, and then resize it
5607 back. We keep track of the prevailing height in these variables. */
5608 int previous_frame_lines
= FRAME_LINES (f
);
5609 int previous_frame_cols
= FRAME_COLS (f
);
5610 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5611 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5613 /* Don't do this within the main loop below: This may call Lisp
5614 code and is thus potentially unsafe while input is blocked. */
5615 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5617 p
= SAVED_WINDOW_N (saved_windows
, k
);
5619 w
= XWINDOW (window
);
5620 if (!NILP (w
->buffer
)
5621 && !EQ (w
->buffer
, p
->buffer
)
5622 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5623 /* If a window we restore gets another buffer, record the
5624 window's old buffer. */
5625 call1 (Qrecord_window_buffer
, window
);
5628 /* The mouse highlighting code could get screwed up
5629 if it runs during this. */
5632 if (data
->frame_lines
!= previous_frame_lines
5633 || data
->frame_cols
!= previous_frame_cols
)
5634 change_frame_size (f
, data
->frame_lines
,
5635 data
->frame_cols
, 0, 0, 0);
5636 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5637 if (data
->frame_menu_bar_lines
5638 != previous_frame_menu_bar_lines
)
5639 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5641 #ifdef HAVE_WINDOW_SYSTEM
5642 if (data
->frame_tool_bar_lines
5643 != previous_frame_tool_bar_lines
)
5644 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5649 /* "Swap out" point from the selected window's buffer
5650 into the window itself. (Normally the pointm of the selected
5651 window holds garbage.) We do this now, before
5652 restoring the window contents, and prevent it from
5653 being done later on when we select a new window. */
5654 if (! NILP (XWINDOW (selected_window
)->buffer
))
5656 w
= XWINDOW (selected_window
);
5657 set_marker_both (w
->pointm
,
5659 BUF_PT (XBUFFER (w
->buffer
)),
5660 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5663 windows_or_buffers_changed
++;
5664 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5666 /* Problem: Freeing all matrices and later allocating them again
5667 is a serious redisplay flickering problem. What we would
5668 really like to do is to free only those matrices not reused
5670 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5671 leaf_windows
= alloca (count_windows (root_window
)
5672 * sizeof *leaf_windows
);
5673 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5676 Mark all windows now on frame as "deleted".
5677 Restoring the new configuration "undeletes" any that are in it.
5679 Save their current buffers in their height fields, since we may
5680 need it later, if a buffer saved in the configuration is now
5682 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5684 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5686 p
= SAVED_WINDOW_N (saved_windows
, k
);
5688 w
= XWINDOW (window
);
5689 wset_next (w
, Qnil
);
5691 if (!NILP (p
->parent
))
5693 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5695 wset_parent (w
, Qnil
);
5697 if (!NILP (p
->prev
))
5700 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5701 wset_next (XWINDOW (w
->prev
), p
->window
);
5705 wset_prev (w
, Qnil
);
5706 if (!NILP (w
->parent
))
5708 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5710 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5711 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5715 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5716 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5721 /* If we squirreled away the buffer, restore it now. */
5722 if (BUFFERP (w
->combination_limit
))
5723 wset_buffer (w
, w
->combination_limit
);
5724 wset_left_col (w
, p
->left_col
);
5725 wset_top_line (w
, p
->top_line
);
5726 wset_total_cols (w
, p
->total_cols
);
5727 wset_total_lines (w
, p
->total_lines
);
5728 wset_normal_cols (w
, p
->normal_cols
);
5729 wset_normal_lines (w
, p
->normal_lines
);
5730 w
->hscroll
= XFASTINT (p
->hscroll
);
5731 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5732 wset_display_table (w
, p
->display_table
);
5733 wset_left_margin_cols (w
, p
->left_margin_cols
);
5734 wset_right_margin_cols (w
, p
->right_margin_cols
);
5735 wset_left_fringe_width (w
, p
->left_fringe_width
);
5736 wset_right_fringe_width (w
, p
->right_fringe_width
);
5737 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5738 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5739 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5740 wset_dedicated (w
, p
->dedicated
);
5741 wset_combination_limit (w
, p
->combination_limit
);
5742 /* Restore any window parameters that have been saved.
5743 Parameters that have not been saved are left alone. */
5744 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5749 if (NILP (XCDR (pers
)))
5751 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5752 if (CONSP (par
) && !NILP (XCDR (par
)))
5753 /* Reset a parameter to nil if and only if it
5754 has a non-nil association. Don't make new
5756 Fsetcdr (par
, Qnil
);
5759 /* Always restore a non-nil value. */
5760 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5764 w
->last_modified
= 0;
5765 w
->last_overlay_modified
= 0;
5767 /* Reinstall the saved buffer and pointers into it. */
5768 if (NILP (p
->buffer
))
5769 /* An internal window. */
5770 wset_buffer (w
, p
->buffer
);
5771 else if (BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5772 /* If saved buffer is alive, install it. */
5774 wset_buffer (w
, p
->buffer
);
5775 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5776 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5777 set_marker_restricted (w
->pointm
, p
->pointm
,
5779 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5780 p
->mark
, w
->buffer
);
5782 /* As documented in Fcurrent_window_configuration, don't
5783 restore the location of point in the buffer which was
5784 current when the window configuration was recorded. */
5785 if (!EQ (p
->buffer
, new_current_buffer
)
5786 && XBUFFER (p
->buffer
) == current_buffer
)
5787 Fgoto_char (w
->pointm
);
5789 else if (!NILP (w
->buffer
)
5790 && BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
5791 /* Keep window's old buffer; make sure the markers are
5794 /* Set window markers at start of visible range. */
5795 if (XMARKER (w
->start
)->buffer
== 0)
5796 set_marker_restricted_both (w
->start
, w
->buffer
, 0, 0);
5797 if (XMARKER (w
->pointm
)->buffer
== 0)
5798 set_marker_restricted_both
5799 (w
->pointm
, w
->buffer
,
5800 BUF_PT (XBUFFER (w
->buffer
)),
5801 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5802 w
->start_at_line_beg
= 1;
5805 /* Window has no live buffer, get one. */
5807 /* Get the buffer via other_buffer_safely in order to
5808 avoid showing an unimportant buffer and, if necessary, to
5809 recreate *scratch* in the course (part of Juanma's bs-show
5810 scenario from March 2011). */
5811 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5812 /* This will set the markers to beginning of visible
5814 set_marker_restricted_both (w
->start
, w
->buffer
, 0, 0);
5815 set_marker_restricted_both (w
->pointm
, w
->buffer
, 0, 0);
5816 w
->start_at_line_beg
= 1;
5817 if (!NILP (w
->dedicated
))
5818 /* Record this window as dead. */
5819 dead_windows
= Fcons (window
, dead_windows
);
5820 /* Make sure window is no more dedicated. */
5821 wset_dedicated (w
, Qnil
);
5825 fset_root_window (f
, data
->root_window
);
5826 /* Arrange *not* to restore point in the buffer that was
5827 current when the window configuration was saved. */
5828 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5829 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5830 make_number (old_point
),
5831 XWINDOW (data
->current_window
)->buffer
);
5833 /* In the following call to `select-window', prevent "swapping out
5834 point" in the old selected window using the buffer that has
5835 been restored into it. We already swapped out that point from
5836 that window's old buffer. */
5837 select_window (data
->current_window
, Qnil
, 1);
5838 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5841 if (NILP (data
->focus_frame
)
5842 || (FRAMEP (data
->focus_frame
)
5843 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5844 Fredirect_frame_focus (frame
, data
->focus_frame
);
5846 /* Set the screen height to the value it had before this function. */
5847 if (previous_frame_lines
!= FRAME_LINES (f
)
5848 || previous_frame_cols
!= FRAME_COLS (f
))
5849 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5851 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5852 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5853 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5855 #ifdef HAVE_WINDOW_SYSTEM
5856 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5857 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5862 /* Now, free glyph matrices in windows that were not reused. */
5863 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5865 if (NILP (leaf_windows
[i
]->buffer
))
5867 /* Assert it's not reused as a combination. */
5868 eassert (NILP (leaf_windows
[i
]->hchild
)
5869 && NILP (leaf_windows
[i
]->vchild
));
5870 free_window_matrices (leaf_windows
[i
]);
5872 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5879 /* Scan dead buffer windows. */
5880 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5882 window
= XCAR (dead_windows
);
5883 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5884 delete_deletable_window (window
);
5887 /* Fselect_window will have made f the selected frame, so we
5888 reselect the proper frame here. Fhandle_switch_frame will change the
5889 selected window too, but that doesn't make the call to
5890 Fselect_window above totally superfluous; it still sets f's
5892 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5893 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5895 run_window_configuration_change_hook (f
);
5898 if (!NILP (new_current_buffer
))
5900 Fset_buffer (new_current_buffer
);
5901 /* If the new current buffer doesn't appear in the selected
5902 window, go to its old point (see bug#12208). */
5903 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5904 Fgoto_char (make_number (old_point
));
5907 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5908 minibuf_selected_window
= data
->minibuf_selected_window
;
5910 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5914 /* Recursively delete all child windows reachable via the next, vchild,
5915 and hchild slots of WINDOW. */
5917 delete_all_child_windows (Lisp_Object window
)
5919 register struct window
*w
;
5921 w
= XWINDOW (window
);
5923 if (!NILP (w
->next
))
5924 /* Delete WINDOW's siblings (we traverse postorderly). */
5925 delete_all_child_windows (w
->next
);
5927 if (!NILP (w
->vchild
))
5929 delete_all_child_windows (w
->vchild
);
5930 wset_vchild (w
, Qnil
);
5932 else if (!NILP (w
->hchild
))
5934 delete_all_child_windows (w
->hchild
);
5935 wset_hchild (w
, Qnil
);
5937 else if (!NILP (w
->buffer
))
5940 unchain_marker (XMARKER (w
->pointm
));
5941 unchain_marker (XMARKER (w
->start
));
5942 /* Since combination limit makes sense for an internal windows
5943 only, we use this slot to save the buffer for the sake of
5944 possible resurrection in Fset_window_configuration. */
5945 wset_combination_limit (w
, w
->buffer
);
5946 wset_buffer (w
, Qnil
);
5949 Vwindow_list
= Qnil
;
5953 count_windows (register struct window
*window
)
5955 register int count
= 1;
5956 if (!NILP (window
->next
))
5957 count
+= count_windows (XWINDOW (window
->next
));
5958 if (!NILP (window
->vchild
))
5959 count
+= count_windows (XWINDOW (window
->vchild
));
5960 if (!NILP (window
->hchild
))
5961 count
+= count_windows (XWINDOW (window
->hchild
));
5966 /* Fill vector FLAT with leaf windows under W, starting at index I.
5967 Value is last index + 1. */
5969 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5973 if (!NILP (w
->hchild
))
5974 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5975 else if (!NILP (w
->vchild
))
5976 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5980 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5987 /* Return a pointer to the glyph W's physical cursor is on. Value is
5988 null if W's current matrix is invalid, so that no meaningful glyph
5991 get_phys_cursor_glyph (struct window
*w
)
5993 struct glyph_row
*row
;
5994 struct glyph
*glyph
;
5995 int hpos
= w
->phys_cursor
.hpos
;
5997 if (!(w
->phys_cursor
.vpos
>= 0
5998 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
6001 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
6002 if (!row
->enabled_p
)
6007 /* When the window is hscrolled, cursor hpos can legitimately be
6008 out of bounds, but we draw the cursor at the corresponding
6009 window margin in that case. */
6010 if (!row
->reversed_p
&& hpos
< 0)
6012 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
6013 hpos
= row
->used
[TEXT_AREA
] - 1;
6016 if (row
->used
[TEXT_AREA
] > hpos
6018 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
6027 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6029 register struct saved_window
*p
;
6030 register struct window
*w
;
6031 register Lisp_Object tem
, pers
, par
;
6033 for (;!NILP (window
); window
= w
->next
)
6035 p
= SAVED_WINDOW_N (vector
, i
);
6036 w
= XWINDOW (window
);
6038 wset_temslot (w
, make_number (i
)); i
++;
6040 p
->buffer
= w
->buffer
;
6041 p
->left_col
= w
->left_col
;
6042 p
->top_line
= w
->top_line
;
6043 p
->total_cols
= w
->total_cols
;
6044 p
->total_lines
= w
->total_lines
;
6045 p
->normal_cols
= w
->normal_cols
;
6046 p
->normal_lines
= w
->normal_lines
;
6047 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6048 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6049 p
->display_table
= w
->display_table
;
6050 p
->left_margin_cols
= w
->left_margin_cols
;
6051 p
->right_margin_cols
= w
->right_margin_cols
;
6052 p
->left_fringe_width
= w
->left_fringe_width
;
6053 p
->right_fringe_width
= w
->right_fringe_width
;
6054 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6055 p
->scroll_bar_width
= w
->scroll_bar_width
;
6056 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6057 p
->dedicated
= w
->dedicated
;
6058 p
->combination_limit
= w
->combination_limit
;
6059 p
->window_parameters
= Qnil
;
6061 if (!NILP (Vwindow_persistent_parameters
))
6063 /* Run cycle detection on Vwindow_persistent_parameters. */
6064 Lisp_Object tortoise
, hare
;
6066 hare
= tortoise
= Vwindow_persistent_parameters
;
6067 while (CONSP (hare
))
6074 tortoise
= XCDR (tortoise
);
6076 if (EQ (hare
, tortoise
))
6077 /* Reset Vwindow_persistent_parameters to Qnil. */
6079 Vwindow_persistent_parameters
= Qnil
;
6084 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6088 /* Save values for persistent window parameters. */
6089 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6091 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6093 /* If the window has no value for the parameter,
6095 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6096 p
->window_parameters
);
6098 /* If the window has a value for the parameter,
6100 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6102 p
->window_parameters
);
6107 if (!NILP (w
->buffer
))
6109 /* Save w's value of point in the window configuration. If w
6110 is the selected window, then get the value of point from
6111 the buffer; pointm is garbage in the selected window. */
6112 if (EQ (window
, selected_window
))
6113 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6114 BUF_PT (XBUFFER (w
->buffer
)),
6115 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6117 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6118 XMARKER (p
->pointm
)->insertion_type
6119 = !NILP (Vwindow_point_insertion_type
);
6121 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6122 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6124 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6125 p
->mark
= Fcopy_marker (tem
, Qnil
);
6132 p
->start_at_line_beg
= Qnil
;
6135 if (NILP (w
->parent
))
6138 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6143 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6145 if (!NILP (w
->vchild
))
6146 i
= save_window_save (w
->vchild
, vector
, i
);
6147 if (!NILP (w
->hchild
))
6148 i
= save_window_save (w
->hchild
, vector
, i
);
6154 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6155 Scurrent_window_configuration
, 0, 1, 0,
6156 doc
: /* Return an object representing the current window configuration of FRAME.
6157 If FRAME is nil or omitted, use the selected frame.
6158 This describes the number of windows, their sizes and current buffers,
6159 and for each displayed buffer, where display starts, and the positions of
6160 point and mark. An exception is made for point in the current buffer:
6161 its value is -not- saved.
6162 This also records the currently selected frame, and FRAME's focus
6163 redirection (see `redirect-frame-focus'). The variable
6164 `window-persistent-parameters' specifies which window parameters are
6165 saved by this function. */)
6168 register Lisp_Object tem
;
6169 register int n_windows
;
6170 register struct save_window_data
*data
;
6172 struct frame
*f
= decode_live_frame (frame
);
6174 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6175 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6176 PVEC_WINDOW_CONFIGURATION
);
6178 data
->frame_cols
= FRAME_COLS (f
);
6179 data
->frame_lines
= FRAME_LINES (f
);
6180 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6181 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6182 data
->selected_frame
= selected_frame
;
6183 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6184 XSETBUFFER (data
->current_buffer
, current_buffer
);
6185 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6186 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6187 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6188 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6189 tem
= make_uninit_vector (n_windows
);
6190 data
->saved_windows
= tem
;
6191 for (i
= 0; i
< n_windows
; i
++)
6193 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6194 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6195 XSETWINDOW_CONFIGURATION (tem
, data
);
6199 /***********************************************************************
6201 ***********************************************************************/
6203 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6205 doc
: /* Set width of marginal areas of window WINDOW.
6206 WINDOW must be a live window and defaults to the selected one.
6208 Second arg LEFT-WIDTH specifies the number of character cells to
6209 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6210 does the same for the right marginal area. A nil width parameter
6211 means no margin. */)
6212 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6214 struct window
*w
= decode_live_window (window
);
6216 /* Translate negative or zero widths to nil.
6217 Margins that are too wide have to be checked elsewhere. */
6219 if (!NILP (left_width
))
6221 CHECK_NUMBER (left_width
);
6222 if (XINT (left_width
) <= 0)
6226 if (!NILP (right_width
))
6228 CHECK_NUMBER (right_width
);
6229 if (XINT (right_width
) <= 0)
6233 if (!EQ (w
->left_margin_cols
, left_width
)
6234 || !EQ (w
->right_margin_cols
, right_width
))
6236 wset_left_margin_cols (w
, left_width
);
6237 wset_right_margin_cols (w
, right_width
);
6239 adjust_window_margins (w
);
6241 ++windows_or_buffers_changed
;
6242 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6249 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6251 doc
: /* Get width of marginal areas of window WINDOW.
6252 WINDOW must be a live window and defaults to the selected one.
6254 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6255 If a marginal area does not exist, its width will be returned
6257 (Lisp_Object window
)
6259 struct window
*w
= decode_live_window (window
);
6260 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6265 /***********************************************************************
6267 ***********************************************************************/
6269 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6271 doc
: /* Set the fringe widths of window WINDOW.
6272 WINDOW must be a live window and defaults to the selected one.
6274 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6275 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6276 fringe width. If a fringe width arg is nil, that means to use the
6277 frame's default fringe width. Default fringe widths can be set with
6278 the command `set-fringe-style'.
6279 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6280 outside of the display margins. By default, fringes are drawn between
6281 display marginal areas and the text area. */)
6282 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6284 struct window
*w
= decode_live_window (window
);
6285 int outside
= !NILP (outside_margins
);
6287 if (!NILP (left_width
))
6288 CHECK_NATNUM (left_width
);
6289 if (!NILP (right_width
))
6290 CHECK_NATNUM (right_width
);
6292 /* Do nothing on a tty. */
6293 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6294 && (!EQ (w
->left_fringe_width
, left_width
)
6295 || !EQ (w
->right_fringe_width
, right_width
)
6296 || w
->fringes_outside_margins
!= outside
))
6298 wset_left_fringe_width (w
, left_width
);
6299 wset_right_fringe_width (w
, right_width
);
6300 w
->fringes_outside_margins
= outside
;
6302 adjust_window_margins (w
);
6304 clear_glyph_matrix (w
->current_matrix
);
6305 w
->window_end_valid
= 0;
6307 ++windows_or_buffers_changed
;
6308 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6315 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6317 doc
: /* Get width of fringes of window WINDOW.
6318 WINDOW must be a live window and defaults to the selected one.
6320 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6321 (Lisp_Object window
)
6323 struct window
*w
= decode_live_window (window
);
6325 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6326 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6327 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6332 /***********************************************************************
6334 ***********************************************************************/
6336 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6337 Sset_window_scroll_bars
, 2, 4, 0,
6338 doc
: /* Set width and type of scroll bars of window WINDOW.
6339 WINDOW must be a live window and defaults to the selected one.
6341 Second parameter WIDTH specifies the pixel width for the scroll bar;
6342 this is automatically adjusted to a multiple of the frame column width.
6343 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6344 bar: left, right, or nil.
6345 If WIDTH is nil, use the frame's scroll-bar width.
6346 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6347 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6348 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6350 struct window
*w
= decode_live_window (window
);
6354 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6356 if (XINT (width
) == 0)
6357 vertical_type
= Qnil
;
6360 if (!(NILP (vertical_type
)
6361 || EQ (vertical_type
, Qleft
)
6362 || EQ (vertical_type
, Qright
)
6363 || EQ (vertical_type
, Qt
)))
6364 error ("Invalid type of vertical scroll bar");
6366 if (!EQ (w
->scroll_bar_width
, width
)
6367 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6369 wset_scroll_bar_width (w
, width
);
6370 wset_vertical_scroll_bar_type (w
, vertical_type
);
6372 adjust_window_margins (w
);
6374 clear_glyph_matrix (w
->current_matrix
);
6375 w
->window_end_valid
= 0;
6377 ++windows_or_buffers_changed
;
6378 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6385 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6387 doc
: /* Get width and type of scroll bars of window WINDOW.
6388 WINDOW must be a live window and defaults to the selected one.
6390 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6391 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6393 (Lisp_Object window
)
6395 struct window
*w
= decode_live_window (window
);
6397 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6398 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6399 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6400 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6401 w
->vertical_scroll_bar_type
, Qnil
);
6406 /***********************************************************************
6408 ***********************************************************************/
6410 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6411 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6412 If WINDOW is omitted or nil, it defaults to the selected window.
6413 Normally, value is a multiple of the canonical character height of WINDOW;
6414 optional second arg PIXELS-P means value is measured in pixels. */)
6415 (Lisp_Object window
, Lisp_Object pixels_p
)
6418 struct window
*w
= decode_live_window (window
);
6419 struct frame
*f
= XFRAME (w
->frame
);
6421 if (FRAME_WINDOW_P (f
))
6422 result
= (NILP (pixels_p
)
6423 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6424 : make_number (-w
->vscroll
));
6426 result
= make_number (0);
6431 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6433 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6434 WINDOW nil means use the selected window. Normally, VSCROLL is a
6435 non-negative multiple of the canonical character height of WINDOW;
6436 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6437 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6438 corresponds to an integral number of pixels. The return value is the
6439 result of this rounding.
6440 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6441 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6443 struct window
*w
= decode_live_window (window
);
6444 struct frame
*f
= XFRAME (w
->frame
);
6446 CHECK_NUMBER_OR_FLOAT (vscroll
);
6448 if (FRAME_WINDOW_P (f
))
6450 int old_dy
= w
->vscroll
;
6452 w
->vscroll
= - (NILP (pixels_p
)
6453 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6454 : XFLOATINT (vscroll
));
6455 w
->vscroll
= min (w
->vscroll
, 0);
6457 if (w
->vscroll
!= old_dy
)
6459 /* Adjust glyph matrix of the frame if the virtual display
6460 area becomes larger than before. */
6461 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6464 /* Prevent redisplay shortcuts. */
6465 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6469 return Fwindow_vscroll (window
, pixels_p
);
6473 /* Call FN for all leaf windows on frame F. FN is called with the
6474 first argument being a pointer to the leaf window, and with
6475 additional argument USER_DATA. Stops when FN returns 0. */
6478 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6481 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6482 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6483 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6487 /* Helper function for foreach_window. Call FN for all leaf windows
6488 reachable from W. FN is called with the first argument being a
6489 pointer to the leaf window, and with additional argument USER_DATA.
6490 Stop when FN returns 0. Value is 0 if stopped by FN. */
6493 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6497 for (cont
= 1; w
&& cont
;)
6499 if (!NILP (w
->hchild
))
6500 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6501 else if (!NILP (w
->vchild
))
6502 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6504 cont
= fn (w
, user_data
);
6506 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6513 /* Freeze or unfreeze the window start of W unless it is a
6514 mini-window or the selected window. FREEZE_P non-null means freeze
6515 the window start. */
6518 freeze_window_start (struct window
*w
, void *freeze_p
)
6520 if (MINI_WINDOW_P (w
)
6521 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6522 && (w
== XWINDOW (selected_window
)
6523 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6524 && ! NILP (Vminibuf_scroll_window
)
6525 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6528 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6533 /* Freeze or unfreeze the window starts of all leaf windows on frame
6534 F, except the selected window and a mini-window. FREEZE_P non-zero
6535 means freeze the window start. */
6538 freeze_window_starts (struct frame
*f
, bool freeze_p
)
6540 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6544 /***********************************************************************
6546 ***********************************************************************/
6548 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6549 describe the same state of affairs. This is used by Fequal.
6551 IGNORE_POSITIONS means ignore non-matching scroll positions
6554 This ignores a couple of things like the dedication status of
6555 window, combination_limit and the like. This might have to be
6559 compare_window_configurations (Lisp_Object configuration1
,
6560 Lisp_Object configuration2
,
6561 bool ignore_positions
)
6563 register struct save_window_data
*d1
, *d2
;
6564 struct Lisp_Vector
*sws1
, *sws2
;
6567 CHECK_WINDOW_CONFIGURATION (configuration1
);
6568 CHECK_WINDOW_CONFIGURATION (configuration2
);
6570 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6571 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6572 sws1
= XVECTOR (d1
->saved_windows
);
6573 sws2
= XVECTOR (d2
->saved_windows
);
6575 /* Frame settings must match. */
6576 if (d1
->frame_cols
!= d2
->frame_cols
6577 || d1
->frame_lines
!= d2
->frame_lines
6578 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6579 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6580 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6581 || (!ignore_positions
6582 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6583 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6584 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6585 /* Verify that the two configurations have the same number of windows. */
6586 || sws1
->header
.size
!= sws2
->header
.size
)
6589 for (i
= 0; i
< sws1
->header
.size
; i
++)
6591 struct saved_window
*sw1
, *sw2
;
6593 sw1
= SAVED_WINDOW_N (sws1
, i
);
6594 sw2
= SAVED_WINDOW_N (sws2
, i
);
6597 /* The "current" windows in the two configurations must
6598 correspond to each other. */
6599 EQ (d1
->current_window
, sw1
->window
)
6600 != EQ (d2
->current_window
, sw2
->window
)
6601 /* Windows' buffers must match. */
6602 || !EQ (sw1
->buffer
, sw2
->buffer
)
6603 || !EQ (sw1
->left_col
, sw2
->left_col
)
6604 || !EQ (sw1
->top_line
, sw2
->top_line
)
6605 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6606 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6607 || !EQ (sw1
->display_table
, sw2
->display_table
)
6608 /* The next two disjuncts check the window structure for
6610 || !EQ (sw1
->parent
, sw2
->parent
)
6611 || !EQ (sw1
->prev
, sw2
->prev
)
6612 || (!ignore_positions
6613 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6614 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6615 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6616 || NILP (Fequal (sw1
->start
, sw2
->start
))
6617 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6618 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6619 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6620 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6621 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6622 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6623 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6624 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6625 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6632 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6633 Scompare_window_configurations
, 2, 2, 0,
6634 doc
: /* Compare two window configurations as regards the structure of windows.
6635 This function ignores details such as the values of point and mark
6636 and scrolling positions. */)
6637 (Lisp_Object x
, Lisp_Object y
)
6639 if (compare_window_configurations (x
, y
, 1))
6645 init_window_once (void)
6647 struct frame
*f
= make_initial_frame ();
6648 XSETFRAME (selected_frame
, f
);
6649 Vterminal_frame
= selected_frame
;
6650 minibuf_window
= f
->minibuffer_window
;
6651 selected_window
= f
->selected_window
;
6652 last_nonminibuf_frame
= f
;
6654 window_initialized
= 1;
6660 Vwindow_list
= Qnil
;
6664 syms_of_window (void)
6666 DEFSYM (Qscroll_up
, "scroll-up");
6667 DEFSYM (Qscroll_down
, "scroll-down");
6668 DEFSYM (Qscroll_command
, "scroll-command");
6670 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6671 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6673 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6674 DEFSYM (Qwindowp
, "windowp");
6675 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6676 DEFSYM (Qwindow_live_p
, "window-live-p");
6677 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6678 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6679 DEFSYM (Qdelete_window
, "delete-window");
6680 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6681 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6682 DEFSYM (Qsafe
, "safe");
6683 DEFSYM (Qdisplay_buffer
, "display-buffer");
6684 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6685 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6686 DEFSYM (Qget_mru_window
, "get-mru-window");
6687 DEFSYM (Qwindow_size
, "window-size");
6688 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6689 DEFSYM (Qabove
, "above");
6690 DEFSYM (Qbelow
, "below");
6691 DEFSYM (Qclone_of
, "clone-of");
6693 staticpro (&Vwindow_list
);
6695 minibuf_selected_window
= Qnil
;
6696 staticpro (&minibuf_selected_window
);
6698 window_scroll_pixel_based_preserve_x
= -1;
6699 window_scroll_pixel_based_preserve_y
= -1;
6700 window_scroll_preserve_hpos
= -1;
6701 window_scroll_preserve_vpos
= -1;
6703 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6704 doc
: /* Non-nil means call as function to display a help buffer.
6705 The function is called with one argument, the buffer to be displayed.
6706 Used by `with-output-to-temp-buffer'.
6707 If this function is used, then it must do the entire job of showing
6708 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6709 Vtemp_buffer_show_function
= Qnil
;
6711 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6712 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6713 Vminibuf_scroll_window
= Qnil
;
6715 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6716 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6717 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6718 is displayed in the `mode-line' face. */);
6719 mode_line_in_non_selected_windows
= 1;
6721 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6722 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6723 Vother_window_scroll_buffer
= Qnil
;
6725 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6726 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6727 auto_window_vscroll_p
= 1;
6729 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6730 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6731 next_screen_context_lines
= 2;
6733 DEFVAR_LISP ("scroll-preserve-screen-position",
6734 Vscroll_preserve_screen_position
,
6735 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6736 A value of nil means point does not keep its screen position except
6737 at the scroll margin or window boundary respectively.
6738 A value of t means point keeps its screen position if the scroll
6739 command moved it vertically out of the window, e.g. when scrolling
6741 Any other value means point always keeps its screen position.
6742 Scroll commands should have the `scroll-command' property
6743 on their symbols to be controlled by this variable. */);
6744 Vscroll_preserve_screen_position
= Qnil
;
6746 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6747 doc
: /* Type of marker to use for `window-point'. */);
6748 Vwindow_point_insertion_type
= Qnil
;
6750 DEFVAR_LISP ("window-configuration-change-hook",
6751 Vwindow_configuration_change_hook
,
6752 doc
: /* Functions to call when window configuration changes.
6753 The buffer-local part is run once per window, with the relevant window
6754 selected; while the global part is run only once for the modified frame,
6755 with the relevant frame selected. */);
6756 Vwindow_configuration_change_hook
= Qnil
;
6758 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6759 doc
: /* Non-nil means `recenter' redraws entire frame.
6760 If this option is non-nil, then the `recenter' command with a nil
6761 argument will redraw the entire frame; the special value `tty' causes
6762 the frame to be redrawn only if it is a tty frame. */);
6763 Vrecenter_redisplay
= Qtty
;
6765 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6766 doc
: /* If t, resize window combinations proportionally.
6767 If this variable is nil, splitting a window gets the entire screen space
6768 for displaying the new window from the window to split. Deleting and
6769 resizing a window preferably resizes one adjacent window only.
6771 If this variable is t, splitting a window tries to get the space
6772 proportionally from all windows in the same combination. This also
6773 allows to split a window that is otherwise too small or of fixed size.
6774 Resizing and deleting a window proportionally resize all windows in the
6777 Other values are reserved for future use.
6779 This variable takes no effect if the variable `window-combination-limit' is
6781 Vwindow_combination_resize
= Qnil
;
6783 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6784 doc
: /* If non-nil, splitting a window makes a new parent window.
6785 The following values are recognized:
6787 nil means splitting a window will create a new parent window only if the
6788 window has no parent window or the window shall become part of a
6789 combination orthogonal to the one it is part of.
6791 `window-size' means that splitting a window for displaying a buffer
6792 makes a new parent window provided `display-buffer' is supposed to
6793 explicitly set the window's size due to the presence of a
6794 `window-height' or `window-width' entry in the alist used by
6795 `display-buffer'. Otherwise, this value is handled like nil.
6797 `temp-buffer' means that splitting a window for displaying a temporary
6798 buffer always makes a new parent window. Otherwise, this value is
6801 `display-buffer' means that splitting a window for displaying a buffer
6802 always makes a new parent window. Since temporary buffers are
6803 displayed by the function `display-buffer', this value is stronger
6804 than `temp-buffer'. Splitting a window for other purpose makes a
6805 new parent window only if needed.
6807 t means that splitting a window always creates a new parent window. If
6808 all splits behave this way, each frame's window tree is a binary
6809 tree and every window but the frame's root window has exactly one
6812 Other values are reserved for future use. */);
6813 Vwindow_combination_limit
= Qwindow_size
;
6815 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6816 doc
: /* Alist of persistent window parameters.
6817 This alist specifies which window parameters shall get saved by
6818 `current-window-configuration' and `window-state-get' and subsequently
6819 restored to their previous values by `set-window-configuration' and
6822 The car of each entry of this alist is the symbol specifying the
6823 parameter. The cdr is one of the following:
6825 nil means the parameter is neither saved by `window-state-get' nor by
6826 `current-window-configuration'.
6828 t means the parameter is saved by `current-window-configuration' and,
6829 provided its WRITABLE argument is nil, by `window-state-get'.
6831 The symbol `writable' means the parameter is saved unconditionally by
6832 both `current-window-configuration' and `window-state-get'. Do not use
6833 this value for parameters without read syntax (like windows or frames).
6835 Parameters not saved by `current-window-configuration' or
6836 `window-state-get' are left alone by `set-window-configuration'
6837 respectively are not installed by `window-state-put'. */);
6838 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6840 defsubr (&Sselected_window
);
6841 defsubr (&Sminibuffer_window
);
6842 defsubr (&Swindow_minibuffer_p
);
6843 defsubr (&Swindowp
);
6844 defsubr (&Swindow_valid_p
);
6845 defsubr (&Swindow_live_p
);
6846 defsubr (&Swindow_frame
);
6847 defsubr (&Sframe_root_window
);
6848 defsubr (&Sframe_first_window
);
6849 defsubr (&Sframe_selected_window
);
6850 defsubr (&Sset_frame_selected_window
);
6851 defsubr (&Spos_visible_in_window_p
);
6852 defsubr (&Swindow_line_height
);
6853 defsubr (&Swindow_buffer
);
6854 defsubr (&Swindow_parent
);
6855 defsubr (&Swindow_top_child
);
6856 defsubr (&Swindow_left_child
);
6857 defsubr (&Swindow_next_sibling
);
6858 defsubr (&Swindow_prev_sibling
);
6859 defsubr (&Swindow_combination_limit
);
6860 defsubr (&Sset_window_combination_limit
);
6861 defsubr (&Swindow_use_time
);
6862 defsubr (&Swindow_top_line
);
6863 defsubr (&Swindow_left_column
);
6864 defsubr (&Swindow_total_height
);
6865 defsubr (&Swindow_total_width
);
6866 defsubr (&Swindow_normal_size
);
6867 defsubr (&Swindow_new_total
);
6868 defsubr (&Swindow_new_normal
);
6869 defsubr (&Sset_window_new_total
);
6870 defsubr (&Sset_window_new_normal
);
6871 defsubr (&Swindow_resize_apply
);
6872 defsubr (&Swindow_body_height
);
6873 defsubr (&Swindow_body_width
);
6874 defsubr (&Swindow_hscroll
);
6875 defsubr (&Sset_window_hscroll
);
6876 defsubr (&Swindow_redisplay_end_trigger
);
6877 defsubr (&Sset_window_redisplay_end_trigger
);
6878 defsubr (&Swindow_edges
);
6879 defsubr (&Swindow_pixel_edges
);
6880 defsubr (&Swindow_absolute_pixel_edges
);
6881 defsubr (&Swindow_inside_edges
);
6882 defsubr (&Swindow_inside_pixel_edges
);
6883 defsubr (&Swindow_inside_absolute_pixel_edges
);
6884 defsubr (&Scoordinates_in_window_p
);
6885 defsubr (&Swindow_at
);
6886 defsubr (&Swindow_point
);
6887 defsubr (&Swindow_start
);
6888 defsubr (&Swindow_end
);
6889 defsubr (&Sset_window_point
);
6890 defsubr (&Sset_window_start
);
6891 defsubr (&Swindow_dedicated_p
);
6892 defsubr (&Sset_window_dedicated_p
);
6893 defsubr (&Swindow_display_table
);
6894 defsubr (&Sset_window_display_table
);
6895 defsubr (&Snext_window
);
6896 defsubr (&Sprevious_window
);
6897 defsubr (&Sget_buffer_window
);
6898 defsubr (&Sdelete_other_windows_internal
);
6899 defsubr (&Sdelete_window_internal
);
6900 defsubr (&Sresize_mini_window_internal
);
6901 defsubr (&Sset_window_buffer
);
6902 defsubr (&Srun_window_configuration_change_hook
);
6903 defsubr (&Sselect_window
);
6904 defsubr (&Sforce_window_update
);
6905 defsubr (&Ssplit_window_internal
);
6906 defsubr (&Sscroll_up
);
6907 defsubr (&Sscroll_down
);
6908 defsubr (&Sscroll_left
);
6909 defsubr (&Sscroll_right
);
6910 defsubr (&Sother_window_for_scrolling
);
6911 defsubr (&Sscroll_other_window
);
6912 defsubr (&Sminibuffer_selected_window
);
6913 defsubr (&Srecenter
);
6914 defsubr (&Swindow_text_height
);
6915 defsubr (&Smove_to_window_line
);
6916 defsubr (&Swindow_configuration_p
);
6917 defsubr (&Swindow_configuration_frame
);
6918 defsubr (&Sset_window_configuration
);
6919 defsubr (&Scurrent_window_configuration
);
6920 defsubr (&Sset_window_margins
);
6921 defsubr (&Swindow_margins
);
6922 defsubr (&Sset_window_fringes
);
6923 defsubr (&Swindow_fringes
);
6924 defsubr (&Sset_window_scroll_bars
);
6925 defsubr (&Swindow_scroll_bars
);
6926 defsubr (&Swindow_vscroll
);
6927 defsubr (&Sset_window_vscroll
);
6928 defsubr (&Scompare_window_configurations
);
6929 defsubr (&Swindow_list
);
6930 defsubr (&Swindow_list_1
);
6931 defsubr (&Swindow_prev_buffers
);
6932 defsubr (&Sset_window_prev_buffers
);
6933 defsubr (&Swindow_next_buffers
);
6934 defsubr (&Sset_window_next_buffers
);
6935 defsubr (&Swindow_parameters
);
6936 defsubr (&Swindow_parameter
);
6937 defsubr (&Sset_window_parameter
);
6941 keys_of_window (void)
6943 initial_define_key (control_x_map
, '<', "scroll-left");
6944 initial_define_key (control_x_map
, '>', "scroll-right");
6946 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6947 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6948 initial_define_key (meta_map
, 'v', "scroll-down-command");