1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2012
4 Free Software Foundation, Inc.
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
*, int);
88 static void window_resize_apply (struct window
*, int);
89 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
91 /* This is the window in which the terminal's cursor should
92 be left when nothing is being done with it. This must
93 always be a leaf window, and its buffer is selected by
94 the top level editing loop at the end of each command.
96 This value is always the same as
97 FRAME_SELECTED_WINDOW (selected_frame). */
98 Lisp_Object selected_window
;
100 /* A list of all windows for use by next_window and Fwindow_list.
101 Functions creating or deleting windows should invalidate this cache
102 by setting it to nil. */
103 Lisp_Object Vwindow_list
;
105 /* The mini-buffer window of the selected frame.
106 Note that you cannot test for mini-bufferness of an arbitrary window
107 by comparing against this; but you can test for mini-bufferness of
108 the selected window. */
109 Lisp_Object minibuf_window
;
111 /* Non-nil means it is the window whose mode line should be
112 shown as the selected window when the minibuffer is selected. */
113 Lisp_Object minibuf_selected_window
;
115 /* Hook run at end of temp_output_buffer_show. */
116 static Lisp_Object Qtemp_buffer_show_hook
;
118 /* Incremented for each window created. */
119 static int sequence_number
;
121 /* Nonzero after init_window_once has finished. */
122 static int window_initialized
;
124 /* Hook to run when window config changes. */
125 static Lisp_Object Qwindow_configuration_change_hook
;
127 /* Used by the function window_scroll_pixel_based */
128 static int window_scroll_pixel_based_preserve_x
;
129 static int window_scroll_pixel_based_preserve_y
;
131 /* Same for window_scroll_line_based. */
132 static EMACS_INT window_scroll_preserve_hpos
;
133 static EMACS_INT window_scroll_preserve_vpos
;
135 /* These setters are used only in this file, so they can be private. */
137 wset_combination_limit (struct window
*w
, Lisp_Object val
)
139 w
->combination_limit
= val
;
142 wset_dedicated (struct window
*w
, Lisp_Object val
)
147 wset_display_table (struct window
*w
, Lisp_Object val
)
149 w
->display_table
= val
;
152 wset_hchild (struct window
*w
, Lisp_Object val
)
157 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
159 w
->left_fringe_width
= val
;
162 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
164 w
->left_margin_cols
= val
;
167 wset_new_normal (struct window
*w
, Lisp_Object val
)
172 wset_new_total (struct window
*w
, Lisp_Object val
)
177 wset_normal_cols (struct window
*w
, Lisp_Object val
)
179 w
->normal_cols
= val
;
182 wset_normal_lines (struct window
*w
, Lisp_Object val
)
184 w
->normal_lines
= val
;
187 wset_parent (struct window
*w
, Lisp_Object val
)
192 wset_pointm (struct window
*w
, Lisp_Object val
)
197 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
199 w
->right_fringe_width
= val
;
202 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
204 w
->right_margin_cols
= val
;
207 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
209 w
->scroll_bar_width
= val
;
212 wset_start (struct window
*w
, Lisp_Object val
)
217 wset_temslot (struct window
*w
, Lisp_Object val
)
222 wset_vchild (struct window
*w
, Lisp_Object val
)
227 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
229 w
->vertical_scroll_bar_type
= val
;
232 wset_window_parameters (struct window
*w
, Lisp_Object val
)
234 w
->window_parameters
= val
;
238 decode_live_window (register Lisp_Object window
)
241 return XWINDOW (selected_window
);
243 CHECK_LIVE_WINDOW (window
);
244 return XWINDOW (window
);
248 decode_any_window (register Lisp_Object window
)
253 return XWINDOW (selected_window
);
255 CHECK_WINDOW (window
);
256 w
= XWINDOW (window
);
260 static struct window
*
261 decode_valid_window (register Lisp_Object window
)
266 return XWINDOW (selected_window
);
268 CHECK_VALID_WINDOW (window
);
269 w
= XWINDOW (window
);
273 /* Build a frequently used 4-integer (X Y W H) list. */
276 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
278 return list4 (make_number (x
), make_number (y
),
279 make_number (w
), make_number (h
));
282 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
283 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
286 return WINDOWP (object
) ? Qt
: Qnil
;
289 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
290 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
291 A valid window is either a window that displays a buffer or an internal
292 window. Deleted windows are not live. */)
295 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
298 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
299 doc
: /* Return t if OBJECT is a live window and nil otherwise.
300 A live window is a window that displays a buffer.
301 Internal windows and deleted windows are not live. */)
304 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
307 /* Frames and windows. */
308 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
309 doc
: /* Return the frame that window WINDOW is on.
310 WINDOW must be a valid window and defaults to the selected one. */)
313 return decode_valid_window (window
)->frame
;
316 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
317 doc
: /* Return the root window of FRAME-OR-WINDOW.
318 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
319 With a frame argument, return that frame's root window.
320 With a window argument, return the root window of that window's frame. */)
321 (Lisp_Object frame_or_window
)
325 if (NILP (frame_or_window
))
326 window
= SELECTED_FRAME ()->root_window
;
327 else if (WINDOW_VALID_P (frame_or_window
))
328 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
331 CHECK_LIVE_FRAME (frame_or_window
);
332 window
= XFRAME (frame_or_window
)->root_window
;
338 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
339 doc
: /* Return the minibuffer window for frame FRAME.
340 If FRAME is omitted or nil, it defaults to the selected frame. */)
343 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
346 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
347 Swindow_minibuffer_p
, 0, 1, 0,
348 doc
: /* Return non-nil if WINDOW is a minibuffer window.
349 WINDOW must be a valid window and defaults to the selected one. */)
352 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
355 /* Don't move this to window.el - this must be a safe routine. */
356 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
357 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
358 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
359 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
360 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
361 the first window of that frame. */)
362 (Lisp_Object frame_or_window
)
366 if (NILP (frame_or_window
))
367 window
= SELECTED_FRAME ()->root_window
;
368 else if (WINDOW_VALID_P (frame_or_window
))
369 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
372 CHECK_LIVE_FRAME (frame_or_window
);
373 window
= XFRAME (frame_or_window
)->root_window
;
376 while (NILP (XWINDOW (window
)->buffer
))
378 if (! NILP (XWINDOW (window
)->hchild
))
379 window
= XWINDOW (window
)->hchild
;
380 else if (! NILP (XWINDOW (window
)->vchild
))
381 window
= XWINDOW (window
)->vchild
;
389 DEFUN ("frame-selected-window", Fframe_selected_window
,
390 Sframe_selected_window
, 0, 1, 0,
391 doc
: /* Return the selected window of FRAME-OR-WINDOW.
392 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
393 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
394 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
395 return the selected window of that frame. */)
396 (Lisp_Object frame_or_window
)
400 if (NILP (frame_or_window
))
401 window
= SELECTED_FRAME ()->selected_window
;
402 else if (WINDOW_VALID_P (frame_or_window
))
403 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
406 CHECK_LIVE_FRAME (frame_or_window
);
407 window
= XFRAME (frame_or_window
)->selected_window
;
413 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
414 Sset_frame_selected_window
, 2, 3, 0,
415 doc
: /* Set selected window of FRAME to WINDOW.
416 FRAME must be a live frame and defaults to the selected one. If FRAME
417 is the selected frame, this makes WINDOW the selected window. Optional
418 argument NORECORD non-nil means to neither change the order of recently
419 selected windows nor the buffer list. WINDOW must denote a live window.
421 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
424 frame
= selected_frame
;
426 CHECK_LIVE_FRAME (frame
);
427 CHECK_LIVE_WINDOW (window
);
429 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
430 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
432 if (EQ (frame
, selected_frame
))
433 return Fselect_window (window
, norecord
);
436 fset_selected_window (XFRAME (frame
), window
);
441 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
442 doc
: /* Return the selected window.
443 The selected window is the window in which the standard cursor for
444 selected windows appears and to which many commands apply. */)
447 return selected_window
;
450 int window_select_count
;
452 /* If select_window is called with inhibit_point_swap non-zero it will
453 not store point of the old selected window's buffer back into that
454 window's pointm slot. This is needed by Fset_window_configuration to
455 avoid that the display routine is called with selected_window set to
456 Qnil causing a subsequent crash. */
458 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
460 register struct window
*w
;
461 register struct window
*ow
;
464 CHECK_LIVE_WINDOW (window
);
466 w
= XWINDOW (window
);
467 w
->frozen_window_start_p
= 0;
471 w
->use_time
= ++window_select_count
;
472 record_buffer (w
->buffer
);
475 /* Make the selected window's buffer current. */
476 Fset_buffer (w
->buffer
);
478 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
481 sf
= SELECTED_FRAME ();
482 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
484 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
485 /* Use this rather than Fhandle_switch_frame
486 so that FRAME_FOCUS_FRAME is moved appropriately as we
487 move around in the state where a minibuffer in a separate
489 Fselect_frame (WINDOW_FRAME (w
), norecord
);
490 /* Fselect_frame called us back so we've done all the work already. */
491 eassert (EQ (window
, selected_window
));
495 fset_selected_window (sf
, window
);
497 /* Store the old selected window's buffer's point in pointm of the old
498 selected window. It belongs to that window, and when the window is
499 not selected, must be in the window. */
500 if (!inhibit_point_swap
)
502 ow
= XWINDOW (selected_window
);
503 if (! NILP (ow
->buffer
))
504 set_marker_both (ow
->pointm
, ow
->buffer
,
505 BUF_PT (XBUFFER (ow
->buffer
)),
506 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
509 selected_window
= window
;
510 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
512 /* Go to the point recorded in the window.
513 This is important when the buffer is in more
514 than one window. It also matters when
515 redisplay_window has altered point after scrolling,
516 because it makes the change only in the window. */
518 register ptrdiff_t new_point
= marker_position (w
->pointm
);
519 if (new_point
< BEGV
)
521 else if (new_point
> ZV
)
527 windows_or_buffers_changed
++;
531 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
532 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
533 Also make WINDOW's buffer current and make WINDOW the frame's selected
534 window. Return WINDOW.
536 Optional second arg NORECORD non-nil means do not put this buffer at the
537 front of the buffer list and do not make this window the most recently
540 Note that the main editor command loop sets the current buffer to the
541 buffer of the selected window before each command. */)
542 (register Lisp_Object window
, Lisp_Object norecord
)
544 return select_window (window
, norecord
, 0);
547 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
548 doc
: /* Return the buffer displayed in window WINDOW.
549 If WINDOW is omitted or nil, it defaults to the selected window.
550 Return nil for an internal window or a deleted window. */)
553 return decode_any_window (window
)->buffer
;
556 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
557 doc
: /* Return the parent window of window WINDOW.
558 WINDOW must be a valid window and defaults to the selected one.
559 Return nil for a window with no parent (e.g. a root window). */)
562 return decode_valid_window (window
)->parent
;
565 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
566 doc
: /* Return the topmost child window of window WINDOW.
567 WINDOW must be a valid window and defaults to the selected one.
568 Return nil if WINDOW is a live window (live windows have no children).
569 Return nil if WINDOW is an internal window whose children form a
570 horizontal combination. */)
573 return decode_valid_window (window
)->vchild
;
576 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
577 doc
: /* Return the leftmost child window of window WINDOW.
578 WINDOW must be a valid window and defaults to the selected one.
579 Return nil if WINDOW is a live window (live windows have no children).
580 Return nil if WINDOW is an internal window whose children form a
581 vertical combination. */)
584 return decode_valid_window (window
)->hchild
;
587 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
588 doc
: /* Return the next sibling window of window WINDOW.
589 WINDOW must be a valid window and defaults to the selected one.
590 Return nil if WINDOW has no next sibling. */)
593 return decode_valid_window (window
)->next
;
596 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
597 doc
: /* Return the previous sibling window of window WINDOW.
598 WINDOW must be a valid window and defaults to the selected one.
599 Return nil if WINDOW has no previous sibling. */)
602 return decode_valid_window (window
)->prev
;
605 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
606 doc
: /* Return combination limit of window WINDOW.
607 If the return value is nil, child windows of WINDOW can be recombined with
608 WINDOW's siblings. A return value of t means that child windows of
609 WINDOW are never \(re-)combined with WINDOW's siblings.
611 WINDOW must be a valid window. The return value is meaningful for
612 internal windows only. */)
615 CHECK_VALID_WINDOW (window
);
616 return XWINDOW (window
)->combination_limit
;
619 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
620 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
621 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
622 siblings. LIMIT t means that child windows of WINDOW are never
623 \(re-)combined with WINDOW's siblings. Other values are reserved for
626 WINDOW must be a valid window. Setting the combination limit is
627 meaningful for internal windows only. */)
628 (Lisp_Object window
, Lisp_Object limit
)
630 wset_combination_limit (decode_valid_window (window
), limit
);
634 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
635 doc
: /* Return the use time of window WINDOW.
636 WINDOW must be a live window and defaults to the selected one.
637 The window with the highest use time is the most recently selected
638 one. The window with the lowest use time is the least recently
642 return make_number (decode_live_window (window
)->use_time
);
645 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
646 doc
: /* Return the total height, in lines, of window WINDOW.
647 WINDOW must be a valid window and defaults to the selected one.
649 The return value includes the mode line and header line, if any.
650 If WINDOW is an internal window, the total height is the height
651 of the screen areas spanned by its children.
653 On a graphical display, this total height is reported as an
654 integer multiple of the default character height. */)
657 return decode_valid_window (window
)->total_lines
;
660 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
661 doc
: /* Return the total width, in columns, of window WINDOW.
662 WINDOW must be a valid window and defaults to the selected one.
664 The return value includes any vertical dividers or scroll bars
665 belonging to WINDOW. If WINDOW is an internal window, the total width
666 is the width of the screen areas spanned by its children.
668 On a graphical display, this total width is reported as an
669 integer multiple of the default character width. */)
672 return decode_valid_window (window
)->total_cols
;
675 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
676 doc
: /* Return the new total size of window WINDOW.
677 WINDOW must be a valid window and defaults to the selected one. */)
680 return decode_valid_window (window
)->new_total
;
683 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
684 doc
: /* Return the normal height of window WINDOW.
685 WINDOW must be a valid window and defaults to the selected one.
686 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
687 (Lisp_Object window
, Lisp_Object horizontal
)
689 struct window
*w
= decode_valid_window (window
);
691 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
694 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
695 doc
: /* Return new normal size of window WINDOW.
696 WINDOW must be a valid window and defaults to the selected one. */)
699 return decode_valid_window (window
)->new_normal
;
702 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
703 doc
: /* Return left column of window WINDOW.
704 This is the distance, in columns, between the left edge of WINDOW and
705 the left edge of the frame's window area. For instance, the return
706 value is 0 if there is no window to the left of WINDOW.
708 WINDOW must be a valid window and defaults to the selected one. */)
711 return decode_valid_window (window
)->left_col
;
714 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
715 doc
: /* Return top line of window WINDOW.
716 This is the distance, in lines, between the top of WINDOW and the top
717 of the frame's window area. For instance, the return value is 0 if
718 there is no window above WINDOW.
720 WINDOW must be a valid window and defaults to the selected one. */)
723 return decode_valid_window (window
)->top_line
;
726 /* Return the number of lines of W's body. Don't count any mode or
730 window_body_lines (struct window
*w
)
732 int height
= XFASTINT (w
->total_lines
);
734 if (!MINI_WINDOW_P (w
))
736 if (WINDOW_WANTS_MODELINE_P (w
))
738 if (WINDOW_WANTS_HEADER_LINE_P (w
))
745 /* Return the number of columns of W's body. Don't count columns
746 occupied by the scroll bar or the vertical bar separating W from its
747 right sibling. On window-systems don't count fringes or display
751 window_body_cols (struct window
*w
)
753 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
754 int width
= XINT (w
->total_cols
);
756 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
757 /* Scroll bars occupy a few columns. */
758 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
759 else if (!FRAME_WINDOW_P (f
)
760 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
761 /* The column of `|' characters separating side-by-side windows
762 occupies one column only. */
765 if (FRAME_WINDOW_P (f
))
766 /* On window-systems, fringes and display margins cannot be
767 used for normal text. */
768 width
-= (WINDOW_FRINGE_COLS (w
)
769 + WINDOW_LEFT_MARGIN_COLS (w
)
770 + WINDOW_RIGHT_MARGIN_COLS (w
));
775 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
776 doc
: /* Return the height, in lines, of WINDOW's text area.
777 WINDOW must be a live window and defaults to the selected one.
779 The returned height does not include the mode line or header line.
780 On a graphical display, the height is expressed as an integer multiple
781 of the default character height. If a line at the bottom of the text
782 area is only partially visible, that counts as a whole line; to
783 exclude partially-visible lines, use `window-text-height'. */)
786 return make_number (window_body_lines (decode_live_window (window
)));
789 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
790 doc
: /* Return the width, in columns, of WINDOW's text area.
791 WINDOW must be a live window and defaults to the selected one.
793 The return value does not include any vertical dividers, fringe or
794 marginal areas, or scroll bars. On a graphical display, the width is
795 expressed as an integer multiple of the default character width. */)
798 return make_number (window_body_cols (decode_live_window (window
)));
801 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
802 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
803 WINDOW must be a live window and defaults to the selected one. */)
806 return make_number (decode_live_window (window
)->hscroll
);
809 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
810 range, returning the new amount as a fixnum. */
812 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
814 /* Horizontal scrolling has problems with large scroll amounts.
815 It's too slow with long lines, and even with small lines the
816 display can be messed up. For now, though, impose only the limits
817 required by the internal representation: horizontal scrolling must
818 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
819 (since it's stored in a ptrdiff_t). */
820 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
821 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
823 /* Prevent redisplay shortcuts when changing the hscroll. */
824 if (w
->hscroll
!= new_hscroll
)
825 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
827 w
->hscroll
= new_hscroll
;
828 return make_number (new_hscroll
);
831 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
832 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
833 WINDOW must be a live window and defaults to the selected one.
834 Clip the number to a reasonable value if out of range.
835 Return the new number. NCOL should be zero or positive.
837 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
838 window so that the location of point moves off-window. */)
839 (Lisp_Object window
, Lisp_Object ncol
)
842 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
845 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
846 Swindow_redisplay_end_trigger
, 0, 1, 0,
847 doc
: /* Return WINDOW's redisplay end trigger value.
848 WINDOW must be a live window and defaults to the selected one.
849 See `set-window-redisplay-end-trigger' for more information. */)
852 return decode_live_window (window
)->redisplay_end_trigger
;
855 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
856 Sset_window_redisplay_end_trigger
, 2, 2, 0,
857 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
858 WINDOW must be a live window and defaults to the selected one. VALUE
859 should be a buffer position (typically a marker) or nil. If it is a
860 buffer position, then if redisplay in WINDOW reaches a position beyond
861 VALUE, the functions in `redisplay-end-trigger-functions' are called
862 with two arguments: WINDOW, and the end trigger value. Afterwards the
863 end-trigger value is reset to nil. */)
864 (register Lisp_Object window
, Lisp_Object value
)
866 wset_redisplay_end_trigger (decode_live_window (window
), value
);
870 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
871 doc
: /* Return a list of the edge coordinates of WINDOW.
872 WINDOW must be a valid window and defaults to the selected one.
874 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
875 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
876 0 at top left corner of frame.
878 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
879 is one more than the bottommost row occupied by WINDOW. The edges
880 include the space used by WINDOW's scroll bar, display margins, fringes,
881 header line, and/or mode line. For the edges of just the text area, use
882 `window-inside-edges'. */)
885 register struct window
*w
= decode_valid_window (window
);
887 return list4i (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
888 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
891 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
892 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
893 WINDOW must be a valid window and defaults to the selected one.
895 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
896 0, 0 at the top left corner of the frame.
898 RIGHT is one more than the rightmost x position occupied by WINDOW.
899 BOTTOM is one more than the bottommost y position occupied by WINDOW.
900 The pixel edges include the space used by WINDOW's scroll bar, display
901 margins, fringes, header line, and/or mode line. For the pixel edges
902 of just the text area, use `window-inside-pixel-edges'. */)
905 register struct window
*w
= decode_valid_window (window
);
907 return list4i (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
908 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
912 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
914 struct frame
*f
= XFRAME (w
->frame
);
916 #ifdef FRAME_MENUBAR_HEIGHT
917 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
919 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
920 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
921 #elif FRAME_TOOLBAR_HEIGHT
922 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
924 #ifdef FRAME_NS_TITLEBAR_HEIGHT
925 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
927 *add_x
= f
->left_pos
;
928 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
929 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
933 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
934 Swindow_absolute_pixel_edges
, 0, 1, 0,
935 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
936 WINDOW must be a valid window and defaults to the selected one.
938 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
939 0, 0 at the top left corner of the display.
941 RIGHT is one more than the rightmost x position occupied by WINDOW.
942 BOTTOM is one more than the bottommost y position occupied by WINDOW.
943 The pixel edges include the space used by WINDOW's scroll bar, display
944 margins, fringes, header line, and/or mode line. For the pixel edges
945 of just the text area, use `window-inside-absolute-pixel-edges'. */)
948 register struct window
*w
= decode_valid_window (window
);
951 calc_absolute_offset (w
, &add_x
, &add_y
);
953 return list4i (WINDOW_LEFT_EDGE_X (w
) + add_x
,
954 WINDOW_TOP_EDGE_Y (w
) + add_y
,
955 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
956 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
959 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
960 doc
: /* Return a list of the edge coordinates of WINDOW.
961 WINDOW must be a live window and defaults to the selected one.
963 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
964 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
965 0 at top left corner of frame.
967 RIGHT is one more than the rightmost column of WINDOW's text area.
968 BOTTOM is one more than the bottommost row of WINDOW's text area. The
969 inside edges do not include the space used by the WINDOW's scroll bar,
970 display margins, fringes, header line, and/or mode line. */)
973 register struct window
*w
= decode_live_window (window
);
975 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w
)
976 + WINDOW_LEFT_MARGIN_COLS (w
)
977 + WINDOW_LEFT_FRINGE_COLS (w
)),
978 (WINDOW_TOP_EDGE_LINE (w
)
979 + WINDOW_HEADER_LINE_LINES (w
)),
980 (WINDOW_BOX_RIGHT_EDGE_COL (w
)
981 - WINDOW_RIGHT_MARGIN_COLS (w
)
982 - WINDOW_RIGHT_FRINGE_COLS (w
)),
983 (WINDOW_BOTTOM_EDGE_LINE (w
)
984 - WINDOW_MODE_LINE_LINES (w
)));
987 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
988 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
989 WINDOW must be a live window and defaults to the selected one.
991 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
992 (0,0) at the top left corner of the frame's window area.
994 RIGHT is one more than the rightmost x position of WINDOW's text area.
995 BOTTOM is one more than the bottommost y position of WINDOW's text area.
996 The inside edges do not include the space used by WINDOW's scroll bar,
997 display margins, fringes, header line, and/or mode line. */)
1000 register struct window
*w
= decode_live_window (window
);
1002 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1003 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1004 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1005 (WINDOW_TOP_EDGE_Y (w
)
1006 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1007 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1008 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1009 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1010 (WINDOW_BOTTOM_EDGE_Y (w
)
1011 - WINDOW_MODE_LINE_HEIGHT (w
)));
1014 DEFUN ("window-inside-absolute-pixel-edges",
1015 Fwindow_inside_absolute_pixel_edges
,
1016 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1017 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1018 WINDOW must be a live window and defaults to the selected one.
1020 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1021 (0,0) at the top left corner of the frame's window area.
1023 RIGHT is one more than the rightmost x position of WINDOW's text area.
1024 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1025 The inside edges do not include the space used by WINDOW's scroll bar,
1026 display margins, fringes, header line, and/or mode line. */)
1027 (Lisp_Object window
)
1029 register struct window
*w
= decode_live_window (window
);
1032 calc_absolute_offset (w
, &add_x
, &add_y
);
1034 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1035 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1036 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1037 (WINDOW_TOP_EDGE_Y (w
)
1038 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1039 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1040 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1041 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1042 (WINDOW_BOTTOM_EDGE_Y (w
)
1043 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1046 /* Test if the character at column X, row Y is within window W.
1047 If it is not, return ON_NOTHING;
1048 if it is in the window's text area, return ON_TEXT;
1049 if it is on the window's modeline, return ON_MODE_LINE;
1050 if it is on the border between the window and its right sibling,
1051 return ON_VERTICAL_BORDER.
1052 if it is on a scroll bar, return ON_SCROLL_BAR.
1053 if it is on the window's top line, return ON_HEADER_LINE;
1054 if it is in left or right fringe of the window,
1055 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1056 if it is in the marginal area to the left/right of the window,
1057 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1059 X and Y are frame relative pixel coordinates. */
1061 static enum window_part
1062 coordinates_in_window (register struct window
*w
, int x
, int y
)
1064 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1065 enum window_part part
;
1066 int ux
= FRAME_COLUMN_WIDTH (f
);
1067 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1068 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1069 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1070 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1071 /* The width of the area where the vertical line can be dragged.
1072 (Between mode lines for instance. */
1073 int grabbable_width
= ux
;
1074 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1076 /* Outside any interesting row or column? */
1077 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1080 /* On the mode line or header line? */
1081 if ((WINDOW_WANTS_MODELINE_P (w
)
1082 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1083 && (part
= ON_MODE_LINE
))
1084 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1085 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1086 && (part
= ON_HEADER_LINE
)))
1088 /* If it's under/over the scroll bar portion of the mode/header
1089 line, say it's on the vertical line. That's to be able to
1090 resize windows horizontally in case we're using toolkit scroll
1091 bars. Note: If scrollbars are on the left, the window that
1092 must be eventually resized is that on the left of WINDOW. */
1093 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1094 && !WINDOW_LEFTMOST_P (w
)
1095 && eabs (x
- left_x
) < grabbable_width
)
1096 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1097 && !WINDOW_RIGHTMOST_P (w
)
1098 && eabs (x
- right_x
) < grabbable_width
))
1099 return ON_VERTICAL_BORDER
;
1104 /* In what's below, we subtract 1 when computing right_x because we
1105 want the rightmost pixel, which is given by left_pixel+width-1. */
1106 if (w
->pseudo_window_p
)
1109 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1113 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1114 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1117 /* Outside any interesting column? */
1118 if (x
< left_x
|| x
> right_x
)
1119 return ON_SCROLL_BAR
;
1121 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1122 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1124 text_left
= window_box_left (w
, TEXT_AREA
);
1125 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1127 if (FRAME_WINDOW_P (f
))
1129 if (!w
->pseudo_window_p
1130 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1131 && !WINDOW_RIGHTMOST_P (w
)
1132 && (eabs (x
- right_x
) < grabbable_width
))
1133 return ON_VERTICAL_BORDER
;
1135 /* Need to say "x > right_x" rather than >=, since on character
1136 terminals, the vertical line's x coordinate is right_x. */
1137 else if (!w
->pseudo_window_p
1138 && !WINDOW_RIGHTMOST_P (w
)
1139 && x
> right_x
- ux
)
1140 return ON_VERTICAL_BORDER
;
1144 if (lmargin_width
> 0
1145 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1146 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1147 : (x
< left_x
+ lmargin_width
)))
1148 return ON_LEFT_MARGIN
;
1150 return ON_LEFT_FRINGE
;
1153 if (x
>= text_right
)
1155 if (rmargin_width
> 0
1156 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1157 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1158 : (x
>= right_x
- rmargin_width
)))
1159 return ON_RIGHT_MARGIN
;
1161 return ON_RIGHT_FRINGE
;
1164 /* Everything special ruled out - must be on text area */
1168 /* Take X is the frame-relative pixel x-coordinate, and return the
1169 x-coordinate relative to part PART of window W. */
1171 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1173 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1178 return x
- window_box_left (w
, TEXT_AREA
);
1180 case ON_LEFT_FRINGE
:
1183 case ON_RIGHT_FRINGE
:
1184 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1186 case ON_LEFT_MARGIN
:
1188 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1189 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1191 case ON_RIGHT_MARGIN
:
1193 - ((w
->pseudo_window_p
)
1194 ? WINDOW_TOTAL_WIDTH (w
)
1195 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1196 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1197 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1198 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1201 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1206 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1207 Scoordinates_in_window_p
, 2, 2, 0,
1208 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1209 WINDOW must be a live window and defaults to the selected one.
1210 COORDINATES is a cons of the form (X . Y), X and Y being distances
1211 measured in characters from the upper-left corner of the frame.
1212 \(0 . 0) denotes the character in the upper left corner of the
1214 If COORDINATES are in the text portion of WINDOW,
1215 the coordinates relative to the window are returned.
1216 If they are in the mode line of WINDOW, `mode-line' is returned.
1217 If they are in the top mode line of WINDOW, `header-line' is returned.
1218 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1219 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1220 If they are on the border between WINDOW and its right sibling,
1221 `vertical-line' is returned.
1222 If they are in the windows's left or right marginal areas, `left-margin'\n\
1223 or `right-margin' is returned. */)
1224 (register Lisp_Object coordinates
, Lisp_Object window
)
1231 w
= decode_live_window (window
);
1232 f
= XFRAME (w
->frame
);
1233 CHECK_CONS (coordinates
);
1234 lx
= Fcar (coordinates
);
1235 ly
= Fcdr (coordinates
);
1236 CHECK_NUMBER_OR_FLOAT (lx
);
1237 CHECK_NUMBER_OR_FLOAT (ly
);
1238 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1239 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1241 switch (coordinates_in_window (w
, x
, y
))
1247 /* Convert X and Y to window relative pixel coordinates, and
1248 return the canonical char units. */
1249 x
-= window_box_left (w
, TEXT_AREA
);
1250 y
-= WINDOW_TOP_EDGE_Y (w
);
1251 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1252 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1257 case ON_VERTICAL_BORDER
:
1258 return Qvertical_line
;
1260 case ON_HEADER_LINE
:
1261 return Qheader_line
;
1263 case ON_LEFT_FRINGE
:
1264 return Qleft_fringe
;
1266 case ON_RIGHT_FRINGE
:
1267 return Qright_fringe
;
1269 case ON_LEFT_MARGIN
:
1270 return Qleft_margin
;
1272 case ON_RIGHT_MARGIN
:
1273 return Qright_margin
;
1276 /* Historically we are supposed to return nil in this case. */
1285 /* Callback for foreach_window, used in window_from_coordinates.
1286 Check if window W contains coordinates specified by USER_DATA which
1287 is actually a pointer to a struct check_window_data CW.
1289 Check if window W contains coordinates *CW->x and *CW->y. If it
1290 does, return W in *CW->window, as Lisp_Object, and return in
1291 *CW->part the part of the window under coordinates *X,*Y. Return
1292 zero from this function to stop iterating over windows. */
1294 struct check_window_data
1296 Lisp_Object
*window
;
1298 enum window_part
*part
;
1302 check_window_containing (struct window
*w
, void *user_data
)
1304 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1305 enum window_part found
;
1308 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1309 if (found
!= ON_NOTHING
)
1312 XSETWINDOW (*cw
->window
, w
);
1320 /* Find the window containing frame-relative pixel position X/Y and
1321 return it as a Lisp_Object.
1323 If X, Y is on one of the window's special `window_part' elements,
1324 set *PART to the id of that element.
1326 If there is no window under X, Y return nil and leave *PART
1327 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1329 This function was previously implemented with a loop cycling over
1330 windows with Fnext_window, and starting with the frame's selected
1331 window. It turned out that this doesn't work with an
1332 implementation of next_window using Vwindow_list, because
1333 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1334 tree of F when this function is called asynchronously from
1335 note_mouse_highlight. The original loop didn't terminate in this
1339 window_from_coordinates (struct frame
*f
, int x
, int y
,
1340 enum window_part
*part
, int tool_bar_p
)
1343 struct check_window_data cw
;
1344 enum window_part dummy
;
1350 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1351 foreach_window (f
, check_window_containing
, &cw
);
1353 /* If not found above, see if it's in the tool bar window, if a tool
1357 && WINDOWP (f
->tool_bar_window
)
1358 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1359 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1363 window
= f
->tool_bar_window
;
1369 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1370 doc
: /* Return window containing coordinates X and Y on FRAME.
1371 FRAME must be a live frame and defaults to the selected one.
1372 The top left corner of the frame is considered to be row 0,
1374 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1376 struct frame
*f
= decode_live_frame (frame
);
1378 /* Check that arguments are integers or floats. */
1379 CHECK_NUMBER_OR_FLOAT (x
);
1380 CHECK_NUMBER_OR_FLOAT (y
);
1382 return window_from_coordinates (f
,
1383 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1384 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1385 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1386 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1390 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1391 doc
: /* Return current value of point in WINDOW.
1392 WINDOW must be a live window and defaults to the selected one.
1394 For a nonselected window, this is the value point would have if that
1395 window were selected.
1397 Note that, when WINDOW is selected, the value returned is the same as
1398 that returned by `point' for WINDOW's buffer. It would be more strictly
1399 correct to return the `top-level' value of `point', outside of any
1400 `save-excursion' forms. But that is hard to define. */)
1401 (Lisp_Object window
)
1403 register struct window
*w
= decode_live_window (window
);
1405 if (w
== XWINDOW (selected_window
))
1406 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1408 return Fmarker_position (w
->pointm
);
1411 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1412 doc
: /* Return position at which display currently starts in WINDOW.
1413 WINDOW must be a live window and defaults to the selected one.
1414 This is updated by redisplay or by calling `set-window-start'. */)
1415 (Lisp_Object window
)
1417 return Fmarker_position (decode_live_window (window
)->start
);
1420 /* This is text temporarily removed from the doc string below.
1422 This function returns nil if the position is not currently known.
1423 That happens when redisplay is preempted and doesn't finish.
1424 If in that case you want to compute where the end of the window would
1425 have been if redisplay had finished, do this:
1427 (goto-char (window-start window))
1428 (vertical-motion (1- (window-height window)) window)
1431 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1432 doc
: /* Return position at which display currently ends in WINDOW.
1433 WINDOW must be a live window and defaults to the selected one.
1434 This is updated by redisplay, when it runs to completion.
1435 Simply changing the buffer text or setting `window-start'
1436 does not update this value.
1437 Return nil if there is no recorded value. (This can happen if the
1438 last redisplay of WINDOW was preempted, and did not finish.)
1439 If UPDATE is non-nil, compute the up-to-date position
1440 if it isn't already recorded. */)
1441 (Lisp_Object window
, Lisp_Object update
)
1444 struct window
*w
= decode_live_window (window
);
1452 #if 0 /* This change broke some things. We should make it later. */
1453 /* If we don't know the end position, return nil.
1454 The user can compute it with vertical-motion if he wants to.
1455 It would be nicer to do it automatically,
1456 but that's so slow that it would probably bother people. */
1457 if (NILP (w
->window_end_valid
))
1462 && (windows_or_buffers_changed
|| NILP (w
->window_end_valid
))
1465 struct text_pos startp
;
1467 struct buffer
*old_buffer
= NULL
;
1468 void *itdata
= NULL
;
1470 /* Cannot use Fvertical_motion because that function doesn't
1471 cope with variable-height lines. */
1472 if (b
!= current_buffer
)
1474 old_buffer
= current_buffer
;
1475 set_buffer_internal (b
);
1478 /* In case W->start is out of the range, use something
1479 reasonable. This situation occurred when loading a file with
1480 `-l' containing a call to `rmail' with subsequent other
1481 commands. At the end, W->start happened to be BEG, while
1482 rmail had already narrowed the buffer. */
1483 if (XMARKER (w
->start
)->charpos
< BEGV
)
1484 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1485 else if (XMARKER (w
->start
)->charpos
> ZV
)
1486 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1488 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1490 itdata
= bidi_shelve_cache ();
1491 start_display (&it
, w
, startp
);
1492 move_it_vertically (&it
, window_box_height (w
));
1493 if (it
.current_y
< it
.last_visible_y
)
1494 move_it_past_eol (&it
);
1495 value
= make_number (IT_CHARPOS (it
));
1496 bidi_unshelve_cache (itdata
, 0);
1499 set_buffer_internal (old_buffer
);
1502 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1507 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1508 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1509 WINDOW must be a live window and defaults to the selected one.
1511 (Lisp_Object window
, Lisp_Object pos
)
1513 register struct window
*w
= decode_live_window (window
);
1515 CHECK_NUMBER_COERCE_MARKER (pos
);
1517 if (w
== XWINDOW (selected_window
))
1519 if (XBUFFER (w
->buffer
) == current_buffer
)
1523 struct buffer
*old_buffer
= current_buffer
;
1525 set_buffer_internal (XBUFFER (w
->buffer
));
1527 set_buffer_internal (old_buffer
);
1532 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1533 /* We have to make sure that redisplay updates the window to show
1534 the new value of point. */
1535 ++windows_or_buffers_changed
;
1541 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1542 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1543 WINDOW must be a live window and defaults to the selected one. Return
1544 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1545 overriding motion of point in order to display at this exact start. */)
1546 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1548 register struct window
*w
= decode_live_window (window
);
1550 CHECK_NUMBER_COERCE_MARKER (pos
);
1551 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1552 /* this is not right, but much easier than doing what is right. */
1553 w
->start_at_line_beg
= 0;
1556 w
->update_mode_line
= 1;
1557 w
->last_modified
= 0;
1558 w
->last_overlay_modified
= 0;
1559 if (!EQ (window
, selected_window
))
1560 windows_or_buffers_changed
++;
1565 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1566 Spos_visible_in_window_p
, 0, 3, 0,
1567 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1568 WINDOW must be a live window and defaults to the selected one.
1570 Return nil if that position is scrolled vertically out of view. If a
1571 character is only partially visible, nil is returned, unless the
1572 optional argument PARTIALLY is non-nil. If POS is only out of view
1573 because of horizontal scrolling, return non-nil. If POS is t, it
1574 specifies the position of the last visible glyph in WINDOW. POS
1575 defaults to point in WINDOW; WINDOW defaults to the selected window.
1577 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1578 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1579 where X and Y are the pixel coordinates relative to the top left corner
1580 of the window. The remaining elements are omitted if the character after
1581 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1582 off-window at the top and bottom of the row, ROWH is the height of the
1583 display row, and VPOS is the row number (0-based) containing POS. */)
1584 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1586 register struct window
*w
;
1587 register EMACS_INT posint
;
1588 register struct buffer
*buf
;
1589 struct text_pos top
;
1590 Lisp_Object in_window
= Qnil
;
1591 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1594 w
= decode_live_window (window
);
1595 buf
= XBUFFER (w
->buffer
);
1596 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1600 else if (!NILP (pos
))
1602 CHECK_NUMBER_COERCE_MARKER (pos
);
1603 posint
= XINT (pos
);
1605 else if (w
== XWINDOW (selected_window
))
1608 posint
= XMARKER (w
->pointm
)->charpos
;
1610 /* If position is above window start or outside buffer boundaries,
1611 or if window start is out of range, position is not visible. */
1613 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1614 && CHARPOS (top
) >= BUF_BEGV (buf
)
1615 && CHARPOS (top
) <= BUF_ZV (buf
)
1616 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1617 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1620 if (!NILP (in_window
) && !NILP (partially
))
1622 Lisp_Object part
= Qnil
;
1624 part
= list4i (rtop
, rbot
, rowh
, vpos
);
1625 in_window
= Fcons (make_number (x
),
1626 Fcons (make_number (y
), part
));
1632 DEFUN ("window-line-height", Fwindow_line_height
,
1633 Swindow_line_height
, 0, 2, 0,
1634 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1635 WINDOW must be a live window and defaults to the selected one.
1637 Return height of current line if LINE is omitted or nil. Return height of
1638 header or mode line if LINE is `header-line' or `mode-line'.
1639 Otherwise, LINE is a text line number starting from 0. A negative number
1640 counts from the end of the window.
1642 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1643 in pixels of the visible part of the line, VPOS and YPOS are the
1644 vertical position in lines and pixels of the line, relative to the top
1645 of the first text line, and OFFBOT is the number of off-window pixels at
1646 the bottom of the text line. If there are off-window pixels at the top
1647 of the (first) text line, YPOS is negative.
1649 Return nil if window display is not up-to-date. In that case, use
1650 `pos-visible-in-window-p' to obtain the information. */)
1651 (Lisp_Object line
, Lisp_Object window
)
1653 register struct window
*w
;
1654 register struct buffer
*b
;
1655 struct glyph_row
*row
, *end_row
;
1659 w
= decode_live_window (window
);
1661 if (noninteractive
|| w
->pseudo_window_p
)
1664 CHECK_BUFFER (w
->buffer
);
1665 b
= XBUFFER (w
->buffer
);
1667 /* Fail if current matrix is not up-to-date. */
1668 if (NILP (w
->window_end_valid
)
1669 || current_buffer
->clip_changed
1670 || current_buffer
->prevent_redisplay_optimizations_p
1671 || w
->last_modified
< BUF_MODIFF (b
)
1672 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1678 if (i
< 0 || i
>= w
->current_matrix
->nrows
1679 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1681 max_y
= window_text_bottom_y (w
);
1685 if (EQ (line
, Qheader_line
))
1687 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1689 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1690 return row
->enabled_p
? list4i (row
->height
, 0, 0, 0) : Qnil
;
1693 if (EQ (line
, Qmode_line
))
1695 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1696 return (row
->enabled_p
?
1697 list4i (row
->height
,
1698 0, /* not accurate */
1699 (WINDOW_HEADER_LINE_HEIGHT (w
)
1700 + window_text_bottom_y (w
)),
1705 CHECK_NUMBER (line
);
1708 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1709 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1710 max_y
= window_text_bottom_y (w
);
1713 while ((n
< 0 || i
< n
)
1714 && row
<= end_row
&& row
->enabled_p
1715 && row
->y
+ row
->height
< max_y
)
1718 if (row
> end_row
|| !row
->enabled_p
)
1730 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1731 return list4i (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1734 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1736 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1737 More precisely, return the value assigned by the last call of
1738 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1739 never called with WINDOW as its argument, or the value set by that
1740 function was internally reset since its last call. WINDOW must be a
1741 live window and defaults to the selected one.
1743 When a window is dedicated to its buffer, `display-buffer' will refrain
1744 from displaying another buffer in it. `get-lru-window' and
1745 `get-largest-window' treat dedicated windows specially.
1746 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1747 `kill-buffer' can delete a dedicated window and the containing frame.
1749 Functions like `set-window-buffer' may change the buffer displayed by a
1750 window, unless that window is "strongly" dedicated to its buffer, that
1751 is the value returned by `window-dedicated-p' is t. */)
1752 (Lisp_Object window
)
1754 return decode_live_window (window
)->dedicated
;
1757 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1758 Sset_window_dedicated_p
, 2, 2, 0,
1759 doc
: /* Mark WINDOW as dedicated according to FLAG.
1760 WINDOW must be a live window and defaults to the selected one. FLAG
1761 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1762 mark WINDOW as non-dedicated. Return FLAG.
1764 When a window is dedicated to its buffer, `display-buffer' will refrain
1765 from displaying another buffer in it. `get-lru-window' and
1766 `get-largest-window' treat dedicated windows specially.
1767 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1768 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1769 and the containing frame.
1771 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1772 its buffer. Functions like `set-window-buffer' may change the buffer
1773 displayed by a window, unless that window is strongly dedicated to its
1774 buffer. If and when `set-window-buffer' displays another buffer in a
1775 window, it also makes sure that the window is no more dedicated. */)
1776 (Lisp_Object window
, Lisp_Object flag
)
1778 wset_dedicated (decode_live_window (window
), flag
);
1782 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1784 doc
: /* Return buffers previously shown in WINDOW.
1785 WINDOW must be a live window and defaults to the selected one.
1787 The return value is a list of elements (BUFFER WINDOW-START POS),
1788 where BUFFER is a buffer, WINDOW-START is the start position of the
1789 window for that buffer, and POS is a window-specific point value. */)
1790 (Lisp_Object window
)
1792 return decode_live_window (window
)->prev_buffers
;
1795 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1796 Sset_window_prev_buffers
, 2, 2, 0,
1797 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1798 WINDOW must be a live window and defaults to the selected one.
1800 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1801 where BUFFER is a buffer, WINDOW-START is the start position of the
1802 window for that buffer, and POS is a window-specific point value. */)
1803 (Lisp_Object window
, Lisp_Object prev_buffers
)
1805 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1806 return prev_buffers
;
1809 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1811 doc
: /* Return list of buffers recently re-shown in WINDOW.
1812 WINDOW must be a live window and defaults to the selected one. */)
1813 (Lisp_Object window
)
1815 return decode_live_window (window
)->next_buffers
;
1818 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1819 Sset_window_next_buffers
, 2, 2, 0,
1820 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1821 WINDOW must be a live window and defaults to the selected one.
1822 NEXT-BUFFERS should be a list of buffers. */)
1823 (Lisp_Object window
, Lisp_Object next_buffers
)
1825 wset_next_buffers (decode_live_window (window
), next_buffers
);
1826 return next_buffers
;
1829 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1831 doc
: /* Return the parameters of WINDOW and their values.
1832 WINDOW must be a valid window and defaults to the selected one. The
1833 return value is a list of elements of the form (PARAMETER . VALUE). */)
1834 (Lisp_Object window
)
1836 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1839 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1841 doc
: /* Return WINDOW's value for PARAMETER.
1842 WINDOW can be any window and defaults to the selected one. */)
1843 (Lisp_Object window
, Lisp_Object parameter
)
1847 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1848 return CDR_SAFE (result
);
1851 DEFUN ("set-window-parameter", Fset_window_parameter
,
1852 Sset_window_parameter
, 3, 3, 0,
1853 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1854 WINDOW can be any window and defaults to the selected one.
1856 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1858 register struct window
*w
= decode_any_window (window
);
1859 Lisp_Object old_alist_elt
;
1861 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1862 if (NILP (old_alist_elt
))
1863 wset_window_parameters
1864 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1866 Fsetcdr (old_alist_elt
, value
);
1870 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1872 doc
: /* Return the display-table that WINDOW is using.
1873 WINDOW must be a live window and defaults to the selected one. */)
1874 (Lisp_Object window
)
1876 return decode_live_window (window
)->display_table
;
1879 /* Get the display table for use on window W. This is either W's
1880 display table or W's buffer's display table. Ignore the specified
1881 tables if they are not valid; if no valid table is specified,
1884 struct Lisp_Char_Table
*
1885 window_display_table (struct window
*w
)
1887 struct Lisp_Char_Table
*dp
= NULL
;
1889 if (DISP_TABLE_P (w
->display_table
))
1890 dp
= XCHAR_TABLE (w
->display_table
);
1891 else if (BUFFERP (w
->buffer
))
1893 struct buffer
*b
= XBUFFER (w
->buffer
);
1895 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1896 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1897 else if (DISP_TABLE_P (Vstandard_display_table
))
1898 dp
= XCHAR_TABLE (Vstandard_display_table
);
1904 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1905 doc
: /* Set WINDOW's display-table to TABLE.
1906 WINDOW must be a live window and defaults to the selected one. */)
1907 (register Lisp_Object window
, Lisp_Object table
)
1909 wset_display_table (decode_live_window (window
), table
);
1913 /* Record info on buffer window W is displaying
1914 when it is about to cease to display that buffer. */
1916 unshow_buffer (register struct window
*w
)
1923 if (b
!= XMARKER (w
->pointm
)->buffer
)
1927 if (w
== XWINDOW (selected_window
)
1928 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1929 /* Do this except when the selected window's buffer
1930 is being removed from some other window. */
1932 /* last_window_start records the start position that this buffer
1933 had in the last window to be disconnected from it.
1934 Now that this statement is unconditional,
1935 it is possible for the buffer to be displayed in the
1936 selected window, while last_window_start reflects another
1937 window which was recently showing the same buffer.
1938 Some people might say that might be a good thing. Let's see. */
1939 b
->last_window_start
= marker_position (w
->start
);
1941 /* Point in the selected window's buffer
1942 is actually stored in that buffer, and the window's pointm isn't used.
1943 So don't clobber point in that buffer. */
1944 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1945 /* Don't clobber point in current buffer either (this could be
1946 useful in connection with bug#12208).
1947 && XBUFFER (buf) != current_buffer */
1948 /* This line helps to fix Horsley's testbug.el bug. */
1949 && !(WINDOWP (BVAR (b
, last_selected_window
))
1950 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1951 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1952 temp_set_point_both (b
,
1953 clip_to_bounds (BUF_BEGV (b
),
1954 XMARKER (w
->pointm
)->charpos
,
1956 clip_to_bounds (BUF_BEGV_BYTE (b
),
1957 marker_byte_position (w
->pointm
),
1960 if (WINDOWP (BVAR (b
, last_selected_window
))
1961 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1962 bset_last_selected_window (b
, Qnil
);
1965 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1966 means change window structure only. Otherwise store geometry and
1967 other settings as well. */
1969 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1971 register Lisp_Object tem
;
1972 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1974 /* If OLD is its frame's root window, then NEW is the new
1975 root window for that frame. */
1976 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1977 fset_root_window (XFRAME (o
->frame
), new);
1981 wset_left_col (n
, o
->left_col
);
1982 wset_top_line (n
, o
->top_line
);
1983 wset_total_cols (n
, o
->total_cols
);
1984 wset_total_lines (n
, o
->total_lines
);
1985 wset_normal_cols (n
, o
->normal_cols
);
1986 wset_normal_cols (o
, make_float (1.0));
1987 wset_normal_lines (n
, o
->normal_lines
);
1988 wset_normal_lines (o
, make_float (1.0));
1989 n
->desired_matrix
= n
->current_matrix
= 0;
1991 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1992 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1993 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1994 n
->phys_cursor_type
= -1;
1995 n
->phys_cursor_width
= -1;
1996 n
->must_be_updated_p
= 0;
1997 n
->pseudo_window_p
= 0;
1998 wset_window_end_vpos (n
, make_number (0));
1999 wset_window_end_pos (n
, make_number (0));
2000 wset_window_end_valid (n
, Qnil
);
2001 n
->frozen_window_start_p
= 0;
2007 wset_prev (XWINDOW (tem
), new);
2012 wset_next (XWINDOW (tem
), new);
2015 wset_parent (n
, tem
);
2018 if (EQ (XWINDOW (tem
)->vchild
, old
))
2019 wset_vchild (XWINDOW (tem
), new);
2020 if (EQ (XWINDOW (tem
)->hchild
, old
))
2021 wset_hchild (XWINDOW (tem
), new);
2025 /* If window WINDOW and its parent window are iso-combined, merge
2026 WINDOW's children into those of its parent window and mark WINDOW as
2030 recombine_windows (Lisp_Object window
)
2032 struct window
*w
, *p
, *c
;
2033 Lisp_Object parent
, child
;
2036 w
= XWINDOW (window
);
2038 if (!NILP (parent
) && NILP (w
->combination_limit
))
2040 p
= XWINDOW (parent
);
2041 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2042 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2043 /* WINDOW and PARENT are both either a vertical or a horizontal
2046 horflag
= NILP (w
->vchild
);
2047 child
= horflag
? w
->hchild
: w
->vchild
;
2048 c
= XWINDOW (child
);
2050 /* Splice WINDOW's children into its parent's children and
2051 assign new normal sizes. */
2054 wset_hchild (p
, child
);
2056 wset_vchild (p
, child
);
2059 wset_prev (c
, w
->prev
);
2060 wset_next (XWINDOW (w
->prev
), child
);
2065 wset_parent (c
, parent
);
2068 wset_normal_cols (c
,
2069 make_float (XFLOATINT (c
->total_cols
)
2070 / XFLOATINT (p
->total_cols
)));
2072 wset_normal_lines (c
,
2073 make_float (XFLOATINT (c
->total_lines
)
2074 / XFLOATINT (p
->total_lines
)));
2078 if (!NILP (w
->next
))
2080 wset_next (c
, w
->next
);
2081 wset_prev (XWINDOW (c
->next
), child
);
2089 c
= XWINDOW (child
);
2093 /* WINDOW can be deleted now. */
2094 wset_vchild (w
, Qnil
);
2095 wset_hchild (w
, Qnil
);
2100 /* If WINDOW can be deleted, delete it. */
2102 delete_deletable_window (Lisp_Object window
)
2104 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2105 call1 (Qdelete_window
, window
);
2108 /***********************************************************************
2110 ***********************************************************************/
2112 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2113 pointer. This is a callback function for foreach_window, used in
2114 the window_list function. */
2117 add_window_to_list (struct window
*w
, void *user_data
)
2119 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2121 XSETWINDOW (window
, w
);
2122 *list
= Fcons (window
, *list
);
2127 /* Return a list of all windows, for use by next_window. If
2128 Vwindow_list is a list, return that list. Otherwise, build a new
2129 list, cache it in Vwindow_list, and return that. */
2134 if (!CONSP (Vwindow_list
))
2136 Lisp_Object tail
, frame
;
2138 Vwindow_list
= Qnil
;
2139 FOR_EACH_FRAME (tail
, frame
)
2141 Lisp_Object args
[2];
2143 /* We are visiting windows in canonical order, and add
2144 new windows at the front of args[1], which means we
2145 have to reverse this list at the end. */
2147 foreach_window (XFRAME (frame
), add_window_to_list
, &args
[1]);
2148 args
[0] = Vwindow_list
;
2149 args
[1] = Fnreverse (args
[1]);
2150 Vwindow_list
= Fnconc (2, args
);
2154 return Vwindow_list
;
2158 /* Value is non-zero if WINDOW satisfies the constraints given by
2159 OWINDOW, MINIBUF and ALL_FRAMES.
2161 MINIBUF t means WINDOW may be minibuffer windows.
2162 `lambda' means WINDOW may not be a minibuffer window.
2163 a window means a specific minibuffer window
2165 ALL_FRAMES t means search all frames,
2166 nil means search just current frame,
2167 `visible' means search just visible frames on the
2169 0 means search visible and iconified frames on the
2171 a window means search the frame that window belongs to,
2172 a frame means consider windows on that frame, only. */
2175 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2177 struct window
*w
= XWINDOW (window
);
2178 struct frame
*f
= XFRAME (w
->frame
);
2179 int candidate_p
= 1;
2181 if (!BUFFERP (w
->buffer
))
2183 else if (MINI_WINDOW_P (w
)
2184 && (EQ (minibuf
, Qlambda
)
2185 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2187 /* If MINIBUF is `lambda' don't consider any mini-windows.
2188 If it is a window, consider only that one. */
2191 else if (EQ (all_frames
, Qt
))
2193 else if (NILP (all_frames
))
2195 eassert (WINDOWP (owindow
));
2196 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2198 else if (EQ (all_frames
, Qvisible
))
2200 FRAME_SAMPLE_VISIBILITY (f
);
2201 candidate_p
= FRAME_VISIBLE_P (f
)
2202 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2203 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2206 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2208 FRAME_SAMPLE_VISIBILITY (f
);
2209 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2210 #ifdef HAVE_X_WINDOWS
2211 /* Yuck!! If we've just created the frame and the
2212 window-manager requested the user to place it
2213 manually, the window may still not be considered
2214 `visible'. I'd argue it should be at least
2215 something like `iconified', but don't know how to do
2217 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2218 && !f
->output_data
.x
->has_been_visible
)
2221 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2222 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2224 else if (WINDOWP (all_frames
))
2225 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2226 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2227 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2228 else if (FRAMEP (all_frames
))
2229 candidate_p
= EQ (all_frames
, w
->frame
);
2235 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2236 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2237 MINIBUF, and ALL_FRAMES. */
2240 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2242 struct window
*w
= decode_live_window (*window
);
2244 XSETWINDOW (*window
, w
);
2245 /* MINIBUF nil may or may not include minibuffers. Decide if it
2247 if (NILP (*minibuf
))
2248 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2249 else if (!EQ (*minibuf
, Qt
))
2252 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2253 => count none of them, or a specific minibuffer window (the
2254 active one) to count. */
2256 /* ALL_FRAMES nil doesn't specify which frames to include. */
2257 if (NILP (*all_frames
))
2259 = (!EQ (*minibuf
, Qlambda
)
2260 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2262 else if (EQ (*all_frames
, Qvisible
))
2264 else if (EQ (*all_frames
, make_number (0)))
2266 else if (FRAMEP (*all_frames
))
2268 else if (!EQ (*all_frames
, Qt
))
2273 /* Return the next or previous window of WINDOW in cyclic ordering
2274 of windows. NEXT_P non-zero means return the next window. See the
2275 documentation string of next-window for the meaning of MINIBUF and
2279 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2281 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2283 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2284 return the first window on the frame. */
2285 if (FRAMEP (all_frames
)
2286 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2287 return Fframe_first_window (all_frames
);
2293 /* Find WINDOW in the list of all windows. */
2294 list
= Fmemq (window
, window_list ());
2296 /* Scan forward from WINDOW to the end of the window list. */
2298 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2299 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2302 /* Scan from the start of the window list up to WINDOW. */
2304 for (list
= Vwindow_list
;
2305 CONSP (list
) && !EQ (XCAR (list
), window
);
2307 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2311 window
= XCAR (list
);
2315 Lisp_Object candidate
, list
;
2317 /* Scan through the list of windows for candidates. If there are
2318 candidate windows in front of WINDOW, the last one of these
2319 is the one we want. If there are candidates following WINDOW
2320 in the list, again the last one of these is the one we want. */
2322 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2324 if (EQ (XCAR (list
), window
))
2326 if (WINDOWP (candidate
))
2329 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2331 candidate
= XCAR (list
);
2334 if (WINDOWP (candidate
))
2342 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2343 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2344 WINDOW must be a live window and defaults to the selected one. The
2345 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2348 MINIBUF nil or omitted means consider the minibuffer window only if the
2349 minibuffer is active. MINIBUF t means consider the minibuffer window
2350 even if the minibuffer is not active. Any other value means do not
2351 consider the minibuffer window even if the minibuffer is active.
2353 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2354 plus the minibuffer window if specified by the MINIBUF argument. If the
2355 minibuffer counts, consider all windows on all frames that share that
2356 minibuffer too. The following non-nil values of ALL-FRAMES have special
2359 - t means consider all windows on all existing frames.
2361 - `visible' means consider all windows on all visible frames.
2363 - 0 (the number zero) means consider all windows on all visible and
2366 - A frame means consider all windows on that frame only.
2368 Anything else means consider all windows on WINDOW's frame and no
2371 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2372 `next-window' to iterate through the entire cycle of acceptable
2373 windows, eventually ending up back at the window you started with.
2374 `previous-window' traverses the same cycle, in the reverse order. */)
2375 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2377 return next_window (window
, minibuf
, all_frames
, 1);
2381 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2382 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2383 WINDOW must be a live window and defaults to the selected one. The
2384 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2387 MINIBUF nil or omitted means consider the minibuffer window only if the
2388 minibuffer is active. MINIBUF t means consider the minibuffer window
2389 even if the minibuffer is not active. Any other value means do not
2390 consider the minibuffer window even if the minibuffer is active.
2392 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2393 plus the minibuffer window if specified by the MINIBUF argument. If the
2394 minibuffer counts, consider all windows on all frames that share that
2395 minibuffer too. The following non-nil values of ALL-FRAMES have special
2398 - t means consider all windows on all existing frames.
2400 - `visible' means consider all windows on all visible frames.
2402 - 0 (the number zero) means consider all windows on all visible and
2405 - A frame means consider all windows on that frame only.
2407 Anything else means consider all windows on WINDOW's frame and no
2410 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2411 use `previous-window' to iterate through the entire cycle of
2412 acceptable windows, eventually ending up back at the window you
2413 started with. `next-window' traverses the same cycle, in the
2415 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2417 return next_window (window
, minibuf
, all_frames
, 0);
2421 /* Return a list of windows in cyclic ordering. Arguments are like
2422 for `next-window'. */
2425 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2427 Lisp_Object tail
, list
, rest
;
2429 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2432 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2433 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2434 list
= Fcons (XCAR (tail
), list
);
2436 /* Rotate the list to start with WINDOW. */
2437 list
= Fnreverse (list
);
2438 rest
= Fmemq (window
, list
);
2439 if (!NILP (rest
) && !EQ (rest
, list
))
2441 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2443 XSETCDR (tail
, Qnil
);
2444 list
= nconc2 (rest
, list
);
2450 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2451 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2452 FRAME nil or omitted means use the selected frame.
2453 WINDOW nil or omitted means use the window selected within FRAME.
2454 MINIBUF t means include the minibuffer window, even if it isn't active.
2455 MINIBUF nil or omitted means include the minibuffer window only
2457 MINIBUF neither nil nor t means never include the minibuffer window. */)
2458 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2461 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2462 CHECK_WINDOW (window
);
2464 frame
= selected_frame
;
2466 if (!EQ (frame
, XWINDOW (window
)->frame
))
2467 error ("Window is on a different frame");
2469 return window_list_1 (window
, minibuf
, frame
);
2473 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2474 doc
: /* Return a list of all live windows.
2475 WINDOW specifies the first window to list and defaults to the selected
2478 Optional argument MINIBUF nil or omitted means consider the minibuffer
2479 window only if the minibuffer is active. MINIBUF t means consider the
2480 minibuffer window even if the minibuffer is not active. Any other value
2481 means do not consider the minibuffer window even if the minibuffer is
2484 Optional argument ALL-FRAMES nil or omitted means consider all windows
2485 on WINDOW's frame, plus the minibuffer window if specified by the
2486 MINIBUF argument. If the minibuffer counts, consider all windows on all
2487 frames that share that minibuffer too. The following non-nil values of
2488 ALL-FRAMES have special meanings:
2490 - t means consider all windows on all existing frames.
2492 - `visible' means consider all windows on all visible frames.
2494 - 0 (the number zero) means consider all windows on all visible and
2497 - A frame means consider all windows on that frame only.
2499 Anything else means consider all windows on WINDOW's frame and no
2502 If WINDOW is not on the list of windows returned, some other window will
2503 be listed first but no error is signaled. */)
2504 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2506 return window_list_1 (window
, minibuf
, all_frames
);
2509 /* Look at all windows, performing an operation specified by TYPE
2511 If FRAMES is Qt, look at all frames;
2512 Qnil, look at just the selected frame;
2513 Qvisible, look at visible frames;
2514 a frame, just look at windows on that frame.
2515 If MINI is non-zero, perform the operation on minibuffer windows too. */
2520 GET_BUFFER_WINDOW
, /* Arg is buffer */
2521 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2522 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2527 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2529 Lisp_Object window
, windows
, best_window
, frame_arg
;
2530 int frame_best_window_flag
= 0;
2532 struct gcpro gcpro1
;
2534 /* If we're only looping through windows on a particular frame,
2535 frame points to that frame. If we're looping through windows
2536 on all frames, frame is 0. */
2537 if (FRAMEP (frames
))
2538 f
= XFRAME (frames
);
2539 else if (NILP (frames
))
2540 f
= SELECTED_FRAME ();
2545 frame_arg
= Qlambda
;
2546 else if (EQ (frames
, make_number (0)))
2548 else if (EQ (frames
, Qvisible
))
2553 /* frame_arg is Qlambda to stick to one frame,
2554 Qvisible to consider all visible frames,
2557 /* Pick a window to start with. */
2561 window
= FRAME_SELECTED_WINDOW (f
);
2563 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2565 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2569 for (; CONSP (windows
); windows
= XCDR (windows
))
2573 window
= XCAR (windows
);
2574 w
= XWINDOW (window
);
2576 /* Note that we do not pay attention here to whether the frame
2577 is visible, since Fwindow_list skips non-visible frames if
2578 that is desired, under the control of frame_arg. */
2579 if (!MINI_WINDOW_P (w
)
2580 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2581 consider all windows. */
2582 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2583 || (mini
&& minibuf_level
> 0))
2586 case GET_BUFFER_WINDOW
:
2587 if (EQ (w
->buffer
, obj
)
2588 /* Don't find any minibuffer window except the one that
2589 is currently in use. */
2590 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2592 if (EQ (window
, selected_window
))
2593 /* Preferably return the selected window. */
2594 RETURN_UNGCPRO (window
);
2595 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2596 && !frame_best_window_flag
)
2597 /* Prefer windows on the current frame (but don't
2598 choose another one if we have one already). */
2600 best_window
= window
;
2601 frame_best_window_flag
= 1;
2603 else if (NILP (best_window
))
2604 best_window
= window
;
2608 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2609 /* We could simply check whether the buffer shown by window
2610 is live, and show another buffer in case it isn't. */
2611 if (EQ (w
->buffer
, obj
))
2613 /* Undedicate WINDOW. */
2614 wset_dedicated (w
, Qnil
);
2615 /* Make WINDOW show the buffer returned by
2616 other_buffer_safely, don't run any hooks. */
2618 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2619 /* If WINDOW is the selected window, make its buffer
2620 current. But do so only if the window shows the
2621 current buffer (Bug#6454). */
2622 if (EQ (window
, selected_window
)
2623 && XBUFFER (w
->buffer
) == current_buffer
)
2624 Fset_buffer (w
->buffer
);
2628 case REDISPLAY_BUFFER_WINDOWS
:
2629 if (EQ (w
->buffer
, obj
))
2631 mark_window_display_accurate (window
, 0);
2632 w
->update_mode_line
= 1;
2633 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2634 ++update_mode_lines
;
2635 best_window
= window
;
2639 /* Check for a window that has a killed buffer. */
2640 case CHECK_ALL_WINDOWS
:
2641 if (! NILP (w
->buffer
)
2642 && !BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
2646 case WINDOW_LOOP_UNUSED
:
2655 /* Used for debugging. Abort if any window has a dead buffer. */
2657 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2659 check_all_windows (void)
2661 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2664 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2665 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2666 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2669 The optional argument ALL-FRAMES specifies the frames to consider:
2671 - t means consider all windows on all existing frames.
2673 - `visible' means consider all windows on all visible frames.
2675 - 0 (the number zero) means consider all windows on all visible
2676 and iconified frames.
2678 - A frame means consider all windows on that frame only.
2680 Any other value of ALL-FRAMES means consider all windows on the
2681 selected frame and no others. */)
2682 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2686 if (NILP (buffer_or_name
))
2687 buffer
= Fcurrent_buffer ();
2689 buffer
= Fget_buffer (buffer_or_name
);
2691 if (BUFFERP (buffer
))
2692 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2698 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2700 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2704 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2705 Sdelete_other_windows_internal
, 0, 2, "",
2706 doc
: /* Make WINDOW fill its frame.
2707 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2708 and defaults to the selected one.
2710 Optional argument ROOT, if non-nil, must specify an internal window such
2711 that WINDOW is in its window subtree. If this is the case, replace ROOT
2712 by WINDOW and leave alone any windows not part of ROOT's subtree.
2714 When WINDOW is live try to reduce display jumps by keeping the text
2715 previously visible in WINDOW in the same place on the frame. Doing this
2716 depends on the value of (window-start WINDOW), so if calling this
2717 function in a program gives strange scrolling, make sure the
2718 window-start value is reasonable when this function is called. */)
2719 (Lisp_Object window
, Lisp_Object root
)
2721 struct window
*w
, *r
, *s
;
2723 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2724 ptrdiff_t startpos
IF_LINT (= 0);
2725 int top
IF_LINT (= 0), new_top
, resize_failed
;
2727 w
= decode_valid_window (window
);
2728 XSETWINDOW (window
, w
);
2729 f
= XFRAME (w
->frame
);
2732 /* ROOT is the frame's root window. */
2734 root
= FRAME_ROOT_WINDOW (f
);
2738 /* ROOT must be an ancestor of WINDOW. */
2740 r
= decode_valid_window (root
);
2741 pwindow
= XWINDOW (window
)->parent
;
2742 while (!NILP (pwindow
))
2743 if (EQ (pwindow
, root
))
2746 pwindow
= XWINDOW (pwindow
)->parent
;
2747 if (!EQ (pwindow
, root
))
2748 error ("Specified root is not an ancestor of specified window");
2751 if (EQ (window
, root
))
2754 /* I don't understand the "top > 0" part below. If we deal with a
2755 standalone minibuffer it would have been caught by the preceding
2757 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2758 error ("Can't expand minibuffer to full frame");
2760 if (!NILP (w
->buffer
))
2762 startpos
= marker_position (w
->start
);
2763 top
= WINDOW_TOP_EDGE_LINE (w
)
2764 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2765 /* Make sure WINDOW is the frame's selected window. */
2766 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2768 if (EQ (selected_frame
, w
->frame
))
2769 Fselect_window (window
, Qnil
);
2771 fset_selected_window (f
, window
);
2776 /* See if the frame's selected window is a part of the window
2777 subtree rooted at WINDOW, by finding all the selected window's
2778 parents and comparing each one with WINDOW. If it isn't we
2779 need a new selected window for this frame. */
2780 swindow
= FRAME_SELECTED_WINDOW (f
);
2784 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2785 pwindow
= XWINDOW (pwindow
)->parent
;
2787 if (EQ (window
, pwindow
))
2788 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2789 as the new selected window. */
2792 /* Else try the previous window of SWINDOW. */
2793 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2796 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2798 if (EQ (selected_frame
, w
->frame
))
2799 Fselect_window (swindow
, Qnil
);
2801 fset_selected_window (f
, swindow
);
2806 if (!FRAME_INITIAL_P (f
))
2808 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2810 /* We are going to free the glyph matrices of WINDOW, and with
2811 that we might lose any information about glyph rows that have
2812 some of their glyphs highlighted in mouse face. (These rows
2813 are marked with a non-zero mouse_face_p flag.) If WINDOW
2814 indeed has some glyphs highlighted in mouse face, signal to
2815 frame's up-to-date hook that mouse highlight was overwritten,
2816 so that it will arrange for redisplaying the highlight. */
2817 if (EQ (hlinfo
->mouse_face_window
, window
))
2819 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2820 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2821 hlinfo
->mouse_face_window
= Qnil
;
2824 free_window_matrices (r
);
2826 windows_or_buffers_changed
++;
2827 Vwindow_list
= Qnil
;
2828 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2831 if (NILP (w
->buffer
))
2833 /* Resize child windows vertically. */
2834 XSETINT (delta
, XINT (r
->total_lines
)
2835 - XINT (w
->total_lines
));
2836 wset_top_line (w
, r
->top_line
);
2837 resize_root_window (window
, delta
, Qnil
, Qnil
);
2838 if (window_resize_check (w
, 0))
2839 window_resize_apply (w
, 0);
2842 resize_root_window (window
, delta
, Qnil
, Qt
);
2843 if (window_resize_check (w
, 0))
2844 window_resize_apply (w
, 0);
2849 /* Resize child windows horizontally. */
2852 wset_left_col (w
, r
->left_col
);
2854 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2855 wset_left_col (w
, r
->left_col
);
2856 resize_root_window (window
, delta
, Qt
, Qnil
);
2857 if (window_resize_check (w
, 1))
2858 window_resize_apply (w
, 1);
2861 resize_root_window (window
, delta
, Qt
, Qt
);
2862 if (window_resize_check (w
, 1))
2863 window_resize_apply (w
, 1);
2870 /* Play safe, if we still can ... */
2873 w
= XWINDOW (window
);
2877 /* Cleanly unlink WINDOW from window-tree. */
2878 if (!NILP (w
->prev
))
2879 /* Get SIBLING above (on the left of) WINDOW. */
2882 s
= XWINDOW (sibling
);
2883 wset_next (s
, w
->next
);
2884 if (!NILP (s
->next
))
2885 wset_prev (XWINDOW (s
->next
), sibling
);
2888 /* Get SIBLING below (on the right of) WINDOW. */
2891 s
= XWINDOW (sibling
);
2892 wset_prev (s
, Qnil
);
2893 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2894 wset_vchild (XWINDOW (w
->parent
), sibling
);
2896 wset_hchild (XWINDOW (w
->parent
), sibling
);
2899 /* Delete ROOT and all child windows of ROOT. */
2900 if (!NILP (r
->vchild
))
2902 delete_all_child_windows (r
->vchild
);
2903 wset_vchild (r
, Qnil
);
2905 else if (!NILP (r
->hchild
))
2907 delete_all_child_windows (r
->hchild
);
2908 wset_hchild (r
, Qnil
);
2911 replace_window (root
, window
, 1);
2913 /* This must become SWINDOW anyway ....... */
2914 if (!NILP (w
->buffer
) && !resize_failed
)
2916 /* Try to minimize scrolling, by setting the window start to the
2917 point will cause the text at the old window start to be at the
2918 same place on the frame. But don't try to do this if the
2919 window start is outside the visible portion (as might happen
2920 when the display is not current, due to typeahead). */
2921 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2923 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2924 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2926 struct position pos
;
2927 struct buffer
*obuf
= current_buffer
;
2929 Fset_buffer (w
->buffer
);
2930 /* This computation used to temporarily move point, but that
2931 can have unwanted side effects due to text properties. */
2932 pos
= *vmotion (startpos
, -top
, w
);
2934 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2935 wset_window_end_valid (w
, Qnil
);
2936 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2937 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2938 /* We need to do this, so that the window-scroll-functions
2940 w
->optional_new_start
= 1;
2942 set_buffer_internal (obuf
);
2949 run_window_configuration_change_hook (f
);
2956 replace_buffer_in_windows (Lisp_Object buffer
)
2958 call1 (Qreplace_buffer_in_windows
, buffer
);
2962 /* Safely replace BUFFER with some other buffer in all windows of all
2963 frames, even those on other keyboards. */
2966 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2968 Lisp_Object tail
, frame
;
2970 /* A single call to window_loop won't do the job because it only
2971 considers frames on the current keyboard. So loop manually over
2972 frames, and handle each one. */
2973 FOR_EACH_FRAME (tail
, frame
)
2974 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2977 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2978 minimum allowable size. */
2981 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2983 /* For height, we have to see:
2984 how many windows the frame has at minimum (one or two),
2985 and whether it has a menu bar or other special stuff at the top. */
2987 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2988 ? MIN_SAFE_WINDOW_HEIGHT
2989 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2991 if (FRAME_TOP_MARGIN (frame
) > 0)
2992 min_height
+= FRAME_TOP_MARGIN (frame
);
2994 if (*rows
< min_height
)
2996 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2997 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3000 /* Adjust the margins of window W if text area is too small.
3001 Return 1 if window width is ok after adjustment; 0 if window
3002 is still too narrow. */
3005 adjust_window_margins (struct window
*w
)
3007 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3008 - WINDOW_FRINGE_COLS (w
)
3009 - WINDOW_SCROLL_BAR_COLS (w
));
3010 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3011 + WINDOW_RIGHT_MARGIN_COLS (w
));
3013 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3016 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3019 /* Window's text area is too narrow, but reducing the window
3020 margins will fix that. */
3021 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3022 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3024 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3026 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3027 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3030 wset_right_margin_cols (w
, make_number (margin_cols
));
3033 wset_left_margin_cols (w
, make_number (margin_cols
));
3037 /* The following three routines are needed for running a window's
3038 configuration change hook. */
3040 run_funs (Lisp_Object funs
)
3042 for (; CONSP (funs
); funs
= XCDR (funs
))
3043 if (!EQ (XCAR (funs
), Qt
))
3044 call0 (XCAR (funs
));
3048 select_window_norecord (Lisp_Object window
)
3050 return WINDOW_LIVE_P (window
)
3051 ? Fselect_window (window
, Qt
) : selected_window
;
3055 select_frame_norecord (Lisp_Object frame
)
3057 return FRAME_LIVE_P (XFRAME (frame
))
3058 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3062 run_window_configuration_change_hook (struct frame
*f
)
3064 ptrdiff_t count
= SPECPDL_INDEX ();
3065 Lisp_Object frame
, global_wcch
3066 = Fdefault_value (Qwindow_configuration_change_hook
);
3067 XSETFRAME (frame
, f
);
3069 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3072 /* Use the right buffer. Matters when running the local hooks. */
3073 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3075 record_unwind_current_buffer ();
3076 Fset_buffer (Fwindow_buffer (Qnil
));
3079 if (SELECTED_FRAME () != f
)
3081 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3082 select_frame_norecord (frame
);
3085 /* Look for buffer-local values. */
3087 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3088 for (; CONSP (windows
); windows
= XCDR (windows
))
3090 Lisp_Object window
= XCAR (windows
);
3091 Lisp_Object buffer
= Fwindow_buffer (window
);
3092 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3095 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3096 record_unwind_protect (select_window_norecord
, Fselected_window ());
3097 select_window_norecord (window
);
3098 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3100 unbind_to (inner_count
, Qnil
);
3105 run_funs (global_wcch
);
3106 unbind_to (count
, Qnil
);
3109 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3110 Srun_window_configuration_change_hook
, 0, 1, 0,
3111 doc
: /* Run `window-configuration-change-hook' for FRAME.
3112 If FRAME is omitted or nil, it defaults to the selected frame. */)
3115 run_window_configuration_change_hook (decode_live_frame (frame
));
3119 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3120 means it's allowed to run hooks. See make_frame for a case where
3121 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3122 margins, fringes, and scroll-bar settings of the window are not
3123 reset from the buffer's local settings. */
3126 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3128 struct window
*w
= XWINDOW (window
);
3129 struct buffer
*b
= XBUFFER (buffer
);
3130 ptrdiff_t count
= SPECPDL_INDEX ();
3131 int samebuf
= EQ (buffer
, w
->buffer
);
3133 wset_buffer (w
, buffer
);
3135 if (EQ (window
, selected_window
))
3136 bset_last_selected_window (b
, window
);
3138 /* Let redisplay errors through. */
3139 b
->display_error_modiff
= 0;
3141 /* Update time stamps of buffer display. */
3142 if (INTEGERP (BVAR (b
, display_count
)))
3143 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3144 bset_display_time (b
, Fcurrent_time ());
3146 wset_window_end_pos (w
, make_number (0));
3147 wset_window_end_vpos (w
, make_number (0));
3148 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3149 wset_window_end_valid (w
, Qnil
);
3150 if (!(keep_margins_p
&& samebuf
))
3151 { /* If we're not actually changing the buffer, don't reset hscroll and
3152 vscroll. This case happens for example when called from
3153 change_frame_size_1, where we use a dummy call to
3154 Fset_window_buffer on the frame's selected window (and no other)
3155 just in order to run window-configuration-change-hook.
3156 Resetting hscroll and vscroll here is problematic for things like
3157 image-mode and doc-view-mode since it resets the image's position
3158 whenever we resize the frame. */
3159 w
->hscroll
= w
->min_hscroll
= 0;
3161 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3162 set_marker_restricted (w
->start
,
3163 make_number (b
->last_window_start
),
3165 w
->start_at_line_beg
= 0;
3167 w
->last_modified
= 0;
3168 w
->last_overlay_modified
= 0;
3170 /* Maybe we could move this into the `if' but it's not obviously safe and
3171 I doubt it's worth the trouble. */
3172 windows_or_buffers_changed
++;
3174 /* We must select BUFFER for running the window-scroll-functions. */
3175 /* We can't check ! NILP (Vwindow_scroll_functions) here
3176 because that might itself be a local variable. */
3177 if (window_initialized
)
3179 record_unwind_current_buffer ();
3180 Fset_buffer (buffer
);
3183 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3185 if (!keep_margins_p
)
3187 /* Set left and right marginal area width etc. from buffer. */
3189 /* This may call adjust_window_margins three times, so
3190 temporarily disable window margins. */
3191 Lisp_Object save_left
= w
->left_margin_cols
;
3192 Lisp_Object save_right
= w
->right_margin_cols
;
3194 wset_left_margin_cols (w
, Qnil
);
3195 wset_right_margin_cols (w
, Qnil
);
3197 Fset_window_fringes (window
,
3198 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3199 BVAR (b
, fringes_outside_margins
));
3201 Fset_window_scroll_bars (window
,
3202 BVAR (b
, scroll_bar_width
),
3203 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3205 wset_left_margin_cols (w
, save_left
);
3206 wset_right_margin_cols (w
, save_right
);
3208 Fset_window_margins (window
,
3209 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3214 if (! NILP (Vwindow_scroll_functions
))
3215 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3216 Fmarker_position (w
->start
));
3217 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3220 unbind_to (count
, Qnil
);
3223 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3224 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3225 WINDOW must be a live window and defaults to the selected one.
3226 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3228 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3229 display margins, fringe widths, and scroll bar settings are preserved;
3230 the default is to reset these from the local settings for BUFFER-OR-NAME
3231 or the frame defaults. Return nil.
3233 This function throws an error when WINDOW is strongly dedicated to its
3234 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3235 already display BUFFER-OR-NAME.
3237 This function runs `window-scroll-functions' before running
3238 `window-configuration-change-hook'. */)
3239 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3241 register Lisp_Object tem
, buffer
;
3242 register struct window
*w
= decode_live_window (window
);
3244 XSETWINDOW (window
, w
);
3245 buffer
= Fget_buffer (buffer_or_name
);
3246 CHECK_BUFFER (buffer
);
3247 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3248 error ("Attempt to display deleted buffer");
3252 error ("Window is deleted");
3255 if (!EQ (tem
, buffer
))
3257 if (EQ (w
->dedicated
, Qt
))
3258 /* WINDOW is strongly dedicated to its buffer, signal an
3260 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3262 /* WINDOW is weakly dedicated to its buffer, reset
3264 wset_dedicated (w
, Qnil
);
3266 call1 (Qrecord_window_buffer
, window
);
3272 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3278 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3280 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3283 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3285 doc
: /* Force all windows to be updated on next redisplay.
3286 If optional arg OBJECT is a window, force redisplay of that window only.
3287 If OBJECT is a buffer or buffer name, force redisplay of all windows
3288 displaying that buffer. */)
3289 (Lisp_Object object
)
3293 windows_or_buffers_changed
++;
3294 update_mode_lines
++;
3298 if (WINDOWP (object
))
3300 struct window
*w
= XWINDOW (object
);
3301 mark_window_display_accurate (object
, 0);
3302 w
->update_mode_line
= 1;
3303 if (BUFFERP (w
->buffer
))
3304 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3305 ++update_mode_lines
;
3309 if (STRINGP (object
))
3310 object
= Fget_buffer (object
);
3311 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
3313 /* Walk all windows looking for buffer, and force update
3314 of each of those windows. */
3316 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3317 return NILP (object
) ? Qnil
: Qt
;
3320 /* If nothing suitable was found, just return.
3321 We could signal an error, but this feature will typically be used
3322 asynchronously in timers or process sentinels, so we don't. */
3326 /* Obsolete since 24.3. */
3328 temp_output_buffer_show (register Lisp_Object buf
)
3330 register struct buffer
*old
= current_buffer
;
3331 register Lisp_Object window
;
3332 register struct window
*w
;
3334 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3337 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3341 set_buffer_internal (old
);
3343 if (!NILP (Vtemp_buffer_show_function
))
3344 call1 (Vtemp_buffer_show_function
, buf
);
3347 window
= display_buffer (buf
, Qnil
, Qnil
);
3349 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3350 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3351 Vminibuf_scroll_window
= window
;
3352 w
= XWINDOW (window
);
3355 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3356 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3358 /* Run temp-buffer-show-hook, with the chosen window selected
3359 and its buffer current. */
3361 ptrdiff_t count
= SPECPDL_INDEX ();
3362 Lisp_Object prev_window
, prev_buffer
;
3363 prev_window
= selected_window
;
3364 XSETBUFFER (prev_buffer
, old
);
3366 /* Select the window that was chosen, for running the hook.
3367 Note: Both Fselect_window and select_window_norecord may
3368 set-buffer to the buffer displayed in the window,
3369 so we need to save the current buffer. --stef */
3370 record_unwind_protect (Fset_buffer
, prev_buffer
);
3371 record_unwind_protect (select_window_norecord
, prev_window
);
3372 Fselect_window (window
, Qt
);
3373 Fset_buffer (w
->buffer
);
3374 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3375 unbind_to (count
, Qnil
);
3380 /* Make new window, have it replace WINDOW in window-tree, and make
3381 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3382 horizontal child). */
3384 make_parent_window (Lisp_Object window
, int horflag
)
3387 register struct window
*o
, *p
;
3389 o
= XWINDOW (window
);
3390 p
= allocate_window ();
3391 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3392 (char *) o
+ sizeof (struct vectorlike_header
),
3393 word_size
* VECSIZE (struct window
));
3394 XSETWINDOW (parent
, p
);
3396 p
->sequence_number
= ++sequence_number
;
3398 replace_window (window
, parent
, 1);
3400 wset_next (o
, Qnil
);
3401 wset_prev (o
, Qnil
);
3402 wset_parent (o
, parent
);
3404 wset_hchild (p
, horflag
? window
: Qnil
);
3405 wset_vchild (p
, horflag
? Qnil
: window
);
3406 wset_start (p
, Qnil
);
3407 wset_pointm (p
, Qnil
);
3408 wset_buffer (p
, Qnil
);
3409 wset_combination_limit (p
, Qnil
);
3410 wset_window_parameters (p
, Qnil
);
3413 /* Make new window from scratch. */
3418 register struct window
*w
;
3420 w
= allocate_window ();
3421 /* Initialize Lisp data. Note that allocate_window initializes all
3422 Lisp data to nil, so do it only for slots which should not be nil. */
3423 wset_left_col (w
, make_number (0));
3424 wset_top_line (w
, make_number (0));
3425 wset_total_lines (w
, make_number (0));
3426 wset_total_cols (w
, make_number (0));
3427 wset_normal_lines (w
, make_float (1.0));
3428 wset_normal_cols (w
, make_float (1.0));
3429 wset_new_total (w
, make_number (0));
3430 wset_new_normal (w
, make_number (0));
3431 wset_start (w
, Fmake_marker ());
3432 wset_pointm (w
, Fmake_marker ());
3433 wset_vertical_scroll_bar_type (w
, Qt
);
3434 wset_window_end_pos (w
, make_number (0));
3435 wset_window_end_vpos (w
, make_number (0));
3436 /* These Lisp fields are marked specially so they're not set to nil by
3438 wset_prev_buffers (w
, Qnil
);
3439 wset_next_buffers (w
, Qnil
);
3441 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3442 non-Lisp data, so do it only for slots which should not be zero. */
3443 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3444 w
->phys_cursor_type
= -1;
3445 w
->phys_cursor_width
= -1;
3446 w
->sequence_number
= ++sequence_number
;
3448 /* Reset window_list. */
3449 Vwindow_list
= Qnil
;
3450 /* Return window. */
3451 XSETWINDOW (window
, w
);
3455 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3456 doc
: /* Set new total size of WINDOW to SIZE.
3457 WINDOW must be a valid window and defaults to the selected one.
3460 Optional argument ADD non-nil means add SIZE to the new total size of
3461 WINDOW and return the sum.
3463 Note: This function does not operate on any child windows of WINDOW. */)
3464 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3466 struct window
*w
= decode_valid_window (window
);
3468 CHECK_NUMBER (size
);
3470 wset_new_total (w
, size
);
3472 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3474 return w
->new_total
;
3477 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3478 doc
: /* Set new normal size of WINDOW to SIZE.
3479 WINDOW must be a valid window and defaults to the selected one.
3482 Note: This function does not operate on any child windows of WINDOW. */)
3483 (Lisp_Object window
, Lisp_Object size
)
3485 wset_new_normal (decode_valid_window (window
), size
);
3489 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3490 non-zero) to w->new_total would result in correct heights (widths)
3491 for window W and recursively all child windows of W.
3493 Note: This function does not check any of `window-fixed-size-p',
3494 `window-min-height' or `window-min-width'. It does check that window
3495 sizes do not drop below one line (two columns). */
3497 window_resize_check (struct window
*w
, int horflag
)
3501 if (!NILP (w
->vchild
))
3502 /* W is a vertical combination. */
3504 c
= XWINDOW (w
->vchild
);
3506 /* All child windows of W must have the same width as W. */
3510 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3511 || !window_resize_check (c
, horflag
))
3513 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3518 /* The sum of the heights of the child windows of W must equal
3521 int sum_of_sizes
= 0;
3524 if (!window_resize_check (c
, horflag
))
3526 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3527 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3529 return (sum_of_sizes
== XINT (w
->new_total
));
3532 else if (!NILP (w
->hchild
))
3533 /* W is a horizontal combination. */
3535 c
= XWINDOW (w
->hchild
);
3537 /* The sum of the widths of the child windows of W must equal W's
3540 int sum_of_sizes
= 0;
3543 if (!window_resize_check (c
, horflag
))
3545 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3546 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3548 return (sum_of_sizes
== XINT (w
->new_total
));
3551 /* All child windows of W must have the same height as W. */
3555 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3556 || !window_resize_check (c
, horflag
))
3558 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3564 /* A leaf window. Make sure it's not too small. The following
3565 hardcodes the values of `window-safe-min-width' (2) and
3566 `window-safe-min-height' (1) which are defined in window.el. */
3567 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3570 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3571 w->new_total for window W and recursively all child windows of W.
3572 Also calculate and assign the new vertical (horizontal) start
3573 positions of each of these windows.
3575 This function does not perform any error checks. Make sure you have
3576 run window_resize_check on W before applying this function. */
3578 window_resize_apply (struct window
*w
, int horflag
)
3583 /* Note: Assigning new_normal requires that the new total size of the
3584 parent window has been set *before*. */
3587 wset_total_cols (w
, w
->new_total
);
3588 if (NUMBERP (w
->new_normal
))
3589 wset_normal_cols (w
, w
->new_normal
);
3591 pos
= XINT (w
->left_col
);
3595 wset_total_lines (w
, w
->new_total
);
3596 if (NUMBERP (w
->new_normal
))
3597 wset_normal_lines (w
, w
->new_normal
);
3599 pos
= XINT (w
->top_line
);
3602 if (!NILP (w
->vchild
))
3603 /* W is a vertical combination. */
3605 c
= XWINDOW (w
->vchild
);
3609 wset_left_col (c
, make_number (pos
));
3611 wset_top_line (c
, make_number (pos
));
3612 window_resize_apply (c
, horflag
);
3614 pos
= pos
+ XINT (c
->total_lines
);
3615 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3618 else if (!NILP (w
->hchild
))
3619 /* W is a horizontal combination. */
3621 c
= XWINDOW (w
->hchild
);
3625 wset_left_col (c
, make_number (pos
));
3627 wset_top_line (c
, make_number (pos
));
3628 window_resize_apply (c
, horflag
);
3630 pos
= pos
+ XINT (c
->total_cols
);
3631 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3635 /* Clear out some redisplay caches. */
3636 w
->last_modified
= 0;
3637 w
->last_overlay_modified
= 0;
3641 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3642 doc
: /* Apply requested size values for window-tree of FRAME.
3643 If FRAME is omitted or nil, it defaults to the selected frame.
3645 Optional argument HORIZONTAL omitted or nil means apply requested
3646 height values. HORIZONTAL non-nil means apply requested width values.
3648 This function checks whether the requested values sum up to a valid
3649 window layout, recursively assigns the new sizes of all child windows
3650 and calculates and assigns the new start positions of these windows.
3652 Note: This function does not check any of `window-fixed-size-p',
3653 `window-min-height' or `window-min-width'. All these checks have to
3654 be applied on the Elisp level. */)
3655 (Lisp_Object frame
, Lisp_Object horizontal
)
3657 struct frame
*f
= decode_live_frame (frame
);
3658 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3659 int horflag
= !NILP (horizontal
);
3661 if (!window_resize_check (r
, horflag
)
3662 || ! EQ (r
->new_total
,
3663 (horflag
? r
->total_cols
: r
->total_lines
)))
3667 window_resize_apply (r
, horflag
);
3669 windows_or_buffers_changed
++;
3670 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3675 run_window_configuration_change_hook (f
);
3681 /* Resize frame F's windows when number of lines of F is set to SIZE.
3682 HORFLAG 1 means resize windows when number of columns of F is set to
3685 This function can delete all windows but the selected one in order to
3686 satisfy the request. The result will be meaningful if and only if
3687 F's windows have meaningful sizes when you call this. */
3689 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3691 Lisp_Object root
= f
->root_window
;
3692 struct window
*r
= XWINDOW (root
);
3693 Lisp_Object mini
= f
->minibuffer_window
;
3695 /* new_size is the new size of the frame's root window. */
3696 int new_size
= (horflag
3699 - FRAME_TOP_MARGIN (f
)
3700 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3703 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3704 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3705 /* For a leaf root window just set the size. */
3707 wset_total_cols (r
, make_number (new_size
));
3709 wset_total_lines (r
, make_number (new_size
));
3712 /* old_size is the old size of the frame's root window. */
3713 int old_size
= XFASTINT (horflag
? r
->total_cols
3717 XSETINT (delta
, new_size
- old_size
);
3718 /* Try a "normal" resize first. */
3719 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3720 if (window_resize_check (r
, horflag
)
3721 && new_size
== XINT (r
->new_total
))
3722 window_resize_apply (r
, horflag
);
3725 /* Try with "reasonable" minimum sizes next. */
3726 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3727 if (window_resize_check (r
, horflag
)
3728 && new_size
== XINT (r
->new_total
))
3729 window_resize_apply (r
, horflag
);
3732 /* Finally, try with "safe" minimum sizes. */
3733 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3734 if (window_resize_check (r
, horflag
)
3735 && new_size
== XINT (r
->new_total
))
3736 window_resize_apply (r
, horflag
);
3739 /* We lost. Delete all windows but the frame's
3741 root
= f
->selected_window
;
3742 Fdelete_other_windows_internal (root
, Qnil
);
3744 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3746 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3752 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3756 wset_total_cols (m
, make_number (size
));
3759 /* Are we sure we always want 1 line here? */
3760 wset_total_lines (m
, make_number (1));
3762 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3766 windows_or_buffers_changed
++;
3770 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3771 doc
: /* Split window OLD.
3772 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3773 new window. In any case TOTAL-SIZE must be a positive integer.
3775 Third argument SIDE nil (or `below') specifies that the new window shall
3776 be located below WINDOW. SIDE `above' means the new window shall be
3777 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3778 lines of the new window including space reserved for the mode and/or
3781 SIDE t (or `right') specifies that the new window shall be located on
3782 the right side of WINDOW. SIDE `left' means the new window shall be
3783 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3784 number of columns of the new window including space reserved for fringes
3785 and the scrollbar or a divider column.
3787 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3788 according to the SIDE argument.
3790 The new total and normal sizes of all involved windows must have been
3791 set correctly. See the code of `split-window' for how this is done. */)
3792 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3794 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3795 parent window or an internal window we have to install as OLD's new
3796 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3797 provided OLD is a leaf window, or to the frame's selected window.
3798 NEW (*n) is the new window created with some parameters taken from
3800 register Lisp_Object
new, frame
, reference
;
3801 register struct window
*o
, *p
, *n
, *r
;
3804 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3805 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3806 int combination_limit
= 0;
3810 frame
= WINDOW_FRAME (o
);
3813 CHECK_NUMBER (total_size
);
3815 /* Set combination_limit to 1 if we have to make a new parent window.
3816 We do that if either `window-combination-limit' is t, or OLD has no
3817 parent, or OLD is ortho-combined. */
3819 EQ (Vwindow_combination_limit
, Qt
)
3822 ? (XWINDOW (o
->parent
)->hchild
)
3823 : (XWINDOW (o
->parent
)->vchild
));
3825 /* We need a live reference window to initialize some parameters. */
3826 if (WINDOW_LIVE_P (old
))
3827 /* OLD is live, use it as reference window. */
3830 /* Use the frame's selected window as reference window. */
3831 reference
= FRAME_SELECTED_WINDOW (f
);
3832 r
= XWINDOW (reference
);
3834 /* The following bugs are caught by `split-window'. */
3835 if (MINI_WINDOW_P (o
))
3836 error ("Attempt to split minibuffer window");
3837 else if (XINT (total_size
) < (horflag
? 2 : 1))
3838 error ("Size of new window too small (after split)");
3839 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3840 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3843 p
= XWINDOW (o
->parent
);
3844 /* Temporarily pretend we split the parent window. */
3846 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3847 - XINT (total_size
)));
3848 if (!window_resize_check (p
, horflag
))
3849 error ("Window sizes don't fit");
3851 /* Undo the temporary pretension. */
3852 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3856 if (!window_resize_check (o
, horflag
))
3857 error ("Resizing old window failed");
3858 else if (XINT (total_size
) + XINT (o
->new_total
)
3859 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3860 error ("Sum of sizes of old and new window don't fit");
3863 /* This is our point of no return. */
3864 if (combination_limit
)
3866 /* Save the old value of o->normal_cols/lines. It gets corrupted
3867 by make_parent_window and we need it below for assigning it to
3869 Lisp_Object new_normal
3870 = horflag
? o
->normal_cols
: o
->normal_lines
;
3872 make_parent_window (old
, horflag
);
3873 p
= XWINDOW (o
->parent
);
3874 if (EQ (Vwindow_combination_limit
, Qt
))
3875 /* Store t in the new parent's combination_limit slot to avoid
3876 that its children get merged into another window. */
3877 wset_combination_limit (p
, Qt
);
3878 /* These get applied below. */
3879 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3880 wset_new_normal (p
, new_normal
);
3883 p
= XWINDOW (o
->parent
);
3885 windows_or_buffers_changed
++;
3886 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3887 new = make_window ();
3889 wset_frame (n
, frame
);
3890 wset_parent (n
, o
->parent
);
3891 wset_vchild (n
, Qnil
);
3892 wset_hchild (n
, Qnil
);
3894 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3896 wset_prev (n
, o
->prev
);
3899 wset_hchild (p
, new);
3901 wset_vchild (p
, new);
3903 wset_next (XWINDOW (n
->prev
), new);
3909 wset_next (n
, o
->next
);
3910 if (!NILP (n
->next
))
3911 wset_prev (XWINDOW (n
->next
), new);
3916 wset_window_end_valid (n
, Qnil
);
3917 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3919 /* Get special geometry settings from reference window. */
3920 wset_left_margin_cols (n
, r
->left_margin_cols
);
3921 wset_right_margin_cols (n
, r
->right_margin_cols
);
3922 wset_left_fringe_width (n
, r
->left_fringe_width
);
3923 wset_right_fringe_width (n
, r
->right_fringe_width
);
3924 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3925 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3926 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3928 /* Directly assign orthogonal coordinates and sizes. */
3931 wset_top_line (n
, o
->top_line
);
3932 wset_total_lines (n
, o
->total_lines
);
3936 wset_left_col (n
, o
->left_col
);
3937 wset_total_cols (n
, o
->total_cols
);
3940 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3941 get them ready here. */
3942 wset_new_total (n
, total_size
);
3943 wset_new_normal (n
, normal_size
);
3946 window_resize_apply (p
, horflag
);
3948 /* Set buffer of NEW to buffer of reference window. Don't run
3950 set_window_buffer (new, r
->buffer
, 0, 1);
3953 /* Maybe we should run the scroll functions in Elisp (which already
3954 runs the configuration change hook). */
3955 if (! NILP (Vwindow_scroll_functions
))
3956 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3957 Fmarker_position (n
->start
));
3963 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3964 doc
: /* Remove WINDOW from its frame.
3965 WINDOW defaults to the selected window. Return nil.
3966 Signal an error when WINDOW is the only window on its frame. */)
3967 (register Lisp_Object window
)
3969 register Lisp_Object parent
, sibling
, frame
, root
;
3970 struct window
*w
, *p
, *s
, *r
;
3973 int before_sibling
= 0;
3975 w
= decode_any_window (window
);
3976 XSETWINDOW (window
, w
);
3977 if (NILP (w
->buffer
)
3978 && NILP (w
->hchild
) && NILP (w
->vchild
))
3979 /* It's a no-op to delete an already deleted window. */
3984 /* Never delete a minibuffer or frame root window. */
3985 error ("Attempt to delete minibuffer or sole ordinary window");
3986 else if (NILP (w
->prev
) && NILP (w
->next
))
3987 /* Rather bow out here, this case should be handled on the Elisp
3989 error ("Attempt to delete sole window of parent");
3991 p
= XWINDOW (parent
);
3992 horflag
= NILP (p
->vchild
);
3994 frame
= WINDOW_FRAME (w
);
3997 root
= FRAME_ROOT_WINDOW (f
);
4000 /* Unlink WINDOW from window tree. */
4002 /* Get SIBLING below (on the right of) WINDOW. */
4004 /* before_sibling 1 means WINDOW is the first child of its
4005 parent and thus before the sibling. */
4008 s
= XWINDOW (sibling
);
4009 wset_prev (s
, Qnil
);
4011 wset_hchild (p
, sibling
);
4013 wset_vchild (p
, sibling
);
4016 /* Get SIBLING above (on the left of) WINDOW. */
4019 s
= XWINDOW (sibling
);
4020 wset_next (s
, w
->next
);
4021 if (!NILP (s
->next
))
4022 wset_prev (XWINDOW (s
->next
), sibling
);
4025 if (window_resize_check (r
, horflag
)
4026 && EQ (r
->new_total
,
4027 (horflag
? r
->total_cols
: r
->total_lines
)))
4028 /* We can delete WINDOW now. */
4033 window_resize_apply (p
, horflag
);
4035 /* If this window is referred to by the dpyinfo's mouse
4036 highlight, invalidate that slot to be safe (Bug#9904). */
4037 if (!FRAME_INITIAL_P (f
))
4039 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4041 if (EQ (hlinfo
->mouse_face_window
, window
))
4042 hlinfo
->mouse_face_window
= Qnil
;
4045 windows_or_buffers_changed
++;
4046 Vwindow_list
= Qnil
;
4047 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4049 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4050 free_window_matrices (w
);
4052 if (!NILP (w
->vchild
))
4054 delete_all_child_windows (w
->vchild
);
4055 wset_vchild (w
, Qnil
);
4057 else if (!NILP (w
->hchild
))
4059 delete_all_child_windows (w
->hchild
);
4060 wset_hchild (w
, Qnil
);
4062 else if (!NILP (w
->buffer
))
4065 unchain_marker (XMARKER (w
->pointm
));
4066 unchain_marker (XMARKER (w
->start
));
4067 wset_buffer (w
, Qnil
);
4070 if (NILP (s
->prev
) && NILP (s
->next
))
4071 /* A matrjoshka where SIBLING has become the only child of
4074 /* Put SIBLING into PARENT's place. */
4075 replace_window (parent
, sibling
, 0);
4076 /* Have SIBLING inherit the following three slot values from
4077 PARENT (the combination_limit slot is not inherited). */
4078 wset_normal_cols (s
, p
->normal_cols
);
4079 wset_normal_lines (s
, p
->normal_lines
);
4080 /* Mark PARENT as deleted. */
4081 wset_vchild (p
, Qnil
);
4082 wset_hchild (p
, Qnil
);
4083 /* Try to merge SIBLING into its new parent. */
4084 recombine_windows (sibling
);
4089 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4090 /* We deleted the frame's selected window. */
4092 /* Use the frame's first window as fallback ... */
4093 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4094 /* ... but preferably use its most recently used window. */
4095 Lisp_Object mru_window
;
4097 /* `get-mru-window' might fail for some reason so play it safe
4098 - promote the first window _without recording it_ first. */
4099 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4100 Fselect_window (new_selected_window
, Qt
);
4102 fset_selected_window (f
, new_selected_window
);
4106 /* Now look whether `get-mru-window' gets us something. */
4107 mru_window
= call1 (Qget_mru_window
, frame
);
4108 if (WINDOW_LIVE_P (mru_window
)
4109 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4110 new_selected_window
= mru_window
;
4112 /* If all ended up well, we now promote the mru window. */
4113 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4114 Fselect_window (new_selected_window
, Qnil
);
4116 fset_selected_window (f
, new_selected_window
);
4121 /* Must be run by the caller:
4122 run_window_configuration_change_hook (f); */
4125 /* We failed: Relink WINDOW into window tree. */
4129 wset_prev (s
, window
);
4131 wset_hchild (p
, window
);
4133 wset_vchild (p
, window
);
4137 wset_next (s
, window
);
4138 if (!NILP (w
->next
))
4139 wset_prev (XWINDOW (w
->next
), window
);
4141 error ("Deletion failed");
4147 /***********************************************************************
4148 Resizing Mini-Windows
4149 ***********************************************************************/
4151 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4154 grow_mini_window (struct window
*w
, int delta
)
4156 struct frame
*f
= XFRAME (w
->frame
);
4158 Lisp_Object root
, value
;
4160 eassert (MINI_WINDOW_P (w
));
4161 eassert (delta
>= 0);
4163 root
= FRAME_ROOT_WINDOW (f
);
4165 value
= call2 (Qwindow_resize_root_window_vertically
,
4166 root
, make_number (- delta
));
4167 if (INTEGERP (value
) && window_resize_check (r
, 0))
4170 window_resize_apply (r
, 0);
4172 /* Grow the mini-window. */
4174 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4176 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4177 w
->last_modified
= 0;
4178 w
->last_overlay_modified
= 0;
4180 windows_or_buffers_changed
++;
4187 /* Shrink mini-window W. */
4189 shrink_mini_window (struct window
*w
)
4191 struct frame
*f
= XFRAME (w
->frame
);
4193 Lisp_Object root
, value
;
4196 eassert (MINI_WINDOW_P (w
));
4198 size
= XINT (w
->total_lines
);
4201 root
= FRAME_ROOT_WINDOW (f
);
4203 value
= call2 (Qwindow_resize_root_window_vertically
,
4204 root
, make_number (size
- 1));
4205 if (INTEGERP (value
) && window_resize_check (r
, 0))
4208 window_resize_apply (r
, 0);
4210 /* Shrink the mini-window. */
4211 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4212 + XFASTINT (r
->total_lines
)));
4213 wset_total_lines (w
, make_number (1));
4215 w
->last_modified
= 0;
4216 w
->last_overlay_modified
= 0;
4218 windows_or_buffers_changed
++;
4222 /* If the above failed for whatever strange reason we must make a
4223 one window frame here. The same routine will be needed when
4224 shrinking the frame (and probably when making the initial
4225 *scratch* window). For the moment leave things as they are. */
4229 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4230 doc
: /* Resize minibuffer window WINDOW. */)
4231 (Lisp_Object window
)
4233 struct window
*w
= XWINDOW (window
);
4238 CHECK_WINDOW (window
);
4239 f
= XFRAME (w
->frame
);
4241 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4242 error ("Not a valid minibuffer window");
4243 else if (FRAME_MINIBUF_ONLY_P (f
))
4244 error ("Cannot resize a minibuffer-only frame");
4246 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4247 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4248 if (window_resize_check (r
, 0)
4249 && XINT (w
->new_total
) > 0
4250 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4253 window_resize_apply (r
, 0);
4255 wset_total_lines (w
, w
->new_total
);
4256 wset_top_line (w
, make_number (XINT (r
->top_line
)
4257 + XINT (r
->total_lines
)));
4259 windows_or_buffers_changed
++;
4260 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4264 run_window_configuration_change_hook (f
);
4267 else error ("Failed to resize minibuffer window");
4270 /* Mark window cursors off for all windows in the window tree rooted
4271 at W by setting their phys_cursor_on_p flag to zero. Called from
4272 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4273 the frame are cleared. */
4276 mark_window_cursors_off (struct window
*w
)
4280 if (!NILP (w
->hchild
))
4281 mark_window_cursors_off (XWINDOW (w
->hchild
));
4282 else if (!NILP (w
->vchild
))
4283 mark_window_cursors_off (XWINDOW (w
->vchild
));
4285 w
->phys_cursor_on_p
= 0;
4287 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4292 /* Return number of lines of text (not counting mode lines) in W. */
4295 window_internal_height (struct window
*w
)
4297 int ht
= XFASTINT (w
->total_lines
);
4299 if (!MINI_WINDOW_P (w
))
4301 if (!NILP (w
->parent
)
4302 || !NILP (w
->vchild
)
4303 || !NILP (w
->hchild
)
4306 || WINDOW_WANTS_MODELINE_P (w
))
4309 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4316 /************************************************************************
4318 ***********************************************************************/
4320 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4321 N screen-fulls, which is defined as the height of the window minus
4322 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4323 instead. Negative values of N mean scroll down. NOERROR non-zero
4324 means don't signal an error if we try to move over BEGV or ZV,
4328 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4331 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4333 /* If we must, use the pixel-based version which is much slower than
4334 the line-based one but can handle varying line heights. */
4335 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4336 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4338 window_scroll_line_based (window
, n
, whole
, noerror
);
4344 /* Implementation of window_scroll that works based on pixel line
4345 heights. See the comment of window_scroll for parameter
4349 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4352 struct window
*w
= XWINDOW (window
);
4353 struct text_pos start
;
4354 int this_scroll_margin
;
4355 /* True if we fiddled the window vscroll field without really scrolling. */
4357 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4358 void *itdata
= NULL
;
4360 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4361 /* Scrolling a minibuffer window via scroll bar when the echo area
4362 shows long text sometimes resets the minibuffer contents behind
4364 if (CHARPOS (start
) > ZV
)
4365 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4367 /* If PT is not visible in WINDOW, move back one half of
4368 the screen. Allow PT to be partially visible, otherwise
4369 something like (scroll-down 1) with PT in the line before
4370 the partially visible one would recenter. */
4372 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4374 itdata
= bidi_shelve_cache ();
4375 /* Move backward half the height of the window. Performance note:
4376 vmotion used here is about 10% faster, but would give wrong
4377 results for variable height lines. */
4378 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4379 it
.current_y
= it
.last_visible_y
;
4380 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4382 /* The function move_iterator_vertically may move over more than
4383 the specified y-distance. If it->w is small, e.g. a
4384 mini-buffer window, we may end up in front of the window's
4385 display area. This is the case when Start displaying at the
4386 start of the line containing PT in this case. */
4387 if (it
.current_y
<= 0)
4389 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4390 move_it_vertically_backward (&it
, 0);
4394 start
= it
.current
.pos
;
4395 bidi_unshelve_cache (itdata
, 0);
4397 else if (auto_window_vscroll_p
)
4399 if (rtop
|| rbot
) /* partially visible */
4402 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4404 dy
= max ((window_box_height (w
)
4405 - next_screen_context_lines
* dy
),
4411 /* Only vscroll backwards if already vscrolled forwards. */
4412 if (w
->vscroll
< 0 && rtop
> 0)
4414 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4415 Fset_window_vscroll (window
, make_number (px
), Qt
);
4421 /* Do vscroll if already vscrolled or only display line. */
4422 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4424 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4425 Fset_window_vscroll (window
, make_number (px
), Qt
);
4429 /* Maybe modify window start instead of scrolling. */
4430 if (rbot
> 0 || w
->vscroll
< 0)
4434 Fset_window_vscroll (window
, make_number (0), Qt
);
4435 /* If there are other text lines above the current row,
4436 move window start to current row. Else to next row. */
4438 spos
= XINT (Fline_beginning_position (Qnil
));
4440 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4441 set_marker_restricted (w
->start
, make_number (spos
),
4443 w
->start_at_line_beg
= 1;
4444 w
->update_mode_line
= 1;
4445 w
->last_modified
= 0;
4446 w
->last_overlay_modified
= 0;
4447 /* Set force_start so that redisplay_window will run the
4448 window-scroll-functions. */
4454 /* Cancel previous vscroll. */
4455 Fset_window_vscroll (window
, make_number (0), Qt
);
4458 itdata
= bidi_shelve_cache ();
4459 /* If scroll_preserve_screen_position is non-nil, we try to set
4460 point in the same window line as it is now, so get that line. */
4461 if (!NILP (Vscroll_preserve_screen_position
))
4463 /* We preserve the goal pixel coordinate across consecutive
4464 calls to scroll-up, scroll-down and other commands that
4465 have the `scroll-command' property. This avoids the
4466 possibility of point becoming "stuck" on a tall line when
4467 scrolling by one line. */
4468 if (window_scroll_pixel_based_preserve_y
< 0
4469 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4470 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4472 start_display (&it
, w
, start
);
4473 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4474 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4475 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4479 window_scroll_pixel_based_preserve_y
4480 = window_scroll_pixel_based_preserve_x
= -1;
4482 /* Move iterator it from start the specified distance forward or
4483 backward. The result is the new window start. */
4484 start_display (&it
, w
, start
);
4487 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4488 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4489 dy
= max ((window_box_height (w
)
4490 - next_screen_context_lines
* dy
),
4493 /* Note that move_it_vertically always moves the iterator to the
4494 start of a line. So, if the last line doesn't have a newline,
4495 we would end up at the start of the line ending at ZV. */
4498 move_it_vertically_backward (&it
, -dy
);
4499 /* Ensure we actually do move, e.g. in case we are currently
4500 looking at an image that is taller that the window height. */
4501 while (start_pos
== IT_CHARPOS (it
)
4502 && start_pos
> BEGV
)
4503 move_it_by_lines (&it
, -1);
4507 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4508 MOVE_TO_POS
| MOVE_TO_Y
);
4509 /* Ensure we actually do move, e.g. in case we are currently
4510 looking at an image that is taller that the window height. */
4511 while (start_pos
== IT_CHARPOS (it
)
4513 move_it_by_lines (&it
, 1);
4517 move_it_by_lines (&it
, n
);
4519 /* We failed if we find ZV is already on the screen (scrolling up,
4520 means there's nothing past the end), or if we can't start any
4521 earlier (scrolling down, means there's nothing past the top). */
4522 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4523 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4525 if (IT_CHARPOS (it
) == ZV
)
4527 if (it
.current_y
< it
.last_visible_y
4528 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4529 > it
.last_visible_y
))
4531 /* The last line was only partially visible, make it fully
4533 w
->vscroll
= (it
.last_visible_y
4534 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4535 adjust_glyphs (it
.f
);
4539 bidi_unshelve_cache (itdata
, 0);
4542 else if (n
< 0) /* could happen with empty buffers */
4543 xsignal0 (Qbeginning_of_buffer
);
4545 xsignal0 (Qend_of_buffer
);
4550 if (w
->vscroll
!= 0)
4551 /* The first line was only partially visible, make it fully
4556 bidi_unshelve_cache (itdata
, 0);
4560 xsignal0 (Qbeginning_of_buffer
);
4564 /* If control gets here, then we vscrolled. */
4566 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4568 /* Don't try to change the window start below. */
4574 ptrdiff_t pos
= IT_CHARPOS (it
);
4577 /* If in the middle of a multi-glyph character move forward to
4578 the next character. */
4579 if (in_display_vector_p (&it
))
4582 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4585 /* Set the window start, and set up the window for redisplay. */
4586 set_marker_restricted (w
->start
, make_number (pos
),
4588 bytepos
= XMARKER (w
->start
)->bytepos
;
4589 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4590 w
->update_mode_line
= 1;
4591 w
->last_modified
= 0;
4592 w
->last_overlay_modified
= 0;
4593 /* Set force_start so that redisplay_window will run the
4594 window-scroll-functions. */
4598 /* The rest of this function uses current_y in a nonstandard way,
4599 not including the height of the header line if any. */
4600 it
.current_y
= it
.vpos
= 0;
4602 /* Move PT out of scroll margins.
4603 This code wants current_y to be zero at the window start position
4604 even if there is a header line. */
4605 this_scroll_margin
= max (0, scroll_margin
);
4607 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4608 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4612 /* We moved the window start towards ZV, so PT may be now
4613 in the scroll margin at the top. */
4614 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4615 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4616 && (NILP (Vscroll_preserve_screen_position
)
4617 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4618 /* We found PT at a legitimate height. Leave it alone. */
4620 else if (window_scroll_pixel_based_preserve_y
>= 0)
4622 /* If we have a header line, take account of it.
4623 This is necessary because we set it.current_y to 0, above. */
4624 move_it_to (&it
, -1,
4625 window_scroll_pixel_based_preserve_x
,
4626 window_scroll_pixel_based_preserve_y
4627 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4628 -1, MOVE_TO_Y
| MOVE_TO_X
);
4629 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4633 while (it
.current_y
< this_scroll_margin
)
4635 int prev
= it
.current_y
;
4636 move_it_by_lines (&it
, 1);
4637 if (prev
== it
.current_y
)
4640 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4645 ptrdiff_t charpos
, bytepos
;
4648 /* Save our position, for the
4649 window_scroll_pixel_based_preserve_y case. */
4650 charpos
= IT_CHARPOS (it
);
4651 bytepos
= IT_BYTEPOS (it
);
4653 /* We moved the window start towards BEGV, so PT may be now
4654 in the scroll margin at the bottom. */
4655 move_it_to (&it
, PT
, -1,
4656 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4657 - this_scroll_margin
- 1),
4659 MOVE_TO_POS
| MOVE_TO_Y
);
4661 /* Save our position, in case it's correct. */
4662 charpos
= IT_CHARPOS (it
);
4663 bytepos
= IT_BYTEPOS (it
);
4665 /* See if point is on a partially visible line at the end. */
4666 if (it
.what
== IT_EOB
)
4667 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4670 move_it_by_lines (&it
, 1);
4671 partial_p
= it
.current_y
> it
.last_visible_y
;
4674 if (charpos
== PT
&& !partial_p
4675 && (NILP (Vscroll_preserve_screen_position
)
4676 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4677 /* We found PT before we found the display margin, so PT is ok. */
4679 else if (window_scroll_pixel_based_preserve_y
>= 0)
4681 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4682 start_display (&it
, w
, start
);
4683 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4684 here because we called start_display again and did not
4685 alter it.current_y this time. */
4686 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4687 window_scroll_pixel_based_preserve_y
, -1,
4688 MOVE_TO_Y
| MOVE_TO_X
);
4689 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4694 /* The last line was only partially visible, so back up two
4695 lines to make sure we're on a fully visible line. */
4697 move_it_by_lines (&it
, -2);
4698 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4701 /* No, the position we saved is OK, so use it. */
4702 SET_PT_BOTH (charpos
, bytepos
);
4705 bidi_unshelve_cache (itdata
, 0);
4709 /* Implementation of window_scroll that works based on screen lines.
4710 See the comment of window_scroll for parameter descriptions. */
4713 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4715 register struct window
*w
= XWINDOW (window
);
4716 /* Fvertical_motion enters redisplay, which can trigger
4717 fontification, which in turn can modify buffer text (e.g., if the
4718 fontification functions replace escape sequences with faces, as
4719 in `grep-mode-font-lock-keywords'). So we use a marker to record
4720 the old point position, to prevent crashes in SET_PT_BOTH. */
4721 Lisp_Object opoint_marker
= Fpoint_marker ();
4722 register ptrdiff_t pos
, pos_byte
;
4723 register int ht
= window_internal_height (w
);
4724 register Lisp_Object tem
;
4728 Lisp_Object original_pos
= Qnil
;
4730 /* If scrolling screen-fulls, compute the number of lines to
4731 scroll from the window's height. */
4733 n
*= max (1, ht
- next_screen_context_lines
);
4735 startpos
= marker_position (w
->start
);
4737 if (!NILP (Vscroll_preserve_screen_position
))
4739 if (window_scroll_preserve_vpos
<= 0
4740 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4741 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4743 struct position posit
4744 = *compute_motion (startpos
, 0, 0, 0,
4748 window_scroll_preserve_vpos
= posit
.vpos
;
4749 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4752 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4753 make_number (window_scroll_preserve_vpos
));
4756 XSETFASTINT (tem
, PT
);
4757 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4761 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4766 lose
= n
< 0 && PT
== BEGV
;
4767 Fvertical_motion (make_number (n
), window
);
4771 SET_PT_BOTH (marker_position (opoint_marker
),
4772 marker_byte_position (opoint_marker
));
4779 xsignal0 (Qbeginning_of_buffer
);
4784 /* Don't use a scroll margin that is negative or too large. */
4785 int this_scroll_margin
=
4786 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4788 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4789 w
->start_at_line_beg
= !NILP (bolp
);
4790 w
->update_mode_line
= 1;
4791 w
->last_modified
= 0;
4792 w
->last_overlay_modified
= 0;
4793 /* Set force_start so that redisplay_window will run
4794 the window-scroll-functions. */
4797 if (!NILP (Vscroll_preserve_screen_position
)
4798 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4800 SET_PT_BOTH (pos
, pos_byte
);
4801 Fvertical_motion (original_pos
, window
);
4803 /* If we scrolled forward, put point enough lines down
4804 that it is outside the scroll margin. */
4809 if (this_scroll_margin
> 0)
4811 SET_PT_BOTH (pos
, pos_byte
);
4812 Fvertical_motion (make_number (this_scroll_margin
), window
);
4818 if (top_margin
<= marker_position (opoint_marker
))
4819 SET_PT_BOTH (marker_position (opoint_marker
),
4820 marker_byte_position (opoint_marker
));
4821 else if (!NILP (Vscroll_preserve_screen_position
))
4823 SET_PT_BOTH (pos
, pos_byte
);
4824 Fvertical_motion (original_pos
, window
);
4827 SET_PT (top_margin
);
4833 /* If we scrolled backward, put point near the end of the window
4834 but not within the scroll margin. */
4835 SET_PT_BOTH (pos
, pos_byte
);
4836 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4837 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4840 bottom_margin
= PT
+ 1;
4842 if (bottom_margin
> marker_position (opoint_marker
))
4843 SET_PT_BOTH (marker_position (opoint_marker
),
4844 marker_byte_position (opoint_marker
));
4847 if (!NILP (Vscroll_preserve_screen_position
))
4849 SET_PT_BOTH (pos
, pos_byte
);
4850 Fvertical_motion (original_pos
, window
);
4853 Fvertical_motion (make_number (-1), window
);
4862 xsignal0 (Qend_of_buffer
);
4867 /* Scroll selected_window up or down. If N is nil, scroll a
4868 screen-full which is defined as the height of the window minus
4869 next_screen_context_lines. If N is the symbol `-', scroll.
4870 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4871 up. This is the guts of Fscroll_up and Fscroll_down. */
4874 scroll_command (Lisp_Object n
, int direction
)
4876 ptrdiff_t count
= SPECPDL_INDEX ();
4878 eassert (eabs (direction
) == 1);
4880 /* If selected window's buffer isn't current, make it current for
4881 the moment. But don't screw up if window_scroll gets an error. */
4882 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4884 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4885 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4887 /* Make redisplay consider other windows than just selected_window. */
4888 ++windows_or_buffers_changed
;
4892 window_scroll (selected_window
, direction
, 1, 0);
4893 else if (EQ (n
, Qminus
))
4894 window_scroll (selected_window
, -direction
, 1, 0);
4897 n
= Fprefix_numeric_value (n
);
4898 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4901 unbind_to (count
, Qnil
);
4904 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4905 doc
: /* Scroll text of selected window upward ARG lines.
4906 If ARG is omitted or nil, scroll upward by a near full screen.
4907 A near full screen is `next-screen-context-lines' less than a full screen.
4908 Negative ARG means scroll downward.
4909 If ARG is the atom `-', scroll downward by nearly full screen.
4910 When calling from a program, supply as argument a number, nil, or `-'. */)
4913 scroll_command (arg
, 1);
4917 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4918 doc
: /* Scroll text of selected window down ARG lines.
4919 If ARG is omitted or nil, scroll down by a near full screen.
4920 A near full screen is `next-screen-context-lines' less than a full screen.
4921 Negative ARG means scroll upward.
4922 If ARG is the atom `-', scroll upward by nearly full screen.
4923 When calling from a program, supply as argument a number, nil, or `-'. */)
4926 scroll_command (arg
, -1);
4930 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4931 doc
: /* Return the other window for \"other window scroll\" commands.
4932 If `other-window-scroll-buffer' is non-nil, a window
4933 showing that buffer is used.
4934 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4935 specifies the window. This takes precedence over
4936 `other-window-scroll-buffer'. */)
4941 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4942 && !NILP (Vminibuf_scroll_window
))
4943 window
= Vminibuf_scroll_window
;
4944 /* If buffer is specified, scroll that buffer. */
4945 else if (!NILP (Vother_window_scroll_buffer
))
4947 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4949 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4953 /* Nothing specified; look for a neighboring window on the same
4955 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4957 if (EQ (window
, selected_window
))
4958 /* That didn't get us anywhere; look for a window on another
4961 window
= Fnext_window (window
, Qnil
, Qt
);
4962 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4963 && ! EQ (window
, selected_window
));
4966 CHECK_LIVE_WINDOW (window
);
4968 if (EQ (window
, selected_window
))
4969 error ("There is no other window");
4974 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4975 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4976 A near full screen is `next-screen-context-lines' less than a full screen.
4977 The next window is the one below the current one; or the one at the top
4978 if the current one is at the bottom. Negative ARG means scroll downward.
4979 If ARG is the atom `-', scroll downward by nearly full screen.
4980 When calling from a program, supply as argument a number, nil, or `-'.
4982 If `other-window-scroll-buffer' is non-nil, scroll the window
4983 showing that buffer, popping the buffer up if necessary.
4984 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4985 specifies the window to scroll. This takes precedence over
4986 `other-window-scroll-buffer'. */)
4991 ptrdiff_t count
= SPECPDL_INDEX ();
4993 window
= Fother_window_for_scrolling ();
4994 w
= XWINDOW (window
);
4996 /* Don't screw up if window_scroll gets an error. */
4997 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4998 ++windows_or_buffers_changed
;
5000 Fset_buffer (w
->buffer
);
5001 SET_PT (marker_position (w
->pointm
));
5004 window_scroll (window
, 1, 1, 1);
5005 else if (EQ (arg
, Qminus
))
5006 window_scroll (window
, -1, 1, 1);
5012 window_scroll (window
, XINT (arg
), 0, 1);
5015 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5016 unbind_to (count
, Qnil
);
5021 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5022 doc
: /* Scroll selected window display ARG columns left.
5023 Default for ARG is window width minus 2.
5024 Value is the total amount of leftward horizontal scrolling in
5025 effect after the change.
5026 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5027 lower bound for automatic scrolling, i.e. automatic scrolling
5028 will not scroll a window to a column less than the value returned
5029 by this function. This happens in an interactive call. */)
5030 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5032 struct window
*w
= XWINDOW (selected_window
);
5033 EMACS_INT requested_arg
= (NILP (arg
)
5034 ? window_body_cols (w
) - 2
5035 : XINT (Fprefix_numeric_value (arg
)));
5036 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5038 if (!NILP (set_minimum
))
5039 w
->min_hscroll
= w
->hscroll
;
5044 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5045 doc
: /* Scroll selected window display ARG columns right.
5046 Default for ARG is window width minus 2.
5047 Value is the total amount of leftward horizontal scrolling in
5048 effect after the change.
5049 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5050 lower bound for automatic scrolling, i.e. automatic scrolling
5051 will not scroll a window to a column less than the value returned
5052 by this function. This happens in an interactive call. */)
5053 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5055 struct window
*w
= XWINDOW (selected_window
);
5056 EMACS_INT requested_arg
= (NILP (arg
)
5057 ? window_body_cols (w
) - 2
5058 : XINT (Fprefix_numeric_value (arg
)));
5059 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5061 if (!NILP (set_minimum
))
5062 w
->min_hscroll
= w
->hscroll
;
5067 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5068 doc
: /* Return the window which was selected when entering the minibuffer.
5069 Returns nil, if selected window is not a minibuffer window. */)
5072 if (minibuf_level
> 0
5073 && MINI_WINDOW_P (XWINDOW (selected_window
))
5074 && WINDOW_LIVE_P (minibuf_selected_window
))
5075 return minibuf_selected_window
;
5080 /* Value is the number of lines actually displayed in window W,
5081 as opposed to its height. */
5084 displayed_window_lines (struct window
*w
)
5087 struct text_pos start
;
5088 int height
= window_box_height (w
);
5089 struct buffer
*old_buffer
;
5091 void *itdata
= NULL
;
5093 if (XBUFFER (w
->buffer
) != current_buffer
)
5095 old_buffer
= current_buffer
;
5096 set_buffer_internal (XBUFFER (w
->buffer
));
5101 /* In case W->start is out of the accessible range, do something
5102 reasonable. This happens in Info mode when Info-scroll-down
5103 calls (recenter -1) while W->start is 1. */
5104 if (XMARKER (w
->start
)->charpos
< BEGV
)
5105 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5106 else if (XMARKER (w
->start
)->charpos
> ZV
)
5107 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5109 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5111 itdata
= bidi_shelve_cache ();
5112 start_display (&it
, w
, start
);
5113 move_it_vertically (&it
, height
);
5114 bottom_y
= line_bottom_y (&it
);
5115 bidi_unshelve_cache (itdata
, 0);
5117 /* rms: On a non-window display,
5118 the value of it.vpos at the bottom of the screen
5119 seems to be 1 larger than window_box_height (w).
5120 This kludge fixes a bug whereby (move-to-window-line -1)
5121 when ZV is on the last screen line
5122 moves to the previous screen line instead of the last one. */
5123 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5126 /* Add in empty lines at the bottom of the window. */
5127 if (bottom_y
< height
)
5129 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5130 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5134 set_buffer_internal (old_buffer
);
5140 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5141 doc
: /* Center point in selected window and maybe redisplay frame.
5142 With prefix argument ARG, recenter putting point on screen line ARG
5143 relative to the selected window. If ARG is negative, it counts up from the
5144 bottom of the window. (ARG should be less than the height of the window.)
5146 If ARG is omitted or nil, then recenter with point on the middle line of
5147 the selected window; if the variable `recenter-redisplay' is non-nil,
5148 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5149 is set to `grow-only', this resets the tool-bar's height to the minimum
5150 height needed); if `recenter-redisplay' has the special value `tty',
5151 then only tty frames are redrawn.
5153 Just C-u as prefix means put point in the center of the window
5154 and redisplay normally--don't erase and redraw the frame. */)
5155 (register Lisp_Object arg
)
5157 struct window
*w
= XWINDOW (selected_window
);
5158 struct buffer
*buf
= XBUFFER (w
->buffer
);
5159 struct buffer
*obuf
= current_buffer
;
5161 ptrdiff_t charpos
, bytepos
;
5162 EMACS_INT iarg
IF_LINT (= 0);
5163 int this_scroll_margin
;
5165 /* If redisplay is suppressed due to an error, try again. */
5166 obuf
->display_error_modiff
= 0;
5170 if (!NILP (Vrecenter_redisplay
)
5171 && (!EQ (Vrecenter_redisplay
, Qtty
)
5172 || !NILP (Ftty_type (selected_frame
))))
5176 /* Invalidate pixel data calculated for all compositions. */
5177 for (i
= 0; i
< n_compositions
; i
++)
5178 composition_table
[i
]->font
= NULL
;
5180 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5182 Fredraw_frame (WINDOW_FRAME (w
));
5183 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5188 else if (CONSP (arg
)) /* Just C-u. */
5192 arg
= Fprefix_numeric_value (arg
);
5197 set_buffer_internal (buf
);
5199 /* Do this after making BUF current
5200 in case scroll_margin is buffer-local. */
5201 this_scroll_margin
=
5202 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5204 /* Handle centering on a graphical frame specially. Such frames can
5205 have variable-height lines and centering point on the basis of
5206 line counts would lead to strange effects. */
5207 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5213 void *itdata
= bidi_shelve_cache ();
5215 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5216 start_display (&it
, w
, pt
);
5217 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5218 charpos
= IT_CHARPOS (it
);
5219 bytepos
= IT_BYTEPOS (it
);
5220 bidi_unshelve_cache (itdata
, 0);
5226 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5227 int extra_line_spacing
;
5228 int h
= window_box_height (w
);
5229 void *itdata
= bidi_shelve_cache ();
5231 iarg
= - max (-iarg
, this_scroll_margin
);
5233 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5234 start_display (&it
, w
, pt
);
5236 /* Be sure we have the exact height of the full line containing PT. */
5237 move_it_by_lines (&it
, 0);
5239 /* The amount of pixels we have to move back is the window
5240 height minus what's displayed in the line containing PT,
5241 and the lines below. */
5244 move_it_by_lines (&it
, nlines
);
5246 if (it
.vpos
== nlines
)
5250 /* Last line has no newline */
5251 h
-= line_bottom_y (&it
);
5255 /* Don't reserve space for extra line spacing of last line. */
5256 extra_line_spacing
= it
.max_extra_line_spacing
;
5258 /* If we can't move down NLINES lines because we hit
5259 the end of the buffer, count in some empty lines. */
5260 if (it
.vpos
< nlines
)
5263 extra_line_spacing
= it
.extra_line_spacing
;
5264 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5268 bidi_unshelve_cache (itdata
, 0);
5272 /* Now find the new top line (starting position) of the window. */
5273 start_display (&it
, w
, pt
);
5275 move_it_vertically_backward (&it
, h
);
5277 /* If extra line spacing is present, we may move too far
5278 back. This causes the last line to be only partially
5279 visible (which triggers redisplay to recenter that line
5280 in the middle), so move forward.
5281 But ignore extra line spacing on last line, as it is not
5282 considered to be part of the visible height of the line.
5284 h
+= extra_line_spacing
;
5285 while (-it
.current_y
> h
)
5286 move_it_by_lines (&it
, 1);
5288 charpos
= IT_CHARPOS (it
);
5289 bytepos
= IT_BYTEPOS (it
);
5291 bidi_unshelve_cache (itdata
, 0);
5295 struct position pos
;
5297 iarg
= max (iarg
, this_scroll_margin
);
5299 pos
= *vmotion (PT
, -iarg
, w
);
5300 charpos
= pos
.bufpos
;
5301 bytepos
= pos
.bytepos
;
5306 struct position pos
;
5307 int ht
= window_internal_height (w
);
5314 /* Don't let it get into the margin at either top or bottom. */
5315 iarg
= max (iarg
, this_scroll_margin
);
5316 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5318 pos
= *vmotion (PT
, - iarg
, w
);
5319 charpos
= pos
.bufpos
;
5320 bytepos
= pos
.bytepos
;
5323 /* Set the new window start. */
5324 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5325 wset_window_end_valid (w
, Qnil
);
5327 w
->optional_new_start
= 1;
5329 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5330 FETCH_BYTE (bytepos
- 1) == '\n');
5332 set_buffer_internal (obuf
);
5336 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5338 doc
: /* Return the height in lines of the text display area of WINDOW.
5339 WINDOW must be a live window and defaults to the selected one.
5341 The returned height does not include the mode line, any header line,
5342 nor any partial-height lines at the bottom of the text area. */)
5343 (Lisp_Object window
)
5345 struct window
*w
= decode_live_window (window
);
5346 int pixel_height
= window_box_height (w
);
5347 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5348 return make_number (line_height
);
5353 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5355 doc
: /* Position point relative to window.
5356 ARG nil means position point at center of window.
5357 Else, ARG specifies vertical position within the window;
5358 zero means top of window, negative means relative to bottom of window. */)
5361 struct window
*w
= XWINDOW (selected_window
);
5365 int this_scroll_margin
;
5368 if (!(BUFFERP (w
->buffer
)
5369 && XBUFFER (w
->buffer
) == current_buffer
))
5370 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5371 when passed below to set_marker_both. */
5372 error ("move-to-window-line called from unrelated buffer");
5374 window
= selected_window
;
5375 start
= marker_position (w
->start
);
5376 if (start
< BEGV
|| start
> ZV
)
5378 int height
= window_internal_height (w
);
5379 Fvertical_motion (make_number (- (height
/ 2)), window
);
5380 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5381 w
->start_at_line_beg
= !NILP (Fbolp ());
5385 Fgoto_char (w
->start
);
5387 lines
= displayed_window_lines (w
);
5390 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5394 XSETFASTINT (arg
, lines
/ 2);
5397 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5400 iarg
= iarg
+ lines
;
5402 #if 0 /* This code would prevent move-to-window-line from moving point
5403 to a place inside the scroll margins (which would cause the
5404 next redisplay to scroll). I wrote this code, but then concluded
5405 it is probably better not to install it. However, it is here
5406 inside #if 0 so as not to lose it. -- rms. */
5408 /* Don't let it get into the margin at either top or bottom. */
5409 iarg
= max (iarg
, this_scroll_margin
);
5410 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5413 arg
= make_number (iarg
);
5416 /* Skip past a partially visible first line. */
5418 XSETINT (arg
, XINT (arg
) + 1);
5420 return Fvertical_motion (arg
, window
);
5425 /***********************************************************************
5426 Window Configuration
5427 ***********************************************************************/
5429 struct save_window_data
5431 struct vectorlike_header header
;
5432 Lisp_Object selected_frame
;
5433 Lisp_Object current_window
;
5434 Lisp_Object current_buffer
;
5435 Lisp_Object minibuf_scroll_window
;
5436 Lisp_Object minibuf_selected_window
;
5437 Lisp_Object root_window
;
5438 Lisp_Object focus_frame
;
5439 /* A vector, each of whose elements is a struct saved_window
5441 Lisp_Object saved_windows
;
5443 /* All fields above are traced by the GC.
5444 From `fame-cols' down, the fields are ignored by the GC. */
5446 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5447 int frame_tool_bar_lines
;
5450 /* This is saved as a Lisp_Vector */
5453 struct vectorlike_header header
;
5455 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5456 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5457 Lisp_Object normal_cols
, normal_lines
;
5458 Lisp_Object hscroll
, min_hscroll
;
5459 Lisp_Object parent
, prev
;
5460 Lisp_Object start_at_line_beg
;
5461 Lisp_Object display_table
;
5462 Lisp_Object left_margin_cols
, right_margin_cols
;
5463 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5464 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5465 Lisp_Object combination_limit
, window_parameters
;
5468 #define SAVED_WINDOW_N(swv,n) \
5469 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5471 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5472 doc
: /* Return t if OBJECT is a window-configuration object. */)
5473 (Lisp_Object object
)
5475 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5478 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5479 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5480 (Lisp_Object config
)
5482 register struct save_window_data
*data
;
5483 struct Lisp_Vector
*saved_windows
;
5485 CHECK_WINDOW_CONFIGURATION (config
);
5487 data
= (struct save_window_data
*) XVECTOR (config
);
5488 saved_windows
= XVECTOR (data
->saved_windows
);
5489 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5492 DEFUN ("set-window-configuration", Fset_window_configuration
,
5493 Sset_window_configuration
, 1, 1, 0,
5494 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5495 CONFIGURATION must be a value previously returned
5496 by `current-window-configuration' (which see).
5497 If CONFIGURATION was made from a frame that is now deleted,
5498 only frame-independent values can be restored. In this case,
5499 the return value is nil. Otherwise the value is t. */)
5500 (Lisp_Object configuration
)
5502 register struct save_window_data
*data
;
5503 struct Lisp_Vector
*saved_windows
;
5504 Lisp_Object new_current_buffer
;
5507 ptrdiff_t old_point
= -1;
5509 CHECK_WINDOW_CONFIGURATION (configuration
);
5511 data
= (struct save_window_data
*) XVECTOR (configuration
);
5512 saved_windows
= XVECTOR (data
->saved_windows
);
5514 new_current_buffer
= data
->current_buffer
;
5515 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5516 new_current_buffer
= Qnil
;
5519 if (XBUFFER (new_current_buffer
) == current_buffer
)
5520 /* The code further down "preserves point" by saving here PT in
5521 old_point and then setting it later back into PT. When the
5522 current-selected-window and the final-selected-window both show
5523 the current buffer, this suffers from the problem that the
5524 current PT is the window-point of the current-selected-window,
5525 while the final PT is the point of the final-selected-window, so
5526 this copy from one PT to the other would end up moving the
5527 window-point of the final-selected-window to the window-point of
5528 the current-selected-window. So we have to be careful which
5529 point of the current-buffer we copy into old_point. */
5530 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5531 && WINDOWP (selected_window
)
5532 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5533 && !EQ (selected_window
, data
->current_window
))
5534 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5538 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5539 point in new_current_buffer as of the last time this buffer was
5540 used. This can be non-deterministic since it can be changed by
5541 things like jit-lock by mere temporary selection of some random
5542 window that happens to show this buffer.
5543 So if possible we want this arbitrary choice of "which point" to
5544 be the one from the to-be-selected-window so as to prevent this
5545 window's cursor from being copied from another window. */
5546 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5547 /* If current_window = selected_window, its point is in BUF_PT. */
5548 && !EQ (selected_window
, data
->current_window
))
5549 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5551 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5554 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5557 /* If f is a dead frame, don't bother rebuilding its window tree.
5558 However, there is other stuff we should still try to do below. */
5559 if (FRAME_LIVE_P (f
))
5562 Lisp_Object dead_windows
= Qnil
;
5563 register Lisp_Object tem
, par
, pers
;
5564 register struct window
*w
;
5565 register struct saved_window
*p
;
5566 struct window
*root_window
;
5567 struct window
**leaf_windows
;
5572 /* If the frame has been resized since this window configuration was
5573 made, we change the frame to the size specified in the
5574 configuration, restore the configuration, and then resize it
5575 back. We keep track of the prevailing height in these variables. */
5576 int previous_frame_lines
= FRAME_LINES (f
);
5577 int previous_frame_cols
= FRAME_COLS (f
);
5578 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5579 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5581 /* Don't do this within the main loop below: This may call Lisp
5582 code and is thus potentially unsafe while input is blocked. */
5583 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5585 p
= SAVED_WINDOW_N (saved_windows
, k
);
5587 w
= XWINDOW (window
);
5588 if (!NILP (w
->buffer
)
5589 && !EQ (w
->buffer
, p
->buffer
)
5590 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5591 /* If a window we restore gets another buffer, record the
5592 window's old buffer. */
5593 call1 (Qrecord_window_buffer
, window
);
5596 /* The mouse highlighting code could get screwed up
5597 if it runs during this. */
5600 if (data
->frame_lines
!= previous_frame_lines
5601 || data
->frame_cols
!= previous_frame_cols
)
5602 change_frame_size (f
, data
->frame_lines
,
5603 data
->frame_cols
, 0, 0, 0);
5604 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5605 if (data
->frame_menu_bar_lines
5606 != previous_frame_menu_bar_lines
)
5607 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5609 #ifdef HAVE_WINDOW_SYSTEM
5610 if (data
->frame_tool_bar_lines
5611 != previous_frame_tool_bar_lines
)
5612 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5617 /* "Swap out" point from the selected window's buffer
5618 into the window itself. (Normally the pointm of the selected
5619 window holds garbage.) We do this now, before
5620 restoring the window contents, and prevent it from
5621 being done later on when we select a new window. */
5622 if (! NILP (XWINDOW (selected_window
)->buffer
))
5624 w
= XWINDOW (selected_window
);
5625 set_marker_both (w
->pointm
,
5627 BUF_PT (XBUFFER (w
->buffer
)),
5628 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5631 windows_or_buffers_changed
++;
5632 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5634 /* Problem: Freeing all matrices and later allocating them again
5635 is a serious redisplay flickering problem. What we would
5636 really like to do is to free only those matrices not reused
5638 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5639 leaf_windows
= alloca (count_windows (root_window
)
5640 * sizeof *leaf_windows
);
5641 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5644 Mark all windows now on frame as "deleted".
5645 Restoring the new configuration "undeletes" any that are in it.
5647 Save their current buffers in their height fields, since we may
5648 need it later, if a buffer saved in the configuration is now
5650 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5652 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5654 p
= SAVED_WINDOW_N (saved_windows
, k
);
5656 w
= XWINDOW (window
);
5657 wset_next (w
, Qnil
);
5659 if (!NILP (p
->parent
))
5661 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5663 wset_parent (w
, Qnil
);
5665 if (!NILP (p
->prev
))
5668 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5669 wset_next (XWINDOW (w
->prev
), p
->window
);
5673 wset_prev (w
, Qnil
);
5674 if (!NILP (w
->parent
))
5676 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5678 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5679 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5683 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5684 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5689 /* If we squirreled away the buffer in the window's height,
5691 if (BUFFERP (w
->total_lines
))
5692 wset_buffer (w
, w
->total_lines
);
5693 wset_left_col (w
, p
->left_col
);
5694 wset_top_line (w
, p
->top_line
);
5695 wset_total_cols (w
, p
->total_cols
);
5696 wset_total_lines (w
, p
->total_lines
);
5697 wset_normal_cols (w
, p
->normal_cols
);
5698 wset_normal_lines (w
, p
->normal_lines
);
5699 w
->hscroll
= XFASTINT (p
->hscroll
);
5700 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5701 wset_display_table (w
, p
->display_table
);
5702 wset_left_margin_cols (w
, p
->left_margin_cols
);
5703 wset_right_margin_cols (w
, p
->right_margin_cols
);
5704 wset_left_fringe_width (w
, p
->left_fringe_width
);
5705 wset_right_fringe_width (w
, p
->right_fringe_width
);
5706 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5707 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5708 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5709 wset_dedicated (w
, p
->dedicated
);
5710 wset_combination_limit (w
, p
->combination_limit
);
5711 /* Restore any window parameters that have been saved.
5712 Parameters that have not been saved are left alone. */
5713 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5718 if (NILP (XCDR (pers
)))
5720 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5721 if (CONSP (par
) && !NILP (XCDR (par
)))
5722 /* Reset a parameter to nil if and only if it
5723 has a non-nil association. Don't make new
5725 Fsetcdr (par
, Qnil
);
5728 /* Always restore a non-nil value. */
5729 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5733 w
->last_modified
= 0;
5734 w
->last_overlay_modified
= 0;
5736 /* Reinstall the saved buffer and pointers into it. */
5737 if (NILP (p
->buffer
))
5738 /* An internal window. */
5739 wset_buffer (w
, p
->buffer
);
5740 else if (BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5741 /* If saved buffer is alive, install it. */
5743 wset_buffer (w
, p
->buffer
);
5744 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5745 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5746 set_marker_restricted (w
->pointm
, p
->pointm
,
5748 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5749 p
->mark
, w
->buffer
);
5751 /* As documented in Fcurrent_window_configuration, don't
5752 restore the location of point in the buffer which was
5753 current when the window configuration was recorded. */
5754 if (!EQ (p
->buffer
, new_current_buffer
)
5755 && XBUFFER (p
->buffer
) == current_buffer
)
5756 Fgoto_char (w
->pointm
);
5758 else if (!NILP (w
->buffer
)
5759 && BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
5760 /* Keep window's old buffer; make sure the markers are
5763 /* Set window markers at start of visible range. */
5764 if (XMARKER (w
->start
)->buffer
== 0)
5765 set_marker_restricted (w
->start
, make_number (0),
5767 if (XMARKER (w
->pointm
)->buffer
== 0)
5768 set_marker_restricted_both
5769 (w
->pointm
, w
->buffer
,
5770 BUF_PT (XBUFFER (w
->buffer
)),
5771 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5772 w
->start_at_line_beg
= 1;
5775 /* Window has no live buffer, get one. */
5777 /* Get the buffer via other_buffer_safely in order to
5778 avoid showing an unimportant buffer and, if necessary, to
5779 recreate *scratch* in the course (part of Juanma's bs-show
5780 scenario from March 2011). */
5781 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5782 /* This will set the markers to beginning of visible
5784 set_marker_restricted (w
->start
,
5785 make_number (0), w
->buffer
);
5786 set_marker_restricted (w
->pointm
,
5787 make_number (0), w
->buffer
);
5788 w
->start_at_line_beg
= 1;
5789 if (!NILP (w
->dedicated
))
5790 /* Record this window as dead. */
5791 dead_windows
= Fcons (window
, dead_windows
);
5792 /* Make sure window is no more dedicated. */
5793 wset_dedicated (w
, Qnil
);
5797 fset_root_window (f
, data
->root_window
);
5798 /* Arrange *not* to restore point in the buffer that was
5799 current when the window configuration was saved. */
5800 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5801 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5802 make_number (old_point
),
5803 XWINDOW (data
->current_window
)->buffer
);
5805 /* In the following call to `select-window', prevent "swapping out
5806 point" in the old selected window using the buffer that has
5807 been restored into it. We already swapped out that point from
5808 that window's old buffer. */
5809 select_window (data
->current_window
, Qnil
, 1);
5810 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5813 if (NILP (data
->focus_frame
)
5814 || (FRAMEP (data
->focus_frame
)
5815 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5816 Fredirect_frame_focus (frame
, data
->focus_frame
);
5818 /* Set the screen height to the value it had before this function. */
5819 if (previous_frame_lines
!= FRAME_LINES (f
)
5820 || previous_frame_cols
!= FRAME_COLS (f
))
5821 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5823 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5824 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5825 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5827 #ifdef HAVE_WINDOW_SYSTEM
5828 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5829 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5834 /* Now, free glyph matrices in windows that were not reused. */
5835 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5837 if (NILP (leaf_windows
[i
]->buffer
))
5839 /* Assert it's not reused as a combination. */
5840 eassert (NILP (leaf_windows
[i
]->hchild
)
5841 && NILP (leaf_windows
[i
]->vchild
));
5842 free_window_matrices (leaf_windows
[i
]);
5844 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5851 /* Scan dead buffer windows. */
5852 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5854 window
= XCAR (dead_windows
);
5855 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5856 delete_deletable_window (window
);
5859 /* Fselect_window will have made f the selected frame, so we
5860 reselect the proper frame here. Fhandle_switch_frame will change the
5861 selected window too, but that doesn't make the call to
5862 Fselect_window above totally superfluous; it still sets f's
5864 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5865 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5867 run_window_configuration_change_hook (f
);
5870 if (!NILP (new_current_buffer
))
5872 Fset_buffer (new_current_buffer
);
5873 /* If the new current buffer doesn't appear in the selected
5874 window, go to its old point (see bug#12208). */
5875 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5876 Fgoto_char (make_number (old_point
));
5879 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5880 minibuf_selected_window
= data
->minibuf_selected_window
;
5882 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5886 /* Recursively delete all child windows reachable via the next, vchild,
5887 and hchild slots of WINDOW. */
5889 delete_all_child_windows (Lisp_Object window
)
5891 register struct window
*w
;
5893 w
= XWINDOW (window
);
5895 if (!NILP (w
->next
))
5896 /* Delete WINDOW's siblings (we traverse postorderly). */
5897 delete_all_child_windows (w
->next
);
5899 /* See Fset_window_configuration for excuse. */
5900 wset_total_lines (w
, w
->buffer
);
5902 if (!NILP (w
->vchild
))
5904 delete_all_child_windows (w
->vchild
);
5905 wset_vchild (w
, Qnil
);
5907 else if (!NILP (w
->hchild
))
5909 delete_all_child_windows (w
->hchild
);
5910 wset_hchild (w
, Qnil
);
5912 else if (!NILP (w
->buffer
))
5915 unchain_marker (XMARKER (w
->pointm
));
5916 unchain_marker (XMARKER (w
->start
));
5917 wset_buffer (w
, Qnil
);
5920 Vwindow_list
= Qnil
;
5924 count_windows (register struct window
*window
)
5926 register int count
= 1;
5927 if (!NILP (window
->next
))
5928 count
+= count_windows (XWINDOW (window
->next
));
5929 if (!NILP (window
->vchild
))
5930 count
+= count_windows (XWINDOW (window
->vchild
));
5931 if (!NILP (window
->hchild
))
5932 count
+= count_windows (XWINDOW (window
->hchild
));
5937 /* Fill vector FLAT with leaf windows under W, starting at index I.
5938 Value is last index + 1. */
5940 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5944 if (!NILP (w
->hchild
))
5945 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5946 else if (!NILP (w
->vchild
))
5947 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5951 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5958 /* Return a pointer to the glyph W's physical cursor is on. Value is
5959 null if W's current matrix is invalid, so that no meaningful glyph
5962 get_phys_cursor_glyph (struct window
*w
)
5964 struct glyph_row
*row
;
5965 struct glyph
*glyph
;
5966 int hpos
= w
->phys_cursor
.hpos
;
5968 if (!(w
->phys_cursor
.vpos
>= 0
5969 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5972 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5973 if (!row
->enabled_p
)
5978 /* When the window is hscrolled, cursor hpos can legitimately be
5979 out of bounds, but we draw the cursor at the corresponding
5980 window margin in that case. */
5981 if (!row
->reversed_p
&& hpos
< 0)
5983 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
5984 hpos
= row
->used
[TEXT_AREA
] - 1;
5987 if (row
->used
[TEXT_AREA
] > hpos
5989 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
5998 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6000 register struct saved_window
*p
;
6001 register struct window
*w
;
6002 register Lisp_Object tem
, pers
, par
;
6004 for (;!NILP (window
); window
= w
->next
)
6006 p
= SAVED_WINDOW_N (vector
, i
);
6007 w
= XWINDOW (window
);
6009 wset_temslot (w
, make_number (i
)); i
++;
6011 p
->buffer
= w
->buffer
;
6012 p
->left_col
= w
->left_col
;
6013 p
->top_line
= w
->top_line
;
6014 p
->total_cols
= w
->total_cols
;
6015 p
->total_lines
= w
->total_lines
;
6016 p
->normal_cols
= w
->normal_cols
;
6017 p
->normal_lines
= w
->normal_lines
;
6018 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6019 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6020 p
->display_table
= w
->display_table
;
6021 p
->left_margin_cols
= w
->left_margin_cols
;
6022 p
->right_margin_cols
= w
->right_margin_cols
;
6023 p
->left_fringe_width
= w
->left_fringe_width
;
6024 p
->right_fringe_width
= w
->right_fringe_width
;
6025 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6026 p
->scroll_bar_width
= w
->scroll_bar_width
;
6027 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6028 p
->dedicated
= w
->dedicated
;
6029 p
->combination_limit
= w
->combination_limit
;
6030 p
->window_parameters
= Qnil
;
6032 if (!NILP (Vwindow_persistent_parameters
))
6034 /* Run cycle detection on Vwindow_persistent_parameters. */
6035 Lisp_Object tortoise
, hare
;
6037 hare
= tortoise
= Vwindow_persistent_parameters
;
6038 while (CONSP (hare
))
6045 tortoise
= XCDR (tortoise
);
6047 if (EQ (hare
, tortoise
))
6048 /* Reset Vwindow_persistent_parameters to Qnil. */
6050 Vwindow_persistent_parameters
= Qnil
;
6055 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6059 /* Save values for persistent window parameters. */
6060 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6062 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6064 /* If the window has no value for the parameter,
6066 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6067 p
->window_parameters
);
6069 /* If the window has a value for the parameter,
6071 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6073 p
->window_parameters
);
6078 if (!NILP (w
->buffer
))
6080 /* Save w's value of point in the window configuration. If w
6081 is the selected window, then get the value of point from
6082 the buffer; pointm is garbage in the selected window. */
6083 if (EQ (window
, selected_window
))
6084 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6085 BUF_PT (XBUFFER (w
->buffer
)),
6086 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6088 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6089 XMARKER (p
->pointm
)->insertion_type
6090 = !NILP (Vwindow_point_insertion_type
);
6092 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6093 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6095 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6096 p
->mark
= Fcopy_marker (tem
, Qnil
);
6103 p
->start_at_line_beg
= Qnil
;
6106 if (NILP (w
->parent
))
6109 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6114 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6116 if (!NILP (w
->vchild
))
6117 i
= save_window_save (w
->vchild
, vector
, i
);
6118 if (!NILP (w
->hchild
))
6119 i
= save_window_save (w
->hchild
, vector
, i
);
6125 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6126 Scurrent_window_configuration
, 0, 1, 0,
6127 doc
: /* Return an object representing the current window configuration of FRAME.
6128 If FRAME is nil or omitted, use the selected frame.
6129 This describes the number of windows, their sizes and current buffers,
6130 and for each displayed buffer, where display starts, and the positions of
6131 point and mark. An exception is made for point in the current buffer:
6132 its value is -not- saved.
6133 This also records the currently selected frame, and FRAME's focus
6134 redirection (see `redirect-frame-focus'). The variable
6135 `window-persistent-parameters' specifies which window parameters are
6136 saved by this function. */)
6139 register Lisp_Object tem
;
6140 register int n_windows
;
6141 register struct save_window_data
*data
;
6143 struct frame
*f
= decode_live_frame (frame
);
6145 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6146 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6147 PVEC_WINDOW_CONFIGURATION
);
6149 data
->frame_cols
= FRAME_COLS (f
);
6150 data
->frame_lines
= FRAME_LINES (f
);
6151 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6152 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6153 data
->selected_frame
= selected_frame
;
6154 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6155 XSETBUFFER (data
->current_buffer
, current_buffer
);
6156 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6157 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6158 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6159 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6160 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6161 data
->saved_windows
= tem
;
6162 for (i
= 0; i
< n_windows
; i
++)
6164 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6165 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6166 XSETWINDOW_CONFIGURATION (tem
, data
);
6170 /***********************************************************************
6172 ***********************************************************************/
6174 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6176 doc
: /* Set width of marginal areas of window WINDOW.
6177 WINDOW must be a live window and defaults to the selected one.
6179 Second arg LEFT-WIDTH specifies the number of character cells to
6180 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6181 does the same for the right marginal area. A nil width parameter
6182 means no margin. */)
6183 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6185 struct window
*w
= decode_live_window (window
);
6187 /* Translate negative or zero widths to nil.
6188 Margins that are too wide have to be checked elsewhere. */
6190 if (!NILP (left_width
))
6192 CHECK_NUMBER (left_width
);
6193 if (XINT (left_width
) <= 0)
6197 if (!NILP (right_width
))
6199 CHECK_NUMBER (right_width
);
6200 if (XINT (right_width
) <= 0)
6204 if (!EQ (w
->left_margin_cols
, left_width
)
6205 || !EQ (w
->right_margin_cols
, right_width
))
6207 wset_left_margin_cols (w
, left_width
);
6208 wset_right_margin_cols (w
, right_width
);
6210 adjust_window_margins (w
);
6212 ++windows_or_buffers_changed
;
6213 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6220 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6222 doc
: /* Get width of marginal areas of window WINDOW.
6223 WINDOW must be a live window and defaults to the selected one.
6225 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6226 If a marginal area does not exist, its width will be returned
6228 (Lisp_Object window
)
6230 struct window
*w
= decode_live_window (window
);
6231 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6236 /***********************************************************************
6238 ***********************************************************************/
6240 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6242 doc
: /* Set the fringe widths of window WINDOW.
6243 WINDOW must be a live window and defaults to the selected one.
6245 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6246 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6247 fringe width. If a fringe width arg is nil, that means to use the
6248 frame's default fringe width. Default fringe widths can be set with
6249 the command `set-fringe-style'.
6250 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6251 outside of the display margins. By default, fringes are drawn between
6252 display marginal areas and the text area. */)
6253 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6255 struct window
*w
= decode_live_window (window
);
6256 int outside
= !NILP (outside_margins
);
6258 if (!NILP (left_width
))
6259 CHECK_NATNUM (left_width
);
6260 if (!NILP (right_width
))
6261 CHECK_NATNUM (right_width
);
6263 /* Do nothing on a tty. */
6264 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6265 && (!EQ (w
->left_fringe_width
, left_width
)
6266 || !EQ (w
->right_fringe_width
, right_width
)
6267 || w
->fringes_outside_margins
!= outside
))
6269 wset_left_fringe_width (w
, left_width
);
6270 wset_right_fringe_width (w
, right_width
);
6271 w
->fringes_outside_margins
= outside
;
6273 adjust_window_margins (w
);
6275 clear_glyph_matrix (w
->current_matrix
);
6276 wset_window_end_valid (w
, Qnil
);
6278 ++windows_or_buffers_changed
;
6279 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6286 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6288 doc
: /* Get width of fringes of window WINDOW.
6289 WINDOW must be a live window and defaults to the selected one.
6291 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6292 (Lisp_Object window
)
6294 struct window
*w
= decode_live_window (window
);
6296 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6297 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6298 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6303 /***********************************************************************
6305 ***********************************************************************/
6307 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6308 Sset_window_scroll_bars
, 2, 4, 0,
6309 doc
: /* Set width and type of scroll bars of window WINDOW.
6310 WINDOW must be a live window and defaults to the selected one.
6312 Second parameter WIDTH specifies the pixel width for the scroll bar;
6313 this is automatically adjusted to a multiple of the frame column width.
6314 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6315 bar: left, right, or nil.
6316 If WIDTH is nil, use the frame's scroll-bar width.
6317 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6318 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6319 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6321 struct window
*w
= decode_live_window (window
);
6325 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6327 if (XINT (width
) == 0)
6328 vertical_type
= Qnil
;
6331 if (!(NILP (vertical_type
)
6332 || EQ (vertical_type
, Qleft
)
6333 || EQ (vertical_type
, Qright
)
6334 || EQ (vertical_type
, Qt
)))
6335 error ("Invalid type of vertical scroll bar");
6337 if (!EQ (w
->scroll_bar_width
, width
)
6338 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6340 wset_scroll_bar_width (w
, width
);
6341 wset_vertical_scroll_bar_type (w
, vertical_type
);
6343 adjust_window_margins (w
);
6345 clear_glyph_matrix (w
->current_matrix
);
6346 wset_window_end_valid (w
, Qnil
);
6348 ++windows_or_buffers_changed
;
6349 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6356 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6358 doc
: /* Get width and type of scroll bars of window WINDOW.
6359 WINDOW must be a live window and defaults to the selected one.
6361 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6362 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6364 (Lisp_Object window
)
6366 struct window
*w
= decode_live_window (window
);
6368 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6369 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6370 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6371 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6372 w
->vertical_scroll_bar_type
, Qnil
);
6377 /***********************************************************************
6379 ***********************************************************************/
6381 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6382 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6383 If WINDOW is omitted or nil, it defaults to the selected window.
6384 Normally, value is a multiple of the canonical character height of WINDOW;
6385 optional second arg PIXELS-P means value is measured in pixels. */)
6386 (Lisp_Object window
, Lisp_Object pixels_p
)
6389 struct window
*w
= decode_live_window (window
);
6390 struct frame
*f
= XFRAME (w
->frame
);
6392 if (FRAME_WINDOW_P (f
))
6393 result
= (NILP (pixels_p
)
6394 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6395 : make_number (-w
->vscroll
));
6397 result
= make_number (0);
6402 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6404 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6405 WINDOW nil means use the selected window. Normally, VSCROLL is a
6406 non-negative multiple of the canonical character height of WINDOW;
6407 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6408 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6409 corresponds to an integral number of pixels. The return value is the
6410 result of this rounding.
6411 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6412 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6414 struct window
*w
= decode_live_window (window
);
6415 struct frame
*f
= XFRAME (w
->frame
);
6417 CHECK_NUMBER_OR_FLOAT (vscroll
);
6419 if (FRAME_WINDOW_P (f
))
6421 int old_dy
= w
->vscroll
;
6423 w
->vscroll
= - (NILP (pixels_p
)
6424 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6425 : XFLOATINT (vscroll
));
6426 w
->vscroll
= min (w
->vscroll
, 0);
6428 if (w
->vscroll
!= old_dy
)
6430 /* Adjust glyph matrix of the frame if the virtual display
6431 area becomes larger than before. */
6432 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6435 /* Prevent redisplay shortcuts. */
6436 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6440 return Fwindow_vscroll (window
, pixels_p
);
6444 /* Call FN for all leaf windows on frame F. FN is called with the
6445 first argument being a pointer to the leaf window, and with
6446 additional argument USER_DATA. Stops when FN returns 0. */
6449 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6452 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6453 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6454 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6458 /* Helper function for foreach_window. Call FN for all leaf windows
6459 reachable from W. FN is called with the first argument being a
6460 pointer to the leaf window, and with additional argument USER_DATA.
6461 Stop when FN returns 0. Value is 0 if stopped by FN. */
6464 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6468 for (cont
= 1; w
&& cont
;)
6470 if (!NILP (w
->hchild
))
6471 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6472 else if (!NILP (w
->vchild
))
6473 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6475 cont
= fn (w
, user_data
);
6477 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6484 /* Freeze or unfreeze the window start of W unless it is a
6485 mini-window or the selected window. FREEZE_P non-null means freeze
6486 the window start. */
6489 freeze_window_start (struct window
*w
, void *freeze_p
)
6491 if (MINI_WINDOW_P (w
)
6492 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6493 && (w
== XWINDOW (selected_window
)
6494 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6495 && ! NILP (Vminibuf_scroll_window
)
6496 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6499 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6504 /* Freeze or unfreeze the window starts of all leaf windows on frame
6505 F, except the selected window and a mini-window. FREEZE_P non-zero
6506 means freeze the window start. */
6509 freeze_window_starts (struct frame
*f
, int freeze_p
)
6511 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6515 /***********************************************************************
6517 ***********************************************************************/
6519 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6520 describe the same state of affairs. This is used by Fequal.
6522 IGNORE_POSITIONS means ignore non-matching scroll positions
6525 This ignores a couple of things like the dedication status of
6526 window, combination_limit and the like. This might have to be
6530 compare_window_configurations (Lisp_Object configuration1
,
6531 Lisp_Object configuration2
,
6532 bool ignore_positions
)
6534 register struct save_window_data
*d1
, *d2
;
6535 struct Lisp_Vector
*sws1
, *sws2
;
6538 CHECK_WINDOW_CONFIGURATION (configuration1
);
6539 CHECK_WINDOW_CONFIGURATION (configuration2
);
6541 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6542 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6543 sws1
= XVECTOR (d1
->saved_windows
);
6544 sws2
= XVECTOR (d2
->saved_windows
);
6546 /* Frame settings must match. */
6547 if (d1
->frame_cols
!= d2
->frame_cols
6548 || d1
->frame_lines
!= d2
->frame_lines
6549 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6550 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6551 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6552 || (!ignore_positions
6553 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6554 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6555 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6556 /* Verify that the two configurations have the same number of windows. */
6557 || sws1
->header
.size
!= sws2
->header
.size
)
6560 for (i
= 0; i
< sws1
->header
.size
; i
++)
6562 struct saved_window
*sw1
, *sw2
;
6564 sw1
= SAVED_WINDOW_N (sws1
, i
);
6565 sw2
= SAVED_WINDOW_N (sws2
, i
);
6568 /* The "current" windows in the two configurations must
6569 correspond to each other. */
6570 EQ (d1
->current_window
, sw1
->window
)
6571 != EQ (d2
->current_window
, sw2
->window
)
6572 /* Windows' buffers must match. */
6573 || !EQ (sw1
->buffer
, sw2
->buffer
)
6574 || !EQ (sw1
->left_col
, sw2
->left_col
)
6575 || !EQ (sw1
->top_line
, sw2
->top_line
)
6576 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6577 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6578 || !EQ (sw1
->display_table
, sw2
->display_table
)
6579 /* The next two disjuncts check the window structure for
6581 || !EQ (sw1
->parent
, sw2
->parent
)
6582 || !EQ (sw1
->prev
, sw2
->prev
)
6583 || (!ignore_positions
6584 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6585 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6586 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6587 || NILP (Fequal (sw1
->start
, sw2
->start
))
6588 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6589 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6590 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6591 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6592 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6593 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6594 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6595 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6596 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6603 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6604 Scompare_window_configurations
, 2, 2, 0,
6605 doc
: /* Compare two window configurations as regards the structure of windows.
6606 This function ignores details such as the values of point and mark
6607 and scrolling positions. */)
6608 (Lisp_Object x
, Lisp_Object y
)
6610 if (compare_window_configurations (x
, y
, 1))
6616 init_window_once (void)
6618 struct frame
*f
= make_initial_frame ();
6619 XSETFRAME (selected_frame
, f
);
6620 Vterminal_frame
= selected_frame
;
6621 minibuf_window
= f
->minibuffer_window
;
6622 selected_window
= f
->selected_window
;
6623 last_nonminibuf_frame
= f
;
6625 window_initialized
= 1;
6631 Vwindow_list
= Qnil
;
6635 syms_of_window (void)
6637 DEFSYM (Qscroll_up
, "scroll-up");
6638 DEFSYM (Qscroll_down
, "scroll-down");
6639 DEFSYM (Qscroll_command
, "scroll-command");
6641 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6642 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6644 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6645 DEFSYM (Qwindowp
, "windowp");
6646 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6647 DEFSYM (Qwindow_live_p
, "window-live-p");
6648 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6649 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6650 DEFSYM (Qdelete_window
, "delete-window");
6651 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6652 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6653 DEFSYM (Qsafe
, "safe");
6654 DEFSYM (Qdisplay_buffer
, "display-buffer");
6655 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6656 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6657 DEFSYM (Qget_mru_window
, "get-mru-window");
6658 DEFSYM (Qwindow_size
, "window-size");
6659 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6660 DEFSYM (Qabove
, "above");
6661 DEFSYM (Qbelow
, "below");
6662 DEFSYM (Qclone_of
, "clone-of");
6664 staticpro (&Vwindow_list
);
6666 minibuf_selected_window
= Qnil
;
6667 staticpro (&minibuf_selected_window
);
6669 window_scroll_pixel_based_preserve_x
= -1;
6670 window_scroll_pixel_based_preserve_y
= -1;
6671 window_scroll_preserve_hpos
= -1;
6672 window_scroll_preserve_vpos
= -1;
6674 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6675 doc
: /* Non-nil means call as function to display a help buffer.
6676 The function is called with one argument, the buffer to be displayed.
6677 Used by `with-output-to-temp-buffer'.
6678 If this function is used, then it must do the entire job of showing
6679 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6680 Vtemp_buffer_show_function
= Qnil
;
6682 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6683 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6684 Vminibuf_scroll_window
= Qnil
;
6686 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6687 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6688 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6689 is displayed in the `mode-line' face. */);
6690 mode_line_in_non_selected_windows
= 1;
6692 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6693 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6694 Vother_window_scroll_buffer
= Qnil
;
6696 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6697 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6698 auto_window_vscroll_p
= 1;
6700 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6701 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6702 next_screen_context_lines
= 2;
6704 DEFVAR_LISP ("scroll-preserve-screen-position",
6705 Vscroll_preserve_screen_position
,
6706 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6707 A value of nil means point does not keep its screen position except
6708 at the scroll margin or window boundary respectively.
6709 A value of t means point keeps its screen position if the scroll
6710 command moved it vertically out of the window, e.g. when scrolling
6712 Any other value means point always keeps its screen position.
6713 Scroll commands should have the `scroll-command' property
6714 on their symbols to be controlled by this variable. */);
6715 Vscroll_preserve_screen_position
= Qnil
;
6717 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6718 doc
: /* Type of marker to use for `window-point'. */);
6719 Vwindow_point_insertion_type
= Qnil
;
6721 DEFVAR_LISP ("window-configuration-change-hook",
6722 Vwindow_configuration_change_hook
,
6723 doc
: /* Functions to call when window configuration changes.
6724 The buffer-local part is run once per window, with the relevant window
6725 selected; while the global part is run only once for the modified frame,
6726 with the relevant frame selected. */);
6727 Vwindow_configuration_change_hook
= Qnil
;
6729 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6730 doc
: /* Non-nil means `recenter' redraws entire frame.
6731 If this option is non-nil, then the `recenter' command with a nil
6732 argument will redraw the entire frame; the special value `tty' causes
6733 the frame to be redrawn only if it is a tty frame. */);
6734 Vrecenter_redisplay
= Qtty
;
6736 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6737 doc
: /* If t, resize window combinations proportionally.
6738 If this variable is nil, splitting a window gets the entire screen space
6739 for displaying the new window from the window to split. Deleting and
6740 resizing a window preferably resizes one adjacent window only.
6742 If this variable is t, splitting a window tries to get the space
6743 proportionally from all windows in the same combination. This also
6744 allows to split a window that is otherwise too small or of fixed size.
6745 Resizing and deleting a window proportionally resize all windows in the
6748 Other values are reserved for future use.
6750 This variable takes no effect if `window-combination-limit' is non-nil. */);
6751 Vwindow_combination_resize
= Qnil
;
6753 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6754 doc
: /* If non-nil, splitting a window makes a new parent window.
6755 The following values are recognized:
6757 nil means splitting a window will create a new parent window only if the
6758 window has no parent window or the window shall become part of a
6759 combination orthogonal to the one it is part of.
6761 `window-size' means that splitting a window for displaying a buffer
6762 makes a new parent window provided `display-buffer' is supposed to
6763 explicitly set the window's size due to the presence of a
6764 `window-height' or `window-width' entry in the alist used by
6765 `display-buffer'. Otherwise, this value is handled like nil.
6767 `temp-buffer' means that splitting a window for displaying a temporary
6768 buffer always makes a new parent window. Otherwise, this value is
6771 `display-buffer' means that splitting a window for displaying a buffer
6772 always makes a new parent window. Since temporary buffers are
6773 displayed by the function `display-buffer', this value is stronger
6774 than `temp-buffer'. Splitting a window for other purpose makes a
6775 new parent window only if needed.
6777 t means that splitting a window always creates a new parent window. If
6778 all splits behave this way, each frame's window tree is a binary
6779 tree and every window but the frame's root window has exactly one
6782 Other values are reserved for future use. */);
6783 Vwindow_combination_limit
= Qwindow_size
;
6785 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6786 doc
: /* Alist of persistent window parameters.
6787 This alist specifies which window parameters shall get saved by
6788 `current-window-configuration' and `window-state-get' and subsequently
6789 restored to their previous values by `set-window-configuration' and
6792 The car of each entry of this alist is the symbol specifying the
6793 parameter. The cdr is one of the following:
6795 nil means the parameter is neither saved by `window-state-get' nor by
6796 `current-window-configuration'.
6798 t means the parameter is saved by `current-window-configuration' and,
6799 provided its WRITABLE argument is nil, by `window-state-get'.
6801 The symbol `writable' means the parameter is saved unconditionally by
6802 both `current-window-configuration' and `window-state-get'. Do not use
6803 this value for parameters without read syntax (like windows or frames).
6805 Parameters not saved by `current-window-configuration' or
6806 `window-state-get' are left alone by `set-window-configuration'
6807 respectively are not installed by `window-state-put'. */);
6808 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6810 defsubr (&Sselected_window
);
6811 defsubr (&Sminibuffer_window
);
6812 defsubr (&Swindow_minibuffer_p
);
6813 defsubr (&Swindowp
);
6814 defsubr (&Swindow_valid_p
);
6815 defsubr (&Swindow_live_p
);
6816 defsubr (&Swindow_frame
);
6817 defsubr (&Sframe_root_window
);
6818 defsubr (&Sframe_first_window
);
6819 defsubr (&Sframe_selected_window
);
6820 defsubr (&Sset_frame_selected_window
);
6821 defsubr (&Spos_visible_in_window_p
);
6822 defsubr (&Swindow_line_height
);
6823 defsubr (&Swindow_buffer
);
6824 defsubr (&Swindow_parent
);
6825 defsubr (&Swindow_top_child
);
6826 defsubr (&Swindow_left_child
);
6827 defsubr (&Swindow_next_sibling
);
6828 defsubr (&Swindow_prev_sibling
);
6829 defsubr (&Swindow_combination_limit
);
6830 defsubr (&Sset_window_combination_limit
);
6831 defsubr (&Swindow_use_time
);
6832 defsubr (&Swindow_top_line
);
6833 defsubr (&Swindow_left_column
);
6834 defsubr (&Swindow_total_height
);
6835 defsubr (&Swindow_total_width
);
6836 defsubr (&Swindow_normal_size
);
6837 defsubr (&Swindow_new_total
);
6838 defsubr (&Swindow_new_normal
);
6839 defsubr (&Sset_window_new_total
);
6840 defsubr (&Sset_window_new_normal
);
6841 defsubr (&Swindow_resize_apply
);
6842 defsubr (&Swindow_body_height
);
6843 defsubr (&Swindow_body_width
);
6844 defsubr (&Swindow_hscroll
);
6845 defsubr (&Sset_window_hscroll
);
6846 defsubr (&Swindow_redisplay_end_trigger
);
6847 defsubr (&Sset_window_redisplay_end_trigger
);
6848 defsubr (&Swindow_edges
);
6849 defsubr (&Swindow_pixel_edges
);
6850 defsubr (&Swindow_absolute_pixel_edges
);
6851 defsubr (&Swindow_inside_edges
);
6852 defsubr (&Swindow_inside_pixel_edges
);
6853 defsubr (&Swindow_inside_absolute_pixel_edges
);
6854 defsubr (&Scoordinates_in_window_p
);
6855 defsubr (&Swindow_at
);
6856 defsubr (&Swindow_point
);
6857 defsubr (&Swindow_start
);
6858 defsubr (&Swindow_end
);
6859 defsubr (&Sset_window_point
);
6860 defsubr (&Sset_window_start
);
6861 defsubr (&Swindow_dedicated_p
);
6862 defsubr (&Sset_window_dedicated_p
);
6863 defsubr (&Swindow_display_table
);
6864 defsubr (&Sset_window_display_table
);
6865 defsubr (&Snext_window
);
6866 defsubr (&Sprevious_window
);
6867 defsubr (&Sget_buffer_window
);
6868 defsubr (&Sdelete_other_windows_internal
);
6869 defsubr (&Sdelete_window_internal
);
6870 defsubr (&Sresize_mini_window_internal
);
6871 defsubr (&Sset_window_buffer
);
6872 defsubr (&Srun_window_configuration_change_hook
);
6873 defsubr (&Sselect_window
);
6874 defsubr (&Sforce_window_update
);
6875 defsubr (&Ssplit_window_internal
);
6876 defsubr (&Sscroll_up
);
6877 defsubr (&Sscroll_down
);
6878 defsubr (&Sscroll_left
);
6879 defsubr (&Sscroll_right
);
6880 defsubr (&Sother_window_for_scrolling
);
6881 defsubr (&Sscroll_other_window
);
6882 defsubr (&Sminibuffer_selected_window
);
6883 defsubr (&Srecenter
);
6884 defsubr (&Swindow_text_height
);
6885 defsubr (&Smove_to_window_line
);
6886 defsubr (&Swindow_configuration_p
);
6887 defsubr (&Swindow_configuration_frame
);
6888 defsubr (&Sset_window_configuration
);
6889 defsubr (&Scurrent_window_configuration
);
6890 defsubr (&Sset_window_margins
);
6891 defsubr (&Swindow_margins
);
6892 defsubr (&Sset_window_fringes
);
6893 defsubr (&Swindow_fringes
);
6894 defsubr (&Sset_window_scroll_bars
);
6895 defsubr (&Swindow_scroll_bars
);
6896 defsubr (&Swindow_vscroll
);
6897 defsubr (&Sset_window_vscroll
);
6898 defsubr (&Scompare_window_configurations
);
6899 defsubr (&Swindow_list
);
6900 defsubr (&Swindow_list_1
);
6901 defsubr (&Swindow_prev_buffers
);
6902 defsubr (&Sset_window_prev_buffers
);
6903 defsubr (&Swindow_next_buffers
);
6904 defsubr (&Sset_window_next_buffers
);
6905 defsubr (&Swindow_parameters
);
6906 defsubr (&Swindow_parameter
);
6907 defsubr (&Sset_window_parameter
);
6911 keys_of_window (void)
6913 initial_define_key (control_x_map
, '<', "scroll-left");
6914 initial_define_key (control_x_map
, '>', "scroll-right");
6916 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6917 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6918 initial_define_key (meta_map
, 'v', "scroll-down-command");