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 /* Called when W's buffer slot is changed. ARG -1 means that W is about to
274 cease its buffer, and 1 means that W is about to set up the new one. */
277 adjust_window_count (struct window
*w
, int arg
)
279 eassert (eabs (arg
) == 1);
280 if (BUFFERP (w
->buffer
))
282 struct buffer
*b
= XBUFFER (w
->buffer
);
286 b
->window_count
+= arg
;
287 eassert (b
->window_count
>= 0);
291 /* Set W's buffer slot to VAL and recompute number
292 of windows showing VAL if it is a buffer. */
295 wset_buffer (struct window
*w
, Lisp_Object val
)
297 adjust_window_count (w
, -1);
299 adjust_window_count (w
, 1);
302 /* Build a frequently used 4-integer (X Y W H) list. */
305 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
307 return list4 (make_number (x
), make_number (y
),
308 make_number (w
), make_number (h
));
311 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
312 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
315 return WINDOWP (object
) ? Qt
: Qnil
;
318 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
319 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
320 A valid window is either a window that displays a buffer or an internal
321 window. Deleted windows are not live. */)
324 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
327 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
328 doc
: /* Return t if OBJECT is a live window and nil otherwise.
329 A live window is a window that displays a buffer.
330 Internal windows and deleted windows are not live. */)
333 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
336 /* Frames and windows. */
337 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
338 doc
: /* Return the frame that window WINDOW is on.
339 WINDOW must be a valid window and defaults to the selected one. */)
342 return decode_valid_window (window
)->frame
;
345 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
346 doc
: /* Return the root window of FRAME-OR-WINDOW.
347 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
348 With a frame argument, return that frame's root window.
349 With a window argument, return the root window of that window's frame. */)
350 (Lisp_Object frame_or_window
)
354 if (NILP (frame_or_window
))
355 window
= SELECTED_FRAME ()->root_window
;
356 else if (WINDOW_VALID_P (frame_or_window
))
357 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
360 CHECK_LIVE_FRAME (frame_or_window
);
361 window
= XFRAME (frame_or_window
)->root_window
;
367 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
368 doc
: /* Return the minibuffer window for frame FRAME.
369 If FRAME is omitted or nil, it defaults to the selected frame. */)
372 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
375 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
376 Swindow_minibuffer_p
, 0, 1, 0,
377 doc
: /* Return non-nil if WINDOW is a minibuffer window.
378 WINDOW must be a valid window and defaults to the selected one. */)
381 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
384 /* Don't move this to window.el - this must be a safe routine. */
385 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
386 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
387 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
388 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
389 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
390 the first window of that frame. */)
391 (Lisp_Object frame_or_window
)
395 if (NILP (frame_or_window
))
396 window
= SELECTED_FRAME ()->root_window
;
397 else if (WINDOW_VALID_P (frame_or_window
))
398 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
401 CHECK_LIVE_FRAME (frame_or_window
);
402 window
= XFRAME (frame_or_window
)->root_window
;
405 while (NILP (XWINDOW (window
)->buffer
))
407 if (! NILP (XWINDOW (window
)->hchild
))
408 window
= XWINDOW (window
)->hchild
;
409 else if (! NILP (XWINDOW (window
)->vchild
))
410 window
= XWINDOW (window
)->vchild
;
418 DEFUN ("frame-selected-window", Fframe_selected_window
,
419 Sframe_selected_window
, 0, 1, 0,
420 doc
: /* Return the selected window of FRAME-OR-WINDOW.
421 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
422 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
423 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
424 return the selected window of that frame. */)
425 (Lisp_Object frame_or_window
)
429 if (NILP (frame_or_window
))
430 window
= SELECTED_FRAME ()->selected_window
;
431 else if (WINDOW_VALID_P (frame_or_window
))
432 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
435 CHECK_LIVE_FRAME (frame_or_window
);
436 window
= XFRAME (frame_or_window
)->selected_window
;
442 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
443 Sset_frame_selected_window
, 2, 3, 0,
444 doc
: /* Set selected window of FRAME to WINDOW.
445 FRAME must be a live frame and defaults to the selected one. If FRAME
446 is the selected frame, this makes WINDOW the selected window. Optional
447 argument NORECORD non-nil means to neither change the order of recently
448 selected windows nor the buffer list. WINDOW must denote a live window.
450 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
453 frame
= selected_frame
;
455 CHECK_LIVE_FRAME (frame
);
456 CHECK_LIVE_WINDOW (window
);
458 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
459 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
461 if (EQ (frame
, selected_frame
))
462 return Fselect_window (window
, norecord
);
465 fset_selected_window (XFRAME (frame
), window
);
470 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
471 doc
: /* Return the selected window.
472 The selected window is the window in which the standard cursor for
473 selected windows appears and to which many commands apply. */)
476 return selected_window
;
479 int window_select_count
;
481 /* If select_window is called with inhibit_point_swap non-zero it will
482 not store point of the old selected window's buffer back into that
483 window's pointm slot. This is needed by Fset_window_configuration to
484 avoid that the display routine is called with selected_window set to
485 Qnil causing a subsequent crash. */
487 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
489 register struct window
*w
;
492 CHECK_LIVE_WINDOW (window
);
494 w
= XWINDOW (window
);
495 w
->frozen_window_start_p
= 0;
499 w
->use_time
= ++window_select_count
;
500 record_buffer (w
->buffer
);
503 /* Make the selected window's buffer current. */
504 Fset_buffer (w
->buffer
);
506 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
509 sf
= SELECTED_FRAME ();
510 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
512 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
513 /* Use this rather than Fhandle_switch_frame
514 so that FRAME_FOCUS_FRAME is moved appropriately as we
515 move around in the state where a minibuffer in a separate
517 Fselect_frame (WINDOW_FRAME (w
), norecord
);
518 /* Fselect_frame called us back so we've done all the work already. */
519 eassert (EQ (window
, selected_window
));
523 fset_selected_window (sf
, window
);
525 select_window_1 (window
, inhibit_point_swap
);
527 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
528 windows_or_buffers_changed
++;
532 /* Select window with a minimum of fuss, i.e. don't record the change anywhere
533 (not even for redisplay's benefit), and assume that the window's frame is
536 select_window_1 (Lisp_Object window
, bool inhibit_point_swap
)
538 /* Store the old selected window's buffer's point in pointm of the old
539 selected window. It belongs to that window, and when the window is
540 not selected, must be in the window. */
541 if (!inhibit_point_swap
)
543 struct window
*ow
= XWINDOW (selected_window
);
544 if (! NILP (ow
->buffer
))
545 set_marker_both (ow
->pointm
, ow
->buffer
,
546 BUF_PT (XBUFFER (ow
->buffer
)),
547 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
550 selected_window
= window
;
552 /* Go to the point recorded in the window.
553 This is important when the buffer is in more
554 than one window. It also matters when
555 redisplay_window has altered point after scrolling,
556 because it makes the change only in the window. */
558 register ptrdiff_t new_point
= marker_position (XWINDOW (window
)->pointm
);
559 if (new_point
< BEGV
)
561 else if (new_point
> ZV
)
568 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
569 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
570 Also make WINDOW's buffer current and make WINDOW the frame's selected
571 window. Return WINDOW.
573 Optional second arg NORECORD non-nil means do not put this buffer at the
574 front of the buffer list and do not make this window the most recently
577 Note that the main editor command loop sets the current buffer to the
578 buffer of the selected window before each command. */)
579 (register Lisp_Object window
, Lisp_Object norecord
)
581 return select_window (window
, norecord
, 0);
584 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
585 doc
: /* Return the buffer displayed in window WINDOW.
586 If WINDOW is omitted or nil, it defaults to the selected window.
587 Return nil for an internal window or a deleted window. */)
590 return decode_any_window (window
)->buffer
;
593 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
594 doc
: /* Return the parent window of window WINDOW.
595 WINDOW must be a valid window and defaults to the selected one.
596 Return nil for a window with no parent (e.g. a root window). */)
599 return decode_valid_window (window
)->parent
;
602 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
603 doc
: /* Return the topmost child window of window WINDOW.
604 WINDOW must be a valid window and defaults to the selected one.
605 Return nil if WINDOW is a live window (live windows have no children).
606 Return nil if WINDOW is an internal window whose children form a
607 horizontal combination. */)
610 return decode_valid_window (window
)->vchild
;
613 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
614 doc
: /* Return the leftmost child window of window WINDOW.
615 WINDOW must be a valid window and defaults to the selected one.
616 Return nil if WINDOW is a live window (live windows have no children).
617 Return nil if WINDOW is an internal window whose children form a
618 vertical combination. */)
621 return decode_valid_window (window
)->hchild
;
624 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
625 doc
: /* Return the next sibling window of window WINDOW.
626 WINDOW must be a valid window and defaults to the selected one.
627 Return nil if WINDOW has no next sibling. */)
630 return decode_valid_window (window
)->next
;
633 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
634 doc
: /* Return the previous sibling window of window WINDOW.
635 WINDOW must be a valid window and defaults to the selected one.
636 Return nil if WINDOW has no previous sibling. */)
639 return decode_valid_window (window
)->prev
;
642 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
643 doc
: /* Return combination limit of window WINDOW.
644 If the return value is nil, child windows of WINDOW can be recombined with
645 WINDOW's siblings. A return value of t means that child windows of
646 WINDOW are never \(re-)combined with WINDOW's siblings.
648 WINDOW must be a valid window. The return value is meaningful for
649 internal windows only. */)
652 CHECK_VALID_WINDOW (window
);
653 return XWINDOW (window
)->combination_limit
;
656 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
657 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
658 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
659 siblings. LIMIT t means that child windows of WINDOW are never
660 \(re-)combined with WINDOW's siblings. Other values are reserved for
663 WINDOW must be a valid window. Setting the combination limit is
664 meaningful for internal windows only. */)
665 (Lisp_Object window
, Lisp_Object limit
)
667 wset_combination_limit (decode_valid_window (window
), limit
);
671 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
672 doc
: /* Return the use time of window WINDOW.
673 WINDOW must be a live window and defaults to the selected one.
674 The window with the highest use time is the most recently selected
675 one. The window with the lowest use time is the least recently
679 return make_number (decode_live_window (window
)->use_time
);
682 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
683 doc
: /* Return the total height, in lines, of window WINDOW.
684 WINDOW must be a valid window and defaults to the selected one.
686 The return value includes the mode line and header line, if any.
687 If WINDOW is an internal window, the total height is the height
688 of the screen areas spanned by its children.
690 On a graphical display, this total height is reported as an
691 integer multiple of the default character height. */)
694 return decode_valid_window (window
)->total_lines
;
697 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
698 doc
: /* Return the total width, in columns, of window WINDOW.
699 WINDOW must be a valid window and defaults to the selected one.
701 The return value includes any vertical dividers or scroll bars
702 belonging to WINDOW. If WINDOW is an internal window, the total width
703 is the width of the screen areas spanned by its children.
705 On a graphical display, this total width is reported as an
706 integer multiple of the default character width. */)
709 return decode_valid_window (window
)->total_cols
;
712 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
713 doc
: /* Return the new total size of window WINDOW.
714 WINDOW must be a valid window and defaults to the selected one. */)
717 return decode_valid_window (window
)->new_total
;
720 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
721 doc
: /* Return the normal height of window WINDOW.
722 WINDOW must be a valid window and defaults to the selected one.
723 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
724 (Lisp_Object window
, Lisp_Object horizontal
)
726 struct window
*w
= decode_valid_window (window
);
728 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
731 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
732 doc
: /* Return new normal size of window WINDOW.
733 WINDOW must be a valid window and defaults to the selected one. */)
736 return decode_valid_window (window
)->new_normal
;
739 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
740 doc
: /* Return left column of window WINDOW.
741 This is the distance, in columns, between the left edge of WINDOW and
742 the left edge of the frame's window area. For instance, the return
743 value is 0 if there is no window to the left of WINDOW.
745 WINDOW must be a valid window and defaults to the selected one. */)
748 return decode_valid_window (window
)->left_col
;
751 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
752 doc
: /* Return top line of window WINDOW.
753 This is the distance, in lines, between the top of WINDOW and the top
754 of the frame's window area. For instance, the return value is 0 if
755 there is no window above WINDOW.
757 WINDOW must be a valid window and defaults to the selected one. */)
760 return decode_valid_window (window
)->top_line
;
763 /* Return the number of lines of W's body. Don't count any mode or
767 window_body_lines (struct window
*w
)
769 int height
= XFASTINT (w
->total_lines
);
771 if (!MINI_WINDOW_P (w
))
773 if (WINDOW_WANTS_MODELINE_P (w
))
775 if (WINDOW_WANTS_HEADER_LINE_P (w
))
782 /* Return the number of columns of W's body. Don't count columns
783 occupied by the scroll bar or the vertical bar separating W from its
784 right sibling. On window-systems don't count fringes or display
788 window_body_cols (struct window
*w
)
790 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
791 int width
= XINT (w
->total_cols
);
793 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
794 /* Scroll bars occupy a few columns. */
795 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
796 else if (!FRAME_WINDOW_P (f
)
797 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
798 /* The column of `|' characters separating side-by-side windows
799 occupies one column only. */
802 if (FRAME_WINDOW_P (f
))
803 /* On window-systems, fringes and display margins cannot be
804 used for normal text. */
805 width
-= (WINDOW_FRINGE_COLS (w
)
806 + WINDOW_LEFT_MARGIN_COLS (w
)
807 + WINDOW_RIGHT_MARGIN_COLS (w
));
812 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
813 doc
: /* Return the height, in lines, of WINDOW's text area.
814 WINDOW must be a live window and defaults to the selected one.
816 The returned height does not include the mode line or header line.
817 On a graphical display, the height is expressed as an integer multiple
818 of the default character height. If a line at the bottom of the text
819 area is only partially visible, that counts as a whole line; to
820 exclude partially-visible lines, use `window-text-height'. */)
823 return make_number (window_body_lines (decode_live_window (window
)));
826 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
827 doc
: /* Return the width, in columns, of WINDOW's text area.
828 WINDOW must be a live window and defaults to the selected one.
830 The return value does not include any vertical dividers, fringe or
831 marginal areas, or scroll bars. On a graphical display, the width is
832 expressed as an integer multiple of the default character width. */)
835 return make_number (window_body_cols (decode_live_window (window
)));
838 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
839 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
840 WINDOW must be a live window and defaults to the selected one. */)
843 return make_number (decode_live_window (window
)->hscroll
);
846 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
847 range, returning the new amount as a fixnum. */
849 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
851 /* Horizontal scrolling has problems with large scroll amounts.
852 It's too slow with long lines, and even with small lines the
853 display can be messed up. For now, though, impose only the limits
854 required by the internal representation: horizontal scrolling must
855 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
856 (since it's stored in a ptrdiff_t). */
857 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
858 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
860 /* Prevent redisplay shortcuts when changing the hscroll. */
861 if (w
->hscroll
!= new_hscroll
)
862 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
864 w
->hscroll
= new_hscroll
;
865 return make_number (new_hscroll
);
868 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
869 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
870 WINDOW must be a live window and defaults to the selected one.
871 Clip the number to a reasonable value if out of range.
872 Return the new number. NCOL should be zero or positive.
874 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
875 window so that the location of point moves off-window. */)
876 (Lisp_Object window
, Lisp_Object ncol
)
879 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
882 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
883 Swindow_redisplay_end_trigger
, 0, 1, 0,
884 doc
: /* Return WINDOW's redisplay end trigger value.
885 WINDOW must be a live window and defaults to the selected one.
886 See `set-window-redisplay-end-trigger' for more information. */)
889 return decode_live_window (window
)->redisplay_end_trigger
;
892 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
893 Sset_window_redisplay_end_trigger
, 2, 2, 0,
894 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
895 WINDOW must be a live window and defaults to the selected one. VALUE
896 should be a buffer position (typically a marker) or nil. If it is a
897 buffer position, then if redisplay in WINDOW reaches a position beyond
898 VALUE, the functions in `redisplay-end-trigger-functions' are called
899 with two arguments: WINDOW, and the end trigger value. Afterwards the
900 end-trigger value is reset to nil. */)
901 (register Lisp_Object window
, Lisp_Object value
)
903 wset_redisplay_end_trigger (decode_live_window (window
), value
);
907 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
908 doc
: /* Return a list of the edge coordinates of WINDOW.
909 WINDOW must be a valid window and defaults to the selected one.
911 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
912 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
913 0 at top left corner of frame.
915 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
916 is one more than the bottommost row occupied by WINDOW. The edges
917 include the space used by WINDOW's scroll bar, display margins, fringes,
918 header line, and/or mode line. For the edges of just the text area, use
919 `window-inside-edges'. */)
922 register struct window
*w
= decode_valid_window (window
);
924 return list4i (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
925 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
928 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
929 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
930 WINDOW must be a valid window and defaults to the selected one.
932 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
933 0, 0 at the top left corner of the frame.
935 RIGHT is one more than the rightmost x position occupied by WINDOW.
936 BOTTOM is one more than the bottommost y position occupied by WINDOW.
937 The pixel edges include the space used by WINDOW's scroll bar, display
938 margins, fringes, header line, and/or mode line. For the pixel edges
939 of just the text area, use `window-inside-pixel-edges'. */)
942 register struct window
*w
= decode_valid_window (window
);
944 return list4i (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
945 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
949 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
951 struct frame
*f
= XFRAME (w
->frame
);
953 #ifdef FRAME_MENUBAR_HEIGHT
954 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
956 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
957 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
958 #elif FRAME_TOOLBAR_HEIGHT
959 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
961 #ifdef FRAME_NS_TITLEBAR_HEIGHT
962 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
964 *add_x
= f
->left_pos
;
965 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
966 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
970 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
971 Swindow_absolute_pixel_edges
, 0, 1, 0,
972 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
973 WINDOW must be a valid window and defaults to the selected one.
975 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
976 0, 0 at the top left corner of the display.
978 RIGHT is one more than the rightmost x position occupied by WINDOW.
979 BOTTOM is one more than the bottommost y position occupied by WINDOW.
980 The pixel edges include the space used by WINDOW's scroll bar, display
981 margins, fringes, header line, and/or mode line. For the pixel edges
982 of just the text area, use `window-inside-absolute-pixel-edges'. */)
985 register struct window
*w
= decode_valid_window (window
);
988 calc_absolute_offset (w
, &add_x
, &add_y
);
990 return list4i (WINDOW_LEFT_EDGE_X (w
) + add_x
,
991 WINDOW_TOP_EDGE_Y (w
) + add_y
,
992 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
993 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
996 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
997 doc
: /* Return a list of the edge coordinates of WINDOW.
998 WINDOW must be a live window and defaults to the selected one.
1000 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
1001 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
1002 0 at top left corner of frame.
1004 RIGHT is one more than the rightmost column of WINDOW's text area.
1005 BOTTOM is one more than the bottommost row of WINDOW's text area. The
1006 inside edges do not include the space used by the WINDOW's scroll bar,
1007 display margins, fringes, header line, and/or mode line. */)
1008 (Lisp_Object window
)
1010 register struct window
*w
= decode_live_window (window
);
1012 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w
)
1013 + WINDOW_LEFT_MARGIN_COLS (w
)
1014 + WINDOW_LEFT_FRINGE_COLS (w
)),
1015 (WINDOW_TOP_EDGE_LINE (w
)
1016 + WINDOW_HEADER_LINE_LINES (w
)),
1017 (WINDOW_BOX_RIGHT_EDGE_COL (w
)
1018 - WINDOW_RIGHT_MARGIN_COLS (w
)
1019 - WINDOW_RIGHT_FRINGE_COLS (w
)),
1020 (WINDOW_BOTTOM_EDGE_LINE (w
)
1021 - WINDOW_MODE_LINE_LINES (w
)));
1024 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
1025 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1026 WINDOW must be a live window and defaults to the selected one.
1028 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1029 (0,0) at the top left corner of the frame's window area.
1031 RIGHT is one more than the rightmost x position of WINDOW's text area.
1032 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1033 The inside edges do not include the space used by WINDOW's scroll bar,
1034 display margins, fringes, header line, and/or mode line. */)
1035 (Lisp_Object window
)
1037 register struct window
*w
= decode_live_window (window
);
1039 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1040 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1041 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1042 (WINDOW_TOP_EDGE_Y (w
)
1043 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1044 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1045 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1046 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1047 (WINDOW_BOTTOM_EDGE_Y (w
)
1048 - WINDOW_MODE_LINE_HEIGHT (w
)));
1051 DEFUN ("window-inside-absolute-pixel-edges",
1052 Fwindow_inside_absolute_pixel_edges
,
1053 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1054 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1055 WINDOW must be a live window and defaults to the selected one.
1057 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1058 (0,0) at the top left corner of the frame's window area.
1060 RIGHT is one more than the rightmost x position of WINDOW's text area.
1061 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1062 The inside edges do not include the space used by WINDOW's scroll bar,
1063 display margins, fringes, header line, and/or mode line. */)
1064 (Lisp_Object window
)
1066 register struct window
*w
= decode_live_window (window
);
1069 calc_absolute_offset (w
, &add_x
, &add_y
);
1071 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1072 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1073 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1074 (WINDOW_TOP_EDGE_Y (w
)
1075 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1076 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1077 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1078 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1079 (WINDOW_BOTTOM_EDGE_Y (w
)
1080 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1083 /* Test if the character at column X, row Y is within window W.
1084 If it is not, return ON_NOTHING;
1085 if it is in the window's text area, return ON_TEXT;
1086 if it is on the window's modeline, return ON_MODE_LINE;
1087 if it is on the border between the window and its right sibling,
1088 return ON_VERTICAL_BORDER.
1089 if it is on a scroll bar, return ON_SCROLL_BAR.
1090 if it is on the window's top line, return ON_HEADER_LINE;
1091 if it is in left or right fringe of the window,
1092 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1093 if it is in the marginal area to the left/right of the window,
1094 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1096 X and Y are frame relative pixel coordinates. */
1098 static enum window_part
1099 coordinates_in_window (register struct window
*w
, int x
, int y
)
1101 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1102 enum window_part part
;
1103 int ux
= FRAME_COLUMN_WIDTH (f
);
1104 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1105 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1106 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1107 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1108 /* The width of the area where the vertical line can be dragged.
1109 (Between mode lines for instance. */
1110 int grabbable_width
= ux
;
1111 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1113 /* Outside any interesting row or column? */
1114 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1117 /* On the mode line or header line? */
1118 if ((WINDOW_WANTS_MODELINE_P (w
)
1119 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1120 && (part
= ON_MODE_LINE
))
1121 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1122 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1123 && (part
= ON_HEADER_LINE
)))
1125 /* If it's under/over the scroll bar portion of the mode/header
1126 line, say it's on the vertical line. That's to be able to
1127 resize windows horizontally in case we're using toolkit scroll
1128 bars. Note: If scrollbars are on the left, the window that
1129 must be eventually resized is that on the left of WINDOW. */
1130 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1131 && !WINDOW_LEFTMOST_P (w
)
1132 && eabs (x
- left_x
) < grabbable_width
)
1133 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1134 && !WINDOW_RIGHTMOST_P (w
)
1135 && eabs (x
- right_x
) < grabbable_width
))
1136 return ON_VERTICAL_BORDER
;
1141 /* In what's below, we subtract 1 when computing right_x because we
1142 want the rightmost pixel, which is given by left_pixel+width-1. */
1143 if (w
->pseudo_window_p
)
1146 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1150 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1151 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1154 /* Outside any interesting column? */
1155 if (x
< left_x
|| x
> right_x
)
1156 return ON_SCROLL_BAR
;
1158 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1159 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1161 text_left
= window_box_left (w
, TEXT_AREA
);
1162 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1164 if (FRAME_WINDOW_P (f
))
1166 if (!w
->pseudo_window_p
1167 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1168 && !WINDOW_RIGHTMOST_P (w
)
1169 && (eabs (x
- right_x
) < grabbable_width
))
1170 return ON_VERTICAL_BORDER
;
1172 /* Need to say "x > right_x" rather than >=, since on character
1173 terminals, the vertical line's x coordinate is right_x. */
1174 else if (!w
->pseudo_window_p
1175 && !WINDOW_RIGHTMOST_P (w
)
1176 && x
> right_x
- ux
)
1177 return ON_VERTICAL_BORDER
;
1181 if (lmargin_width
> 0
1182 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1183 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1184 : (x
< left_x
+ lmargin_width
)))
1185 return ON_LEFT_MARGIN
;
1187 return ON_LEFT_FRINGE
;
1190 if (x
>= text_right
)
1192 if (rmargin_width
> 0
1193 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1194 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1195 : (x
>= right_x
- rmargin_width
)))
1196 return ON_RIGHT_MARGIN
;
1198 return ON_RIGHT_FRINGE
;
1201 /* Everything special ruled out - must be on text area */
1205 /* Take X is the frame-relative pixel x-coordinate, and return the
1206 x-coordinate relative to part PART of window W. */
1208 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1210 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1215 return x
- window_box_left (w
, TEXT_AREA
);
1217 case ON_LEFT_FRINGE
:
1220 case ON_RIGHT_FRINGE
:
1221 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1223 case ON_LEFT_MARGIN
:
1225 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1226 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1228 case ON_RIGHT_MARGIN
:
1230 - ((w
->pseudo_window_p
)
1231 ? WINDOW_TOTAL_WIDTH (w
)
1232 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1233 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1234 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1235 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1238 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1243 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1244 Scoordinates_in_window_p
, 2, 2, 0,
1245 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1246 WINDOW must be a live window and defaults to the selected one.
1247 COORDINATES is a cons of the form (X . Y), X and Y being distances
1248 measured in characters from the upper-left corner of the frame.
1249 \(0 . 0) denotes the character in the upper left corner of the
1251 If COORDINATES are in the text portion of WINDOW,
1252 the coordinates relative to the window are returned.
1253 If they are in the mode line of WINDOW, `mode-line' is returned.
1254 If they are in the top mode line of WINDOW, `header-line' is returned.
1255 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1256 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1257 If they are on the border between WINDOW and its right sibling,
1258 `vertical-line' is returned.
1259 If they are in the windows's left or right marginal areas, `left-margin'\n\
1260 or `right-margin' is returned. */)
1261 (register Lisp_Object coordinates
, Lisp_Object window
)
1268 w
= decode_live_window (window
);
1269 f
= XFRAME (w
->frame
);
1270 CHECK_CONS (coordinates
);
1271 lx
= Fcar (coordinates
);
1272 ly
= Fcdr (coordinates
);
1273 CHECK_NUMBER_OR_FLOAT (lx
);
1274 CHECK_NUMBER_OR_FLOAT (ly
);
1275 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1276 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1278 switch (coordinates_in_window (w
, x
, y
))
1284 /* Convert X and Y to window relative pixel coordinates, and
1285 return the canonical char units. */
1286 x
-= window_box_left (w
, TEXT_AREA
);
1287 y
-= WINDOW_TOP_EDGE_Y (w
);
1288 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1289 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1294 case ON_VERTICAL_BORDER
:
1295 return Qvertical_line
;
1297 case ON_HEADER_LINE
:
1298 return Qheader_line
;
1300 case ON_LEFT_FRINGE
:
1301 return Qleft_fringe
;
1303 case ON_RIGHT_FRINGE
:
1304 return Qright_fringe
;
1306 case ON_LEFT_MARGIN
:
1307 return Qleft_margin
;
1309 case ON_RIGHT_MARGIN
:
1310 return Qright_margin
;
1313 /* Historically we are supposed to return nil in this case. */
1322 /* Callback for foreach_window, used in window_from_coordinates.
1323 Check if window W contains coordinates specified by USER_DATA which
1324 is actually a pointer to a struct check_window_data CW.
1326 Check if window W contains coordinates *CW->x and *CW->y. If it
1327 does, return W in *CW->window, as Lisp_Object, and return in
1328 *CW->part the part of the window under coordinates *X,*Y. Return
1329 zero from this function to stop iterating over windows. */
1331 struct check_window_data
1333 Lisp_Object
*window
;
1335 enum window_part
*part
;
1339 check_window_containing (struct window
*w
, void *user_data
)
1341 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1342 enum window_part found
;
1345 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1346 if (found
!= ON_NOTHING
)
1349 XSETWINDOW (*cw
->window
, w
);
1357 /* Find the window containing frame-relative pixel position X/Y and
1358 return it as a Lisp_Object.
1360 If X, Y is on one of the window's special `window_part' elements,
1361 set *PART to the id of that element.
1363 If there is no window under X, Y return nil and leave *PART
1364 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1366 This function was previously implemented with a loop cycling over
1367 windows with Fnext_window, and starting with the frame's selected
1368 window. It turned out that this doesn't work with an
1369 implementation of next_window using Vwindow_list, because
1370 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1371 tree of F when this function is called asynchronously from
1372 note_mouse_highlight. The original loop didn't terminate in this
1376 window_from_coordinates (struct frame
*f
, int x
, int y
,
1377 enum window_part
*part
, int tool_bar_p
)
1380 struct check_window_data cw
;
1381 enum window_part dummy
;
1387 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1388 foreach_window (f
, check_window_containing
, &cw
);
1390 /* If not found above, see if it's in the tool bar window, if a tool
1394 && WINDOWP (f
->tool_bar_window
)
1395 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1396 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1400 window
= f
->tool_bar_window
;
1406 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1407 doc
: /* Return window containing coordinates X and Y on FRAME.
1408 FRAME must be a live frame and defaults to the selected one.
1409 The top left corner of the frame is considered to be row 0,
1411 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1413 struct frame
*f
= decode_live_frame (frame
);
1415 /* Check that arguments are integers or floats. */
1416 CHECK_NUMBER_OR_FLOAT (x
);
1417 CHECK_NUMBER_OR_FLOAT (y
);
1419 return window_from_coordinates (f
,
1420 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1421 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1422 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1423 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1427 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1428 doc
: /* Return current value of point in WINDOW.
1429 WINDOW must be a live window and defaults to the selected one.
1431 For a nonselected window, this is the value point would have if that
1432 window were selected.
1434 Note that, when WINDOW is selected, the value returned is the same as
1435 that returned by `point' for WINDOW's buffer. It would be more strictly
1436 correct to return the `top-level' value of `point', outside of any
1437 `save-excursion' forms. But that is hard to define. */)
1438 (Lisp_Object window
)
1440 register struct window
*w
= decode_live_window (window
);
1442 if (w
== XWINDOW (selected_window
))
1443 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1445 return Fmarker_position (w
->pointm
);
1448 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1449 doc
: /* Return position at which display currently starts in WINDOW.
1450 WINDOW must be a live window and defaults to the selected one.
1451 This is updated by redisplay or by calling `set-window-start'. */)
1452 (Lisp_Object window
)
1454 return Fmarker_position (decode_live_window (window
)->start
);
1457 /* This is text temporarily removed from the doc string below.
1459 This function returns nil if the position is not currently known.
1460 That happens when redisplay is preempted and doesn't finish.
1461 If in that case you want to compute where the end of the window would
1462 have been if redisplay had finished, do this:
1464 (goto-char (window-start window))
1465 (vertical-motion (1- (window-height window)) window)
1468 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1469 doc
: /* Return position at which display currently ends in WINDOW.
1470 WINDOW must be a live window and defaults to the selected one.
1471 This is updated by redisplay, when it runs to completion.
1472 Simply changing the buffer text or setting `window-start'
1473 does not update this value.
1474 Return nil if there is no recorded value. (This can happen if the
1475 last redisplay of WINDOW was preempted, and did not finish.)
1476 If UPDATE is non-nil, compute the up-to-date position
1477 if it isn't already recorded. */)
1478 (Lisp_Object window
, Lisp_Object update
)
1481 struct window
*w
= decode_live_window (window
);
1489 #if 0 /* This change broke some things. We should make it later. */
1490 /* If we don't know the end position, return nil.
1491 The user can compute it with vertical-motion if he wants to.
1492 It would be nicer to do it automatically,
1493 but that's so slow that it would probably bother people. */
1494 if (NILP (w
->window_end_valid
))
1499 && (windows_or_buffers_changed
|| NILP (w
->window_end_valid
))
1502 struct text_pos startp
;
1503 ptrdiff_t charpos
= marker_position (w
->start
);
1505 struct buffer
*old_buffer
= NULL
;
1506 void *itdata
= NULL
;
1508 /* Cannot use Fvertical_motion because that function doesn't
1509 cope with variable-height lines. */
1510 if (b
!= current_buffer
)
1512 old_buffer
= current_buffer
;
1513 set_buffer_internal (b
);
1516 /* In case W->start is out of the range, use something
1517 reasonable. This situation occurred when loading a file with
1518 `-l' containing a call to `rmail' with subsequent other
1519 commands. At the end, W->start happened to be BEG, while
1520 rmail had already narrowed the buffer. */
1522 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1523 else if (charpos
> ZV
)
1524 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1526 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1528 itdata
= bidi_shelve_cache ();
1529 start_display (&it
, w
, startp
);
1530 move_it_vertically (&it
, window_box_height (w
));
1531 if (it
.current_y
< it
.last_visible_y
)
1532 move_it_past_eol (&it
);
1533 value
= make_number (IT_CHARPOS (it
));
1534 bidi_unshelve_cache (itdata
, 0);
1537 set_buffer_internal (old_buffer
);
1540 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1545 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1546 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1547 WINDOW must be a live window and defaults to the selected one.
1549 (Lisp_Object window
, Lisp_Object pos
)
1551 register struct window
*w
= decode_live_window (window
);
1553 CHECK_NUMBER_COERCE_MARKER (pos
);
1555 if (w
== XWINDOW (selected_window
))
1557 if (XBUFFER (w
->buffer
) == current_buffer
)
1561 struct buffer
*old_buffer
= current_buffer
;
1563 set_buffer_internal (XBUFFER (w
->buffer
));
1565 set_buffer_internal (old_buffer
);
1570 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1571 /* We have to make sure that redisplay updates the window to show
1572 the new value of point. */
1573 ++windows_or_buffers_changed
;
1579 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1580 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1581 WINDOW must be a live window and defaults to the selected one. Return
1582 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1583 overriding motion of point in order to display at this exact start. */)
1584 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1586 register struct window
*w
= decode_live_window (window
);
1588 CHECK_NUMBER_COERCE_MARKER (pos
);
1589 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1590 /* this is not right, but much easier than doing what is right. */
1591 w
->start_at_line_beg
= 0;
1594 w
->update_mode_line
= 1;
1595 w
->last_modified
= 0;
1596 w
->last_overlay_modified
= 0;
1597 if (!EQ (window
, selected_window
))
1598 windows_or_buffers_changed
++;
1603 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1604 Spos_visible_in_window_p
, 0, 3, 0,
1605 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1606 WINDOW must be a live window and defaults to the selected one.
1608 Return nil if that position is scrolled vertically out of view. If a
1609 character is only partially visible, nil is returned, unless the
1610 optional argument PARTIALLY is non-nil. If POS is only out of view
1611 because of horizontal scrolling, return non-nil. If POS is t, it
1612 specifies the position of the last visible glyph in WINDOW. POS
1613 defaults to point in WINDOW; WINDOW defaults to the selected window.
1615 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1616 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1617 where X and Y are the pixel coordinates relative to the top left corner
1618 of the window. The remaining elements are omitted if the character after
1619 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1620 off-window at the top and bottom of the row, ROWH is the height of the
1621 display row, and VPOS is the row number (0-based) containing POS. */)
1622 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1624 register struct window
*w
;
1625 register EMACS_INT posint
;
1626 register struct buffer
*buf
;
1627 struct text_pos top
;
1628 Lisp_Object in_window
= Qnil
;
1629 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1632 w
= decode_live_window (window
);
1633 buf
= XBUFFER (w
->buffer
);
1634 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1638 else if (!NILP (pos
))
1640 CHECK_NUMBER_COERCE_MARKER (pos
);
1641 posint
= XINT (pos
);
1643 else if (w
== XWINDOW (selected_window
))
1646 posint
= marker_position (w
->pointm
);
1648 /* If position is above window start or outside buffer boundaries,
1649 or if window start is out of range, position is not visible. */
1651 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1652 && CHARPOS (top
) >= BUF_BEGV (buf
)
1653 && CHARPOS (top
) <= BUF_ZV (buf
)
1654 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1655 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1658 if (!NILP (in_window
) && !NILP (partially
))
1660 Lisp_Object part
= Qnil
;
1662 part
= list4i (rtop
, rbot
, rowh
, vpos
);
1663 in_window
= Fcons (make_number (x
),
1664 Fcons (make_number (y
), part
));
1670 DEFUN ("window-line-height", Fwindow_line_height
,
1671 Swindow_line_height
, 0, 2, 0,
1672 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1673 WINDOW must be a live window and defaults to the selected one.
1675 Return height of current line if LINE is omitted or nil. Return height of
1676 header or mode line if LINE is `header-line' or `mode-line'.
1677 Otherwise, LINE is a text line number starting from 0. A negative number
1678 counts from the end of the window.
1680 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1681 in pixels of the visible part of the line, VPOS and YPOS are the
1682 vertical position in lines and pixels of the line, relative to the top
1683 of the first text line, and OFFBOT is the number of off-window pixels at
1684 the bottom of the text line. If there are off-window pixels at the top
1685 of the (first) text line, YPOS is negative.
1687 Return nil if window display is not up-to-date. In that case, use
1688 `pos-visible-in-window-p' to obtain the information. */)
1689 (Lisp_Object line
, Lisp_Object window
)
1691 register struct window
*w
;
1692 register struct buffer
*b
;
1693 struct glyph_row
*row
, *end_row
;
1697 w
= decode_live_window (window
);
1699 if (noninteractive
|| w
->pseudo_window_p
)
1702 CHECK_BUFFER (w
->buffer
);
1703 b
= XBUFFER (w
->buffer
);
1705 /* Fail if current matrix is not up-to-date. */
1706 if (NILP (w
->window_end_valid
)
1707 || current_buffer
->clip_changed
1708 || current_buffer
->prevent_redisplay_optimizations_p
1709 || w
->last_modified
< BUF_MODIFF (b
)
1710 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1716 if (i
< 0 || i
>= w
->current_matrix
->nrows
1717 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1719 max_y
= window_text_bottom_y (w
);
1723 if (EQ (line
, Qheader_line
))
1725 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1727 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1728 return row
->enabled_p
? list4i (row
->height
, 0, 0, 0) : Qnil
;
1731 if (EQ (line
, Qmode_line
))
1733 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1734 return (row
->enabled_p
?
1735 list4i (row
->height
,
1736 0, /* not accurate */
1737 (WINDOW_HEADER_LINE_HEIGHT (w
)
1738 + window_text_bottom_y (w
)),
1743 CHECK_NUMBER (line
);
1746 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1747 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1748 max_y
= window_text_bottom_y (w
);
1751 while ((n
< 0 || i
< n
)
1752 && row
<= end_row
&& row
->enabled_p
1753 && row
->y
+ row
->height
< max_y
)
1756 if (row
> end_row
|| !row
->enabled_p
)
1768 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1769 return list4i (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1772 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1774 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1775 More precisely, return the value assigned by the last call of
1776 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1777 never called with WINDOW as its argument, or the value set by that
1778 function was internally reset since its last call. WINDOW must be a
1779 live window and defaults to the selected one.
1781 When a window is dedicated to its buffer, `display-buffer' will refrain
1782 from displaying another buffer in it. `get-lru-window' and
1783 `get-largest-window' treat dedicated windows specially.
1784 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1785 `kill-buffer' can delete a dedicated window and the containing frame.
1787 Functions like `set-window-buffer' may change the buffer displayed by a
1788 window, unless that window is "strongly" dedicated to its buffer, that
1789 is the value returned by `window-dedicated-p' is t. */)
1790 (Lisp_Object window
)
1792 return decode_live_window (window
)->dedicated
;
1795 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1796 Sset_window_dedicated_p
, 2, 2, 0,
1797 doc
: /* Mark WINDOW as dedicated according to FLAG.
1798 WINDOW must be a live window and defaults to the selected one. FLAG
1799 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1800 mark WINDOW as non-dedicated. Return FLAG.
1802 When a window is dedicated to its buffer, `display-buffer' will refrain
1803 from displaying another buffer in it. `get-lru-window' and
1804 `get-largest-window' treat dedicated windows specially.
1805 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1806 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1807 and the containing frame.
1809 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1810 its buffer. Functions like `set-window-buffer' may change the buffer
1811 displayed by a window, unless that window is strongly dedicated to its
1812 buffer. If and when `set-window-buffer' displays another buffer in a
1813 window, it also makes sure that the window is no more dedicated. */)
1814 (Lisp_Object window
, Lisp_Object flag
)
1816 wset_dedicated (decode_live_window (window
), flag
);
1820 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1822 doc
: /* Return buffers previously shown in WINDOW.
1823 WINDOW must be a live window and defaults to the selected one.
1825 The return value is a list of elements (BUFFER WINDOW-START POS),
1826 where BUFFER is a buffer, WINDOW-START is the start position of the
1827 window for that buffer, and POS is a window-specific point value. */)
1828 (Lisp_Object window
)
1830 return decode_live_window (window
)->prev_buffers
;
1833 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1834 Sset_window_prev_buffers
, 2, 2, 0,
1835 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1836 WINDOW must be a live window and defaults to the selected one.
1838 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1839 where BUFFER is a buffer, WINDOW-START is the start position of the
1840 window for that buffer, and POS is a window-specific point value. */)
1841 (Lisp_Object window
, Lisp_Object prev_buffers
)
1843 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1844 return prev_buffers
;
1847 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1849 doc
: /* Return list of buffers recently re-shown in WINDOW.
1850 WINDOW must be a live window and defaults to the selected one. */)
1851 (Lisp_Object window
)
1853 return decode_live_window (window
)->next_buffers
;
1856 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1857 Sset_window_next_buffers
, 2, 2, 0,
1858 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1859 WINDOW must be a live window and defaults to the selected one.
1860 NEXT-BUFFERS should be a list of buffers. */)
1861 (Lisp_Object window
, Lisp_Object next_buffers
)
1863 wset_next_buffers (decode_live_window (window
), next_buffers
);
1864 return next_buffers
;
1867 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1869 doc
: /* Return the parameters of WINDOW and their values.
1870 WINDOW must be a valid window and defaults to the selected one. The
1871 return value is a list of elements of the form (PARAMETER . VALUE). */)
1872 (Lisp_Object window
)
1874 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1877 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1879 doc
: /* Return WINDOW's value for PARAMETER.
1880 WINDOW can be any window and defaults to the selected one. */)
1881 (Lisp_Object window
, Lisp_Object parameter
)
1885 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1886 return CDR_SAFE (result
);
1889 DEFUN ("set-window-parameter", Fset_window_parameter
,
1890 Sset_window_parameter
, 3, 3, 0,
1891 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1892 WINDOW can be any window and defaults to the selected one.
1894 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1896 register struct window
*w
= decode_any_window (window
);
1897 Lisp_Object old_alist_elt
;
1899 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1900 if (NILP (old_alist_elt
))
1901 wset_window_parameters
1902 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1904 Fsetcdr (old_alist_elt
, value
);
1908 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1910 doc
: /* Return the display-table that WINDOW is using.
1911 WINDOW must be a live window and defaults to the selected one. */)
1912 (Lisp_Object window
)
1914 return decode_live_window (window
)->display_table
;
1917 /* Get the display table for use on window W. This is either W's
1918 display table or W's buffer's display table. Ignore the specified
1919 tables if they are not valid; if no valid table is specified,
1922 struct Lisp_Char_Table
*
1923 window_display_table (struct window
*w
)
1925 struct Lisp_Char_Table
*dp
= NULL
;
1927 if (DISP_TABLE_P (w
->display_table
))
1928 dp
= XCHAR_TABLE (w
->display_table
);
1929 else if (BUFFERP (w
->buffer
))
1931 struct buffer
*b
= XBUFFER (w
->buffer
);
1933 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1934 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1935 else if (DISP_TABLE_P (Vstandard_display_table
))
1936 dp
= XCHAR_TABLE (Vstandard_display_table
);
1942 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1943 doc
: /* Set WINDOW's display-table to TABLE.
1944 WINDOW must be a live window and defaults to the selected one. */)
1945 (register Lisp_Object window
, Lisp_Object table
)
1947 wset_display_table (decode_live_window (window
), table
);
1951 /* Record info on buffer window W is displaying
1952 when it is about to cease to display that buffer. */
1954 unshow_buffer (register struct window
*w
)
1961 if (b
!= XMARKER (w
->pointm
)->buffer
)
1965 if (w
== XWINDOW (selected_window
)
1966 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1967 /* Do this except when the selected window's buffer
1968 is being removed from some other window. */
1970 /* last_window_start records the start position that this buffer
1971 had in the last window to be disconnected from it.
1972 Now that this statement is unconditional,
1973 it is possible for the buffer to be displayed in the
1974 selected window, while last_window_start reflects another
1975 window which was recently showing the same buffer.
1976 Some people might say that might be a good thing. Let's see. */
1977 b
->last_window_start
= marker_position (w
->start
);
1979 /* Point in the selected window's buffer
1980 is actually stored in that buffer, and the window's pointm isn't used.
1981 So don't clobber point in that buffer. */
1982 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1983 /* Don't clobber point in current buffer either (this could be
1984 useful in connection with bug#12208).
1985 && XBUFFER (buf) != current_buffer */
1986 /* This line helps to fix Horsley's testbug.el bug. */
1987 && !(WINDOWP (BVAR (b
, last_selected_window
))
1988 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1989 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1990 temp_set_point_both (b
,
1991 clip_to_bounds (BUF_BEGV (b
),
1992 marker_position (w
->pointm
),
1994 clip_to_bounds (BUF_BEGV_BYTE (b
),
1995 marker_byte_position (w
->pointm
),
1998 if (WINDOWP (BVAR (b
, last_selected_window
))
1999 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
2000 bset_last_selected_window (b
, Qnil
);
2003 /* Put NEW into the window structure in place of OLD. SETFLAG zero
2004 means change window structure only. Otherwise store geometry and
2005 other settings as well. */
2007 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
2009 register Lisp_Object tem
;
2010 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
2012 /* If OLD is its frame's root window, then NEW is the new
2013 root window for that frame. */
2014 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
2015 fset_root_window (XFRAME (o
->frame
), new);
2019 wset_left_col (n
, o
->left_col
);
2020 wset_top_line (n
, o
->top_line
);
2021 wset_total_cols (n
, o
->total_cols
);
2022 wset_total_lines (n
, o
->total_lines
);
2023 wset_normal_cols (n
, o
->normal_cols
);
2024 wset_normal_cols (o
, make_float (1.0));
2025 wset_normal_lines (n
, o
->normal_lines
);
2026 wset_normal_lines (o
, make_float (1.0));
2027 n
->desired_matrix
= n
->current_matrix
= 0;
2029 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
2030 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
2031 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
2032 n
->phys_cursor_type
= -1;
2033 n
->phys_cursor_width
= -1;
2034 n
->must_be_updated_p
= 0;
2035 n
->pseudo_window_p
= 0;
2036 wset_window_end_vpos (n
, make_number (0));
2037 wset_window_end_pos (n
, make_number (0));
2038 wset_window_end_valid (n
, Qnil
);
2039 n
->frozen_window_start_p
= 0;
2045 wset_prev (XWINDOW (tem
), new);
2050 wset_next (XWINDOW (tem
), new);
2053 wset_parent (n
, tem
);
2056 if (EQ (XWINDOW (tem
)->vchild
, old
))
2057 wset_vchild (XWINDOW (tem
), new);
2058 if (EQ (XWINDOW (tem
)->hchild
, old
))
2059 wset_hchild (XWINDOW (tem
), new);
2063 /* If window WINDOW and its parent window are iso-combined, merge
2064 WINDOW's children into those of its parent window and mark WINDOW as
2068 recombine_windows (Lisp_Object window
)
2070 struct window
*w
, *p
, *c
;
2071 Lisp_Object parent
, child
;
2074 w
= XWINDOW (window
);
2076 if (!NILP (parent
) && NILP (w
->combination_limit
))
2078 p
= XWINDOW (parent
);
2079 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2080 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2081 /* WINDOW and PARENT are both either a vertical or a horizontal
2084 horflag
= NILP (w
->vchild
);
2085 child
= horflag
? w
->hchild
: w
->vchild
;
2086 c
= XWINDOW (child
);
2088 /* Splice WINDOW's children into its parent's children and
2089 assign new normal sizes. */
2092 wset_hchild (p
, child
);
2094 wset_vchild (p
, child
);
2097 wset_prev (c
, w
->prev
);
2098 wset_next (XWINDOW (w
->prev
), child
);
2103 wset_parent (c
, parent
);
2106 wset_normal_cols (c
,
2107 make_float (XFLOATINT (c
->total_cols
)
2108 / XFLOATINT (p
->total_cols
)));
2110 wset_normal_lines (c
,
2111 make_float (XFLOATINT (c
->total_lines
)
2112 / XFLOATINT (p
->total_lines
)));
2116 if (!NILP (w
->next
))
2118 wset_next (c
, w
->next
);
2119 wset_prev (XWINDOW (c
->next
), child
);
2127 c
= XWINDOW (child
);
2131 /* WINDOW can be deleted now. */
2132 wset_vchild (w
, Qnil
);
2133 wset_hchild (w
, Qnil
);
2138 /* If WINDOW can be deleted, delete it. */
2140 delete_deletable_window (Lisp_Object window
)
2142 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2143 call1 (Qdelete_window
, window
);
2146 /***********************************************************************
2148 ***********************************************************************/
2150 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2151 pointer. This is a callback function for foreach_window, used in
2152 the window_list function. */
2155 add_window_to_list (struct window
*w
, void *user_data
)
2157 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2159 XSETWINDOW (window
, w
);
2160 *list
= Fcons (window
, *list
);
2165 /* Return a list of all windows, for use by next_window. If
2166 Vwindow_list is a list, return that list. Otherwise, build a new
2167 list, cache it in Vwindow_list, and return that. */
2172 if (!CONSP (Vwindow_list
))
2174 Lisp_Object tail
, frame
;
2176 Vwindow_list
= Qnil
;
2177 FOR_EACH_FRAME (tail
, frame
)
2179 Lisp_Object args
[2];
2181 /* We are visiting windows in canonical order, and add
2182 new windows at the front of args[1], which means we
2183 have to reverse this list at the end. */
2185 foreach_window (XFRAME (frame
), add_window_to_list
, &args
[1]);
2186 args
[0] = Vwindow_list
;
2187 args
[1] = Fnreverse (args
[1]);
2188 Vwindow_list
= Fnconc (2, args
);
2192 return Vwindow_list
;
2196 /* Value is non-zero if WINDOW satisfies the constraints given by
2197 OWINDOW, MINIBUF and ALL_FRAMES.
2199 MINIBUF t means WINDOW may be minibuffer windows.
2200 `lambda' means WINDOW may not be a minibuffer window.
2201 a window means a specific minibuffer window
2203 ALL_FRAMES t means search all frames,
2204 nil means search just current frame,
2205 `visible' means search just visible frames on the
2207 0 means search visible and iconified frames on the
2209 a window means search the frame that window belongs to,
2210 a frame means consider windows on that frame, only. */
2213 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2215 struct window
*w
= XWINDOW (window
);
2216 struct frame
*f
= XFRAME (w
->frame
);
2217 int candidate_p
= 1;
2219 if (!BUFFERP (w
->buffer
))
2221 else if (MINI_WINDOW_P (w
)
2222 && (EQ (minibuf
, Qlambda
)
2223 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2225 /* If MINIBUF is `lambda' don't consider any mini-windows.
2226 If it is a window, consider only that one. */
2229 else if (EQ (all_frames
, Qt
))
2231 else if (NILP (all_frames
))
2233 eassert (WINDOWP (owindow
));
2234 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2236 else if (EQ (all_frames
, Qvisible
))
2238 FRAME_SAMPLE_VISIBILITY (f
);
2239 candidate_p
= FRAME_VISIBLE_P (f
)
2240 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2241 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2244 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2246 FRAME_SAMPLE_VISIBILITY (f
);
2247 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2248 #ifdef HAVE_X_WINDOWS
2249 /* Yuck!! If we've just created the frame and the
2250 window-manager requested the user to place it
2251 manually, the window may still not be considered
2252 `visible'. I'd argue it should be at least
2253 something like `iconified', but don't know how to do
2255 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2256 && !f
->output_data
.x
->has_been_visible
)
2259 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2260 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2262 else if (WINDOWP (all_frames
))
2263 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2264 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2265 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2266 else if (FRAMEP (all_frames
))
2267 candidate_p
= EQ (all_frames
, w
->frame
);
2273 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2274 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2275 MINIBUF, and ALL_FRAMES. */
2278 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2280 struct window
*w
= decode_live_window (*window
);
2282 XSETWINDOW (*window
, w
);
2283 /* MINIBUF nil may or may not include minibuffers. Decide if it
2285 if (NILP (*minibuf
))
2286 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2287 else if (!EQ (*minibuf
, Qt
))
2290 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2291 => count none of them, or a specific minibuffer window (the
2292 active one) to count. */
2294 /* ALL_FRAMES nil doesn't specify which frames to include. */
2295 if (NILP (*all_frames
))
2297 = (!EQ (*minibuf
, Qlambda
)
2298 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2300 else if (EQ (*all_frames
, Qvisible
))
2302 else if (EQ (*all_frames
, make_number (0)))
2304 else if (FRAMEP (*all_frames
))
2306 else if (!EQ (*all_frames
, Qt
))
2311 /* Return the next or previous window of WINDOW in cyclic ordering
2312 of windows. NEXT_P non-zero means return the next window. See the
2313 documentation string of next-window for the meaning of MINIBUF and
2317 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2319 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2321 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2322 return the first window on the frame. */
2323 if (FRAMEP (all_frames
)
2324 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2325 return Fframe_first_window (all_frames
);
2331 /* Find WINDOW in the list of all windows. */
2332 list
= Fmemq (window
, window_list ());
2334 /* Scan forward from WINDOW to the end of the window list. */
2336 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2337 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2340 /* Scan from the start of the window list up to WINDOW. */
2342 for (list
= Vwindow_list
;
2343 CONSP (list
) && !EQ (XCAR (list
), window
);
2345 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2349 window
= XCAR (list
);
2353 Lisp_Object candidate
, list
;
2355 /* Scan through the list of windows for candidates. If there are
2356 candidate windows in front of WINDOW, the last one of these
2357 is the one we want. If there are candidates following WINDOW
2358 in the list, again the last one of these is the one we want. */
2360 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2362 if (EQ (XCAR (list
), window
))
2364 if (WINDOWP (candidate
))
2367 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2369 candidate
= XCAR (list
);
2372 if (WINDOWP (candidate
))
2380 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2381 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2382 WINDOW must be a live window and defaults to the selected one. The
2383 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2386 MINIBUF nil or omitted means consider the minibuffer window only if the
2387 minibuffer is active. MINIBUF t means consider the minibuffer window
2388 even if the minibuffer is not active. Any other value means do not
2389 consider the minibuffer window even if the minibuffer is active.
2391 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2392 plus the minibuffer window if specified by the MINIBUF argument. If the
2393 minibuffer counts, consider all windows on all frames that share that
2394 minibuffer too. The following non-nil values of ALL-FRAMES have special
2397 - t means consider all windows on all existing frames.
2399 - `visible' means consider all windows on all visible frames.
2401 - 0 (the number zero) means consider all windows on all visible and
2404 - A frame means consider all windows on that frame only.
2406 Anything else means consider all windows on WINDOW's frame and no
2409 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2410 `next-window' to iterate through the entire cycle of acceptable
2411 windows, eventually ending up back at the window you started with.
2412 `previous-window' traverses the same cycle, in the reverse order. */)
2413 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2415 return next_window (window
, minibuf
, all_frames
, 1);
2419 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2420 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2421 WINDOW must be a live window and defaults to the selected one. The
2422 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2425 MINIBUF nil or omitted means consider the minibuffer window only if the
2426 minibuffer is active. MINIBUF t means consider the minibuffer window
2427 even if the minibuffer is not active. Any other value means do not
2428 consider the minibuffer window even if the minibuffer is active.
2430 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2431 plus the minibuffer window if specified by the MINIBUF argument. If the
2432 minibuffer counts, consider all windows on all frames that share that
2433 minibuffer too. The following non-nil values of ALL-FRAMES have special
2436 - t means consider all windows on all existing frames.
2438 - `visible' means consider all windows on all visible frames.
2440 - 0 (the number zero) means consider all windows on all visible and
2443 - A frame means consider all windows on that frame only.
2445 Anything else means consider all windows on WINDOW's frame and no
2448 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2449 use `previous-window' to iterate through the entire cycle of
2450 acceptable windows, eventually ending up back at the window you
2451 started with. `next-window' traverses the same cycle, in the
2453 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2455 return next_window (window
, minibuf
, all_frames
, 0);
2459 /* Return a list of windows in cyclic ordering. Arguments are like
2460 for `next-window'. */
2463 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2465 Lisp_Object tail
, list
, rest
;
2467 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2470 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2471 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2472 list
= Fcons (XCAR (tail
), list
);
2474 /* Rotate the list to start with WINDOW. */
2475 list
= Fnreverse (list
);
2476 rest
= Fmemq (window
, list
);
2477 if (!NILP (rest
) && !EQ (rest
, list
))
2479 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2481 XSETCDR (tail
, Qnil
);
2482 list
= nconc2 (rest
, list
);
2488 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2489 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2490 FRAME nil or omitted means use the selected frame.
2491 WINDOW nil or omitted means use the window selected within FRAME.
2492 MINIBUF t means include the minibuffer window, even if it isn't active.
2493 MINIBUF nil or omitted means include the minibuffer window only
2495 MINIBUF neither nil nor t means never include the minibuffer window. */)
2496 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2499 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2500 CHECK_WINDOW (window
);
2502 frame
= selected_frame
;
2504 if (!EQ (frame
, XWINDOW (window
)->frame
))
2505 error ("Window is on a different frame");
2507 return window_list_1 (window
, minibuf
, frame
);
2511 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2512 doc
: /* Return a list of all live windows.
2513 WINDOW specifies the first window to list and defaults to the selected
2516 Optional argument MINIBUF nil or omitted means consider the minibuffer
2517 window only if the minibuffer is active. MINIBUF t means consider the
2518 minibuffer window even if the minibuffer is not active. Any other value
2519 means do not consider the minibuffer window even if the minibuffer is
2522 Optional argument ALL-FRAMES nil or omitted means consider all windows
2523 on WINDOW's frame, plus the minibuffer window if specified by the
2524 MINIBUF argument. If the minibuffer counts, consider all windows on all
2525 frames that share that minibuffer too. The following non-nil values of
2526 ALL-FRAMES have special meanings:
2528 - t means consider all windows on all existing frames.
2530 - `visible' means consider all windows on all visible frames.
2532 - 0 (the number zero) means consider all windows on all visible and
2535 - A frame means consider all windows on that frame only.
2537 Anything else means consider all windows on WINDOW's frame and no
2540 If WINDOW is not on the list of windows returned, some other window will
2541 be listed first but no error is signaled. */)
2542 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2544 return window_list_1 (window
, minibuf
, all_frames
);
2547 /* Look at all windows, performing an operation specified by TYPE
2549 If FRAMES is Qt, look at all frames;
2550 Qnil, look at just the selected frame;
2551 Qvisible, look at visible frames;
2552 a frame, just look at windows on that frame.
2553 If MINI is non-zero, perform the operation on minibuffer windows too. */
2558 GET_BUFFER_WINDOW
, /* Arg is buffer */
2559 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2560 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2565 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2567 Lisp_Object window
, windows
, best_window
, frame_arg
;
2568 int frame_best_window_flag
= 0;
2570 struct gcpro gcpro1
;
2572 /* If we're only looping through windows on a particular frame,
2573 frame points to that frame. If we're looping through windows
2574 on all frames, frame is 0. */
2575 if (FRAMEP (frames
))
2576 f
= XFRAME (frames
);
2577 else if (NILP (frames
))
2578 f
= SELECTED_FRAME ();
2583 frame_arg
= Qlambda
;
2584 else if (EQ (frames
, make_number (0)))
2586 else if (EQ (frames
, Qvisible
))
2591 /* frame_arg is Qlambda to stick to one frame,
2592 Qvisible to consider all visible frames,
2595 /* Pick a window to start with. */
2599 window
= FRAME_SELECTED_WINDOW (f
);
2601 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2603 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2607 for (; CONSP (windows
); windows
= XCDR (windows
))
2611 window
= XCAR (windows
);
2612 w
= XWINDOW (window
);
2614 /* Note that we do not pay attention here to whether the frame
2615 is visible, since Fwindow_list skips non-visible frames if
2616 that is desired, under the control of frame_arg. */
2617 if (!MINI_WINDOW_P (w
)
2618 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2619 consider all windows. */
2620 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2621 || (mini
&& minibuf_level
> 0))
2624 case GET_BUFFER_WINDOW
:
2625 if (EQ (w
->buffer
, obj
)
2626 /* Don't find any minibuffer window except the one that
2627 is currently in use. */
2628 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2630 if (EQ (window
, selected_window
))
2631 /* Preferably return the selected window. */
2632 RETURN_UNGCPRO (window
);
2633 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2634 && !frame_best_window_flag
)
2635 /* Prefer windows on the current frame (but don't
2636 choose another one if we have one already). */
2638 best_window
= window
;
2639 frame_best_window_flag
= 1;
2641 else if (NILP (best_window
))
2642 best_window
= window
;
2646 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2647 /* We could simply check whether the buffer shown by window
2648 is live, and show another buffer in case it isn't. */
2649 if (EQ (w
->buffer
, obj
))
2651 /* Undedicate WINDOW. */
2652 wset_dedicated (w
, Qnil
);
2653 /* Make WINDOW show the buffer returned by
2654 other_buffer_safely, don't run any hooks. */
2656 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2657 /* If WINDOW is the selected window, make its buffer
2658 current. But do so only if the window shows the
2659 current buffer (Bug#6454). */
2660 if (EQ (window
, selected_window
)
2661 && XBUFFER (w
->buffer
) == current_buffer
)
2662 Fset_buffer (w
->buffer
);
2666 case REDISPLAY_BUFFER_WINDOWS
:
2667 if (EQ (w
->buffer
, obj
))
2669 mark_window_display_accurate (window
, 0);
2670 w
->update_mode_line
= 1;
2671 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2672 ++update_mode_lines
;
2673 best_window
= window
;
2677 /* Check for a window that has a killed buffer. */
2678 case CHECK_ALL_WINDOWS
:
2679 if (! NILP (w
->buffer
)
2680 && !BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
2684 case WINDOW_LOOP_UNUSED
:
2693 /* Used for debugging. Abort if any window has a dead buffer. */
2695 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2697 check_all_windows (void)
2699 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2702 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2703 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2704 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2707 The optional argument ALL-FRAMES specifies the frames to consider:
2709 - t means consider all windows on all existing frames.
2711 - `visible' means consider all windows on all visible frames.
2713 - 0 (the number zero) means consider all windows on all visible
2714 and iconified frames.
2716 - A frame means consider all windows on that frame only.
2718 Any other value of ALL-FRAMES means consider all windows on the
2719 selected frame and no others. */)
2720 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2724 if (NILP (buffer_or_name
))
2725 buffer
= Fcurrent_buffer ();
2727 buffer
= Fget_buffer (buffer_or_name
);
2729 if (BUFFERP (buffer
))
2730 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2736 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2738 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2742 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2743 Sdelete_other_windows_internal
, 0, 2, "",
2744 doc
: /* Make WINDOW fill its frame.
2745 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2746 and defaults to the selected one.
2748 Optional argument ROOT, if non-nil, must specify an internal window such
2749 that WINDOW is in its window subtree. If this is the case, replace ROOT
2750 by WINDOW and leave alone any windows not part of ROOT's subtree.
2752 When WINDOW is live try to reduce display jumps by keeping the text
2753 previously visible in WINDOW in the same place on the frame. Doing this
2754 depends on the value of (window-start WINDOW), so if calling this
2755 function in a program gives strange scrolling, make sure the
2756 window-start value is reasonable when this function is called. */)
2757 (Lisp_Object window
, Lisp_Object root
)
2759 struct window
*w
, *r
, *s
;
2761 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2762 ptrdiff_t startpos
IF_LINT (= 0);
2763 int top
IF_LINT (= 0), new_top
, resize_failed
;
2765 w
= decode_valid_window (window
);
2766 XSETWINDOW (window
, w
);
2767 f
= XFRAME (w
->frame
);
2770 /* ROOT is the frame's root window. */
2772 root
= FRAME_ROOT_WINDOW (f
);
2776 /* ROOT must be an ancestor of WINDOW. */
2778 r
= decode_valid_window (root
);
2779 pwindow
= XWINDOW (window
)->parent
;
2780 while (!NILP (pwindow
))
2781 if (EQ (pwindow
, root
))
2784 pwindow
= XWINDOW (pwindow
)->parent
;
2785 if (!EQ (pwindow
, root
))
2786 error ("Specified root is not an ancestor of specified window");
2789 if (EQ (window
, root
))
2792 /* I don't understand the "top > 0" part below. If we deal with a
2793 standalone minibuffer it would have been caught by the preceding
2795 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2796 error ("Can't expand minibuffer to full frame");
2798 if (!NILP (w
->buffer
))
2800 startpos
= marker_position (w
->start
);
2801 top
= WINDOW_TOP_EDGE_LINE (w
)
2802 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2803 /* Make sure WINDOW is the frame's selected window. */
2804 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2806 if (EQ (selected_frame
, w
->frame
))
2807 Fselect_window (window
, Qnil
);
2809 fset_selected_window (f
, window
);
2814 /* See if the frame's selected window is a part of the window
2815 subtree rooted at WINDOW, by finding all the selected window's
2816 parents and comparing each one with WINDOW. If it isn't we
2817 need a new selected window for this frame. */
2818 swindow
= FRAME_SELECTED_WINDOW (f
);
2822 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2823 pwindow
= XWINDOW (pwindow
)->parent
;
2825 if (EQ (window
, pwindow
))
2826 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2827 as the new selected window. */
2830 /* Else try the previous window of SWINDOW. */
2831 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2834 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2836 if (EQ (selected_frame
, w
->frame
))
2837 Fselect_window (swindow
, Qnil
);
2839 fset_selected_window (f
, swindow
);
2844 if (!FRAME_INITIAL_P (f
))
2846 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2848 /* We are going to free the glyph matrices of WINDOW, and with
2849 that we might lose any information about glyph rows that have
2850 some of their glyphs highlighted in mouse face. (These rows
2851 are marked with a non-zero mouse_face_p flag.) If WINDOW
2852 indeed has some glyphs highlighted in mouse face, signal to
2853 frame's up-to-date hook that mouse highlight was overwritten,
2854 so that it will arrange for redisplaying the highlight. */
2855 if (EQ (hlinfo
->mouse_face_window
, window
))
2857 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2858 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2859 hlinfo
->mouse_face_window
= Qnil
;
2862 free_window_matrices (r
);
2864 windows_or_buffers_changed
++;
2865 Vwindow_list
= Qnil
;
2866 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2869 if (NILP (w
->buffer
))
2871 /* Resize child windows vertically. */
2872 XSETINT (delta
, XINT (r
->total_lines
)
2873 - XINT (w
->total_lines
));
2874 wset_top_line (w
, r
->top_line
);
2875 resize_root_window (window
, delta
, Qnil
, Qnil
);
2876 if (window_resize_check (w
, 0))
2877 window_resize_apply (w
, 0);
2880 resize_root_window (window
, delta
, Qnil
, Qt
);
2881 if (window_resize_check (w
, 0))
2882 window_resize_apply (w
, 0);
2887 /* Resize child windows horizontally. */
2890 wset_left_col (w
, r
->left_col
);
2892 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2893 wset_left_col (w
, r
->left_col
);
2894 resize_root_window (window
, delta
, Qt
, Qnil
);
2895 if (window_resize_check (w
, 1))
2896 window_resize_apply (w
, 1);
2899 resize_root_window (window
, delta
, Qt
, Qt
);
2900 if (window_resize_check (w
, 1))
2901 window_resize_apply (w
, 1);
2908 /* Play safe, if we still can ... */
2911 w
= XWINDOW (window
);
2915 /* Cleanly unlink WINDOW from window-tree. */
2916 if (!NILP (w
->prev
))
2917 /* Get SIBLING above (on the left of) WINDOW. */
2920 s
= XWINDOW (sibling
);
2921 wset_next (s
, w
->next
);
2922 if (!NILP (s
->next
))
2923 wset_prev (XWINDOW (s
->next
), sibling
);
2926 /* Get SIBLING below (on the right of) WINDOW. */
2929 s
= XWINDOW (sibling
);
2930 wset_prev (s
, Qnil
);
2931 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2932 wset_vchild (XWINDOW (w
->parent
), sibling
);
2934 wset_hchild (XWINDOW (w
->parent
), sibling
);
2937 /* Delete ROOT and all child windows of ROOT. */
2938 if (!NILP (r
->vchild
))
2940 delete_all_child_windows (r
->vchild
);
2941 wset_vchild (r
, Qnil
);
2943 else if (!NILP (r
->hchild
))
2945 delete_all_child_windows (r
->hchild
);
2946 wset_hchild (r
, Qnil
);
2949 replace_window (root
, window
, 1);
2951 /* This must become SWINDOW anyway ....... */
2952 if (!NILP (w
->buffer
) && !resize_failed
)
2954 /* Try to minimize scrolling, by setting the window start to the
2955 point will cause the text at the old window start to be at the
2956 same place on the frame. But don't try to do this if the
2957 window start is outside the visible portion (as might happen
2958 when the display is not current, due to typeahead). */
2959 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2961 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2962 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2964 struct position pos
;
2965 struct buffer
*obuf
= current_buffer
;
2967 Fset_buffer (w
->buffer
);
2968 /* This computation used to temporarily move point, but that
2969 can have unwanted side effects due to text properties. */
2970 pos
= *vmotion (startpos
, -top
, w
);
2972 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2973 wset_window_end_valid (w
, Qnil
);
2974 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2975 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2976 /* We need to do this, so that the window-scroll-functions
2978 w
->optional_new_start
= 1;
2980 set_buffer_internal (obuf
);
2987 run_window_configuration_change_hook (f
);
2994 replace_buffer_in_windows (Lisp_Object buffer
)
2996 call1 (Qreplace_buffer_in_windows
, buffer
);
2999 /* If BUFFER is shown in a window, safely replace it with some other
3000 buffer in all windows of all frames, even those on other keyboards. */
3003 replace_buffer_in_windows_safely (Lisp_Object buffer
)
3005 if (buffer_window_count (XBUFFER (buffer
)))
3007 Lisp_Object tail
, frame
;
3009 /* A single call to window_loop won't do the job because it only
3010 considers frames on the current keyboard. So loop manually over
3011 frames, and handle each one. */
3012 FOR_EACH_FRAME (tail
, frame
)
3013 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
3017 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
3018 minimum allowable size. */
3021 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
3023 /* For height, we have to see:
3024 how many windows the frame has at minimum (one or two),
3025 and whether it has a menu bar or other special stuff at the top. */
3027 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
3028 ? MIN_SAFE_WINDOW_HEIGHT
3029 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
3031 if (FRAME_TOP_MARGIN (frame
) > 0)
3032 min_height
+= FRAME_TOP_MARGIN (frame
);
3034 if (*rows
< min_height
)
3036 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
3037 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3040 /* Adjust the margins of window W if text area is too small.
3041 Return 1 if window width is ok after adjustment; 0 if window
3042 is still too narrow. */
3045 adjust_window_margins (struct window
*w
)
3047 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3048 - WINDOW_FRINGE_COLS (w
)
3049 - WINDOW_SCROLL_BAR_COLS (w
));
3050 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3051 + WINDOW_RIGHT_MARGIN_COLS (w
));
3053 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3056 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3059 /* Window's text area is too narrow, but reducing the window
3060 margins will fix that. */
3061 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3062 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3064 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3066 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3067 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3070 wset_right_margin_cols (w
, make_number (margin_cols
));
3073 wset_left_margin_cols (w
, make_number (margin_cols
));
3077 /* The following three routines are needed for running a window's
3078 configuration change hook. */
3080 run_funs (Lisp_Object funs
)
3082 for (; CONSP (funs
); funs
= XCDR (funs
))
3083 if (!EQ (XCAR (funs
), Qt
))
3084 call0 (XCAR (funs
));
3088 select_window_norecord (Lisp_Object window
)
3090 return WINDOW_LIVE_P (window
)
3091 ? Fselect_window (window
, Qt
) : selected_window
;
3095 select_frame_norecord (Lisp_Object frame
)
3097 return FRAME_LIVE_P (XFRAME (frame
))
3098 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3102 run_window_configuration_change_hook (struct frame
*f
)
3104 ptrdiff_t count
= SPECPDL_INDEX ();
3105 Lisp_Object frame
, global_wcch
3106 = Fdefault_value (Qwindow_configuration_change_hook
);
3107 XSETFRAME (frame
, f
);
3109 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3112 /* Use the right buffer. Matters when running the local hooks. */
3113 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3115 record_unwind_current_buffer ();
3116 Fset_buffer (Fwindow_buffer (Qnil
));
3119 if (SELECTED_FRAME () != f
)
3121 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3122 select_frame_norecord (frame
);
3125 /* Look for buffer-local values. */
3127 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3128 for (; CONSP (windows
); windows
= XCDR (windows
))
3130 Lisp_Object window
= XCAR (windows
);
3131 Lisp_Object buffer
= Fwindow_buffer (window
);
3132 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3135 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3136 record_unwind_protect (select_window_norecord
, Fselected_window ());
3137 select_window_norecord (window
);
3138 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3140 unbind_to (inner_count
, Qnil
);
3145 run_funs (global_wcch
);
3146 unbind_to (count
, Qnil
);
3149 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3150 Srun_window_configuration_change_hook
, 0, 1, 0,
3151 doc
: /* Run `window-configuration-change-hook' for FRAME.
3152 If FRAME is omitted or nil, it defaults to the selected frame. */)
3155 run_window_configuration_change_hook (decode_live_frame (frame
));
3159 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3160 means it's allowed to run hooks. See make_frame for a case where
3161 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3162 margins, fringes, and scroll-bar settings of the window are not
3163 reset from the buffer's local settings. */
3166 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3168 struct window
*w
= XWINDOW (window
);
3169 struct buffer
*b
= XBUFFER (buffer
);
3170 ptrdiff_t count
= SPECPDL_INDEX ();
3171 int samebuf
= EQ (buffer
, w
->buffer
);
3173 wset_buffer (w
, buffer
);
3175 if (EQ (window
, selected_window
))
3176 bset_last_selected_window (b
, window
);
3178 /* Let redisplay errors through. */
3179 b
->display_error_modiff
= 0;
3181 /* Update time stamps of buffer display. */
3182 if (INTEGERP (BVAR (b
, display_count
)))
3183 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3184 bset_display_time (b
, Fcurrent_time ());
3186 wset_window_end_pos (w
, make_number (0));
3187 wset_window_end_vpos (w
, make_number (0));
3188 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3189 wset_window_end_valid (w
, Qnil
);
3190 if (!(keep_margins_p
&& samebuf
))
3191 { /* If we're not actually changing the buffer, don't reset hscroll and
3192 vscroll. This case happens for example when called from
3193 change_frame_size_1, where we use a dummy call to
3194 Fset_window_buffer on the frame's selected window (and no other)
3195 just in order to run window-configuration-change-hook.
3196 Resetting hscroll and vscroll here is problematic for things like
3197 image-mode and doc-view-mode since it resets the image's position
3198 whenever we resize the frame. */
3199 w
->hscroll
= w
->min_hscroll
= 0;
3201 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3202 set_marker_restricted (w
->start
,
3203 make_number (b
->last_window_start
),
3205 w
->start_at_line_beg
= 0;
3207 w
->last_modified
= 0;
3208 w
->last_overlay_modified
= 0;
3210 /* Maybe we could move this into the `if' but it's not obviously safe and
3211 I doubt it's worth the trouble. */
3212 windows_or_buffers_changed
++;
3214 /* We must select BUFFER for running the window-scroll-functions. */
3215 /* We can't check ! NILP (Vwindow_scroll_functions) here
3216 because that might itself be a local variable. */
3217 if (window_initialized
)
3219 record_unwind_current_buffer ();
3220 Fset_buffer (buffer
);
3223 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3225 if (!keep_margins_p
)
3227 /* Set left and right marginal area width etc. from buffer. */
3229 /* This may call adjust_window_margins three times, so
3230 temporarily disable window margins. */
3231 Lisp_Object save_left
= w
->left_margin_cols
;
3232 Lisp_Object save_right
= w
->right_margin_cols
;
3234 wset_left_margin_cols (w
, Qnil
);
3235 wset_right_margin_cols (w
, Qnil
);
3237 Fset_window_fringes (window
,
3238 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3239 BVAR (b
, fringes_outside_margins
));
3241 Fset_window_scroll_bars (window
,
3242 BVAR (b
, scroll_bar_width
),
3243 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3245 wset_left_margin_cols (w
, save_left
);
3246 wset_right_margin_cols (w
, save_right
);
3248 Fset_window_margins (window
,
3249 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3254 if (! NILP (Vwindow_scroll_functions
))
3255 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3256 Fmarker_position (w
->start
));
3257 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3260 unbind_to (count
, Qnil
);
3263 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3264 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3265 WINDOW must be a live window and defaults to the selected one.
3266 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3268 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3269 display margins, fringe widths, and scroll bar settings are preserved;
3270 the default is to reset these from the local settings for BUFFER-OR-NAME
3271 or the frame defaults. Return nil.
3273 This function throws an error when WINDOW is strongly dedicated to its
3274 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3275 already display BUFFER-OR-NAME.
3277 This function runs `window-scroll-functions' before running
3278 `window-configuration-change-hook'. */)
3279 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3281 register Lisp_Object tem
, buffer
;
3282 register struct window
*w
= decode_live_window (window
);
3284 XSETWINDOW (window
, w
);
3285 buffer
= Fget_buffer (buffer_or_name
);
3286 CHECK_BUFFER (buffer
);
3287 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3288 error ("Attempt to display deleted buffer");
3292 error ("Window is deleted");
3295 if (!EQ (tem
, buffer
))
3297 if (EQ (w
->dedicated
, Qt
))
3298 /* WINDOW is strongly dedicated to its buffer, signal an
3300 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3302 /* WINDOW is weakly dedicated to its buffer, reset
3304 wset_dedicated (w
, Qnil
);
3306 call1 (Qrecord_window_buffer
, window
);
3312 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3318 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3320 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3323 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3325 doc
: /* Force all windows to be updated on next redisplay.
3326 If optional arg OBJECT is a window, force redisplay of that window only.
3327 If OBJECT is a buffer or buffer name, force redisplay of all windows
3328 displaying that buffer. */)
3329 (Lisp_Object object
)
3333 windows_or_buffers_changed
++;
3334 update_mode_lines
++;
3338 if (WINDOWP (object
))
3340 struct window
*w
= XWINDOW (object
);
3341 mark_window_display_accurate (object
, 0);
3342 w
->update_mode_line
= 1;
3343 if (BUFFERP (w
->buffer
))
3344 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3345 ++update_mode_lines
;
3349 if (STRINGP (object
))
3350 object
= Fget_buffer (object
);
3351 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
))
3352 && buffer_window_count (XBUFFER (object
)))
3354 /* If buffer is live and shown in at least one window, find
3355 all windows showing this buffer and force update of them. */
3356 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3357 return NILP (object
) ? Qnil
: Qt
;
3360 /* If nothing suitable was found, just return.
3361 We could signal an error, but this feature will typically be used
3362 asynchronously in timers or process sentinels, so we don't. */
3366 /* Obsolete since 24.3. */
3368 temp_output_buffer_show (register Lisp_Object buf
)
3370 register struct buffer
*old
= current_buffer
;
3371 register Lisp_Object window
;
3372 register struct window
*w
;
3374 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3377 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3381 set_buffer_internal (old
);
3383 if (!NILP (Vtemp_buffer_show_function
))
3384 call1 (Vtemp_buffer_show_function
, buf
);
3387 window
= display_buffer (buf
, Qnil
, Qnil
);
3389 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3390 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3391 Vminibuf_scroll_window
= window
;
3392 w
= XWINDOW (window
);
3395 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3396 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3398 /* Run temp-buffer-show-hook, with the chosen window selected
3399 and its buffer current. */
3401 ptrdiff_t count
= SPECPDL_INDEX ();
3402 Lisp_Object prev_window
, prev_buffer
;
3403 prev_window
= selected_window
;
3404 XSETBUFFER (prev_buffer
, old
);
3406 /* Select the window that was chosen, for running the hook.
3407 Note: Both Fselect_window and select_window_norecord may
3408 set-buffer to the buffer displayed in the window,
3409 so we need to save the current buffer. --stef */
3410 record_unwind_protect (Fset_buffer
, prev_buffer
);
3411 record_unwind_protect (select_window_norecord
, prev_window
);
3412 Fselect_window (window
, Qt
);
3413 Fset_buffer (w
->buffer
);
3414 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3415 unbind_to (count
, Qnil
);
3420 /* Make new window, have it replace WINDOW in window-tree, and make
3421 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3422 horizontal child). */
3424 make_parent_window (Lisp_Object window
, int horflag
)
3427 register struct window
*o
, *p
;
3429 o
= XWINDOW (window
);
3430 p
= allocate_window ();
3431 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3432 (char *) o
+ sizeof (struct vectorlike_header
),
3433 word_size
* VECSIZE (struct window
));
3434 /* P's buffer slot may change from nil to a buffer. */
3435 adjust_window_count (p
, 1);
3436 XSETWINDOW (parent
, p
);
3438 p
->sequence_number
= ++sequence_number
;
3440 replace_window (window
, parent
, 1);
3442 wset_next (o
, Qnil
);
3443 wset_prev (o
, Qnil
);
3444 wset_parent (o
, parent
);
3446 wset_hchild (p
, horflag
? window
: Qnil
);
3447 wset_vchild (p
, horflag
? Qnil
: window
);
3448 wset_start (p
, Qnil
);
3449 wset_pointm (p
, Qnil
);
3450 wset_buffer (p
, Qnil
);
3451 wset_combination_limit (p
, Qnil
);
3452 wset_window_parameters (p
, Qnil
);
3455 /* Make new window from scratch. */
3460 register struct window
*w
;
3462 w
= allocate_window ();
3463 /* Initialize Lisp data. Note that allocate_window initializes all
3464 Lisp data to nil, so do it only for slots which should not be nil. */
3465 wset_left_col (w
, make_number (0));
3466 wset_top_line (w
, make_number (0));
3467 wset_total_lines (w
, make_number (0));
3468 wset_total_cols (w
, make_number (0));
3469 wset_normal_lines (w
, make_float (1.0));
3470 wset_normal_cols (w
, make_float (1.0));
3471 wset_new_total (w
, make_number (0));
3472 wset_new_normal (w
, make_number (0));
3473 wset_start (w
, Fmake_marker ());
3474 wset_pointm (w
, Fmake_marker ());
3475 wset_vertical_scroll_bar_type (w
, Qt
);
3476 wset_window_end_pos (w
, make_number (0));
3477 wset_window_end_vpos (w
, make_number (0));
3478 /* These Lisp fields are marked specially so they're not set to nil by
3480 wset_prev_buffers (w
, Qnil
);
3481 wset_next_buffers (w
, Qnil
);
3483 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3484 non-Lisp data, so do it only for slots which should not be zero. */
3485 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3486 w
->phys_cursor_type
= -1;
3487 w
->phys_cursor_width
= -1;
3488 w
->sequence_number
= ++sequence_number
;
3490 /* Reset window_list. */
3491 Vwindow_list
= Qnil
;
3492 /* Return window. */
3493 XSETWINDOW (window
, w
);
3497 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3498 doc
: /* Set new total size of WINDOW to SIZE.
3499 WINDOW must be a valid window and defaults to the selected one.
3502 Optional argument ADD non-nil means add SIZE to the new total size of
3503 WINDOW and return the sum.
3505 Note: This function does not operate on any child windows of WINDOW. */)
3506 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3508 struct window
*w
= decode_valid_window (window
);
3510 CHECK_NUMBER (size
);
3512 wset_new_total (w
, size
);
3514 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3516 return w
->new_total
;
3519 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3520 doc
: /* Set new normal size of WINDOW to SIZE.
3521 WINDOW must be a valid window and defaults to the selected one.
3524 Note: This function does not operate on any child windows of WINDOW. */)
3525 (Lisp_Object window
, Lisp_Object size
)
3527 wset_new_normal (decode_valid_window (window
), size
);
3531 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3532 non-zero) to w->new_total would result in correct heights (widths)
3533 for window W and recursively all child windows of W.
3535 Note: This function does not check any of `window-fixed-size-p',
3536 `window-min-height' or `window-min-width'. It does check that window
3537 sizes do not drop below one line (two columns). */
3539 window_resize_check (struct window
*w
, int horflag
)
3543 if (!NILP (w
->vchild
))
3544 /* W is a vertical combination. */
3546 c
= XWINDOW (w
->vchild
);
3548 /* All child windows of W must have the same width as W. */
3552 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3553 || !window_resize_check (c
, horflag
))
3555 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3560 /* The sum of the heights of the child windows of W must equal
3563 int sum_of_sizes
= 0;
3566 if (!window_resize_check (c
, horflag
))
3568 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3569 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3571 return (sum_of_sizes
== XINT (w
->new_total
));
3574 else if (!NILP (w
->hchild
))
3575 /* W is a horizontal combination. */
3577 c
= XWINDOW (w
->hchild
);
3579 /* The sum of the widths of the child windows of W must equal W's
3582 int sum_of_sizes
= 0;
3585 if (!window_resize_check (c
, horflag
))
3587 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3588 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3590 return (sum_of_sizes
== XINT (w
->new_total
));
3593 /* All child windows of W must have the same height as W. */
3597 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3598 || !window_resize_check (c
, horflag
))
3600 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3606 /* A leaf window. Make sure it's not too small. The following
3607 hardcodes the values of `window-safe-min-width' (2) and
3608 `window-safe-min-height' (1) which are defined in window.el. */
3609 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3612 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3613 w->new_total for window W and recursively all child windows of W.
3614 Also calculate and assign the new vertical (horizontal) start
3615 positions of each of these windows.
3617 This function does not perform any error checks. Make sure you have
3618 run window_resize_check on W before applying this function. */
3620 window_resize_apply (struct window
*w
, int horflag
)
3625 /* Note: Assigning new_normal requires that the new total size of the
3626 parent window has been set *before*. */
3629 wset_total_cols (w
, w
->new_total
);
3630 if (NUMBERP (w
->new_normal
))
3631 wset_normal_cols (w
, w
->new_normal
);
3633 pos
= XINT (w
->left_col
);
3637 wset_total_lines (w
, w
->new_total
);
3638 if (NUMBERP (w
->new_normal
))
3639 wset_normal_lines (w
, w
->new_normal
);
3641 pos
= XINT (w
->top_line
);
3644 if (!NILP (w
->vchild
))
3645 /* W is a vertical combination. */
3647 c
= XWINDOW (w
->vchild
);
3651 wset_left_col (c
, make_number (pos
));
3653 wset_top_line (c
, make_number (pos
));
3654 window_resize_apply (c
, horflag
);
3656 pos
= pos
+ XINT (c
->total_lines
);
3657 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3660 else if (!NILP (w
->hchild
))
3661 /* W is a horizontal combination. */
3663 c
= XWINDOW (w
->hchild
);
3667 wset_left_col (c
, make_number (pos
));
3669 wset_top_line (c
, make_number (pos
));
3670 window_resize_apply (c
, horflag
);
3672 pos
= pos
+ XINT (c
->total_cols
);
3673 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3677 /* Clear out some redisplay caches. */
3678 w
->last_modified
= 0;
3679 w
->last_overlay_modified
= 0;
3683 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3684 doc
: /* Apply requested size values for window-tree of FRAME.
3685 If FRAME is omitted or nil, it defaults to the selected frame.
3687 Optional argument HORIZONTAL omitted or nil means apply requested
3688 height values. HORIZONTAL non-nil means apply requested width values.
3690 This function checks whether the requested values sum up to a valid
3691 window layout, recursively assigns the new sizes of all child windows
3692 and calculates and assigns the new start positions of these windows.
3694 Note: This function does not check any of `window-fixed-size-p',
3695 `window-min-height' or `window-min-width'. All these checks have to
3696 be applied on the Elisp level. */)
3697 (Lisp_Object frame
, Lisp_Object horizontal
)
3699 struct frame
*f
= decode_live_frame (frame
);
3700 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3701 int horflag
= !NILP (horizontal
);
3703 if (!window_resize_check (r
, horflag
)
3704 || ! EQ (r
->new_total
,
3705 (horflag
? r
->total_cols
: r
->total_lines
)))
3709 window_resize_apply (r
, horflag
);
3711 windows_or_buffers_changed
++;
3712 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3717 run_window_configuration_change_hook (f
);
3723 /* Resize frame F's windows when number of lines of F is set to SIZE.
3724 HORFLAG 1 means resize windows when number of columns of F is set to
3727 This function can delete all windows but the selected one in order to
3728 satisfy the request. The result will be meaningful if and only if
3729 F's windows have meaningful sizes when you call this. */
3731 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3733 Lisp_Object root
= f
->root_window
;
3734 struct window
*r
= XWINDOW (root
);
3735 Lisp_Object mini
= f
->minibuffer_window
;
3737 /* new_size is the new size of the frame's root window. */
3738 int new_size
= (horflag
3741 - FRAME_TOP_MARGIN (f
)
3742 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3745 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3746 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3747 /* For a leaf root window just set the size. */
3749 wset_total_cols (r
, make_number (new_size
));
3751 wset_total_lines (r
, make_number (new_size
));
3754 /* old_size is the old size of the frame's root window. */
3755 int old_size
= XFASTINT (horflag
? r
->total_cols
3759 XSETINT (delta
, new_size
- old_size
);
3760 /* Try a "normal" resize first. */
3761 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3762 if (window_resize_check (r
, horflag
)
3763 && new_size
== XINT (r
->new_total
))
3764 window_resize_apply (r
, horflag
);
3767 /* Try with "reasonable" minimum sizes next. */
3768 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3769 if (window_resize_check (r
, horflag
)
3770 && new_size
== XINT (r
->new_total
))
3771 window_resize_apply (r
, horflag
);
3774 /* Finally, try with "safe" minimum sizes. */
3775 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3776 if (window_resize_check (r
, horflag
)
3777 && new_size
== XINT (r
->new_total
))
3778 window_resize_apply (r
, horflag
);
3781 /* We lost. Delete all windows but the frame's
3783 root
= f
->selected_window
;
3784 Fdelete_other_windows_internal (root
, Qnil
);
3786 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3788 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3794 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3798 wset_total_cols (m
, make_number (size
));
3801 /* Are we sure we always want 1 line here? */
3802 wset_total_lines (m
, make_number (1));
3804 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3808 windows_or_buffers_changed
++;
3812 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3813 doc
: /* Split window OLD.
3814 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3815 new window. In any case TOTAL-SIZE must be a positive integer.
3817 Third argument SIDE nil (or `below') specifies that the new window shall
3818 be located below WINDOW. SIDE `above' means the new window shall be
3819 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3820 lines of the new window including space reserved for the mode and/or
3823 SIDE t (or `right') specifies that the new window shall be located on
3824 the right side of WINDOW. SIDE `left' means the new window shall be
3825 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3826 number of columns of the new window including space reserved for fringes
3827 and the scrollbar or a divider column.
3829 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3830 according to the SIDE argument.
3832 The new total and normal sizes of all involved windows must have been
3833 set correctly. See the code of `split-window' for how this is done. */)
3834 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3836 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3837 parent window or an internal window we have to install as OLD's new
3838 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3839 provided OLD is a leaf window, or to the frame's selected window.
3840 NEW (*n) is the new window created with some parameters taken from
3842 register Lisp_Object
new, frame
, reference
;
3843 register struct window
*o
, *p
, *n
, *r
;
3846 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3847 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3848 int combination_limit
= 0;
3852 frame
= WINDOW_FRAME (o
);
3855 CHECK_NUMBER (total_size
);
3857 /* Set combination_limit to 1 if we have to make a new parent window.
3858 We do that if either `window-combination-limit' is t, or OLD has no
3859 parent, or OLD is ortho-combined. */
3861 EQ (Vwindow_combination_limit
, Qt
)
3864 ? (XWINDOW (o
->parent
)->hchild
)
3865 : (XWINDOW (o
->parent
)->vchild
));
3867 /* We need a live reference window to initialize some parameters. */
3868 if (WINDOW_LIVE_P (old
))
3869 /* OLD is live, use it as reference window. */
3872 /* Use the frame's selected window as reference window. */
3873 reference
= FRAME_SELECTED_WINDOW (f
);
3874 r
= XWINDOW (reference
);
3876 /* The following bugs are caught by `split-window'. */
3877 if (MINI_WINDOW_P (o
))
3878 error ("Attempt to split minibuffer window");
3879 else if (XINT (total_size
) < (horflag
? 2 : 1))
3880 error ("Size of new window too small (after split)");
3881 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3882 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3885 p
= XWINDOW (o
->parent
);
3886 /* Temporarily pretend we split the parent window. */
3888 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3889 - XINT (total_size
)));
3890 if (!window_resize_check (p
, horflag
))
3891 error ("Window sizes don't fit");
3893 /* Undo the temporary pretension. */
3894 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3898 if (!window_resize_check (o
, horflag
))
3899 error ("Resizing old window failed");
3900 else if (XINT (total_size
) + XINT (o
->new_total
)
3901 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3902 error ("Sum of sizes of old and new window don't fit");
3905 /* This is our point of no return. */
3906 if (combination_limit
)
3908 /* Save the old value of o->normal_cols/lines. It gets corrupted
3909 by make_parent_window and we need it below for assigning it to
3911 Lisp_Object new_normal
3912 = horflag
? o
->normal_cols
: o
->normal_lines
;
3914 make_parent_window (old
, horflag
);
3915 p
= XWINDOW (o
->parent
);
3916 if (EQ (Vwindow_combination_limit
, Qt
))
3917 /* Store t in the new parent's combination_limit slot to avoid
3918 that its children get merged into another window. */
3919 wset_combination_limit (p
, Qt
);
3920 /* These get applied below. */
3921 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3922 wset_new_normal (p
, new_normal
);
3925 p
= XWINDOW (o
->parent
);
3927 windows_or_buffers_changed
++;
3928 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3929 new = make_window ();
3931 wset_frame (n
, frame
);
3932 wset_parent (n
, o
->parent
);
3933 wset_vchild (n
, Qnil
);
3934 wset_hchild (n
, Qnil
);
3936 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3938 wset_prev (n
, o
->prev
);
3941 wset_hchild (p
, new);
3943 wset_vchild (p
, new);
3945 wset_next (XWINDOW (n
->prev
), new);
3951 wset_next (n
, o
->next
);
3952 if (!NILP (n
->next
))
3953 wset_prev (XWINDOW (n
->next
), new);
3958 wset_window_end_valid (n
, Qnil
);
3959 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3961 /* Get special geometry settings from reference window. */
3962 wset_left_margin_cols (n
, r
->left_margin_cols
);
3963 wset_right_margin_cols (n
, r
->right_margin_cols
);
3964 wset_left_fringe_width (n
, r
->left_fringe_width
);
3965 wset_right_fringe_width (n
, r
->right_fringe_width
);
3966 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3967 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3968 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3970 /* Directly assign orthogonal coordinates and sizes. */
3973 wset_top_line (n
, o
->top_line
);
3974 wset_total_lines (n
, o
->total_lines
);
3978 wset_left_col (n
, o
->left_col
);
3979 wset_total_cols (n
, o
->total_cols
);
3982 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3983 get them ready here. */
3984 wset_new_total (n
, total_size
);
3985 wset_new_normal (n
, normal_size
);
3988 window_resize_apply (p
, horflag
);
3990 /* Set buffer of NEW to buffer of reference window. Don't run
3992 set_window_buffer (new, r
->buffer
, 0, 1);
3995 /* Maybe we should run the scroll functions in Elisp (which already
3996 runs the configuration change hook). */
3997 if (! NILP (Vwindow_scroll_functions
))
3998 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3999 Fmarker_position (n
->start
));
4005 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
4006 doc
: /* Remove WINDOW from its frame.
4007 WINDOW defaults to the selected window. Return nil.
4008 Signal an error when WINDOW is the only window on its frame. */)
4009 (register Lisp_Object window
)
4011 register Lisp_Object parent
, sibling
, frame
, root
;
4012 struct window
*w
, *p
, *s
, *r
;
4015 int before_sibling
= 0;
4017 w
= decode_any_window (window
);
4018 XSETWINDOW (window
, w
);
4019 if (NILP (w
->buffer
)
4020 && NILP (w
->hchild
) && NILP (w
->vchild
))
4021 /* It's a no-op to delete an already deleted window. */
4026 /* Never delete a minibuffer or frame root window. */
4027 error ("Attempt to delete minibuffer or sole ordinary window");
4028 else if (NILP (w
->prev
) && NILP (w
->next
))
4029 /* Rather bow out here, this case should be handled on the Elisp
4031 error ("Attempt to delete sole window of parent");
4033 p
= XWINDOW (parent
);
4034 horflag
= NILP (p
->vchild
);
4036 frame
= WINDOW_FRAME (w
);
4039 root
= FRAME_ROOT_WINDOW (f
);
4042 /* Unlink WINDOW from window tree. */
4044 /* Get SIBLING below (on the right of) WINDOW. */
4046 /* before_sibling 1 means WINDOW is the first child of its
4047 parent and thus before the sibling. */
4050 s
= XWINDOW (sibling
);
4051 wset_prev (s
, Qnil
);
4053 wset_hchild (p
, sibling
);
4055 wset_vchild (p
, sibling
);
4058 /* Get SIBLING above (on the left of) WINDOW. */
4061 s
= XWINDOW (sibling
);
4062 wset_next (s
, w
->next
);
4063 if (!NILP (s
->next
))
4064 wset_prev (XWINDOW (s
->next
), sibling
);
4067 if (window_resize_check (r
, horflag
)
4068 && EQ (r
->new_total
,
4069 (horflag
? r
->total_cols
: r
->total_lines
)))
4070 /* We can delete WINDOW now. */
4075 window_resize_apply (p
, horflag
);
4077 /* If this window is referred to by the dpyinfo's mouse
4078 highlight, invalidate that slot to be safe (Bug#9904). */
4079 if (!FRAME_INITIAL_P (f
))
4081 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4083 if (EQ (hlinfo
->mouse_face_window
, window
))
4084 hlinfo
->mouse_face_window
= Qnil
;
4087 windows_or_buffers_changed
++;
4088 Vwindow_list
= Qnil
;
4089 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4091 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4092 free_window_matrices (w
);
4094 if (!NILP (w
->vchild
))
4096 delete_all_child_windows (w
->vchild
);
4097 wset_vchild (w
, Qnil
);
4099 else if (!NILP (w
->hchild
))
4101 delete_all_child_windows (w
->hchild
);
4102 wset_hchild (w
, Qnil
);
4104 else if (!NILP (w
->buffer
))
4107 unchain_marker (XMARKER (w
->pointm
));
4108 unchain_marker (XMARKER (w
->start
));
4109 wset_buffer (w
, Qnil
);
4112 if (NILP (s
->prev
) && NILP (s
->next
))
4113 /* A matrjoshka where SIBLING has become the only child of
4116 /* Put SIBLING into PARENT's place. */
4117 replace_window (parent
, sibling
, 0);
4118 /* Have SIBLING inherit the following three slot values from
4119 PARENT (the combination_limit slot is not inherited). */
4120 wset_normal_cols (s
, p
->normal_cols
);
4121 wset_normal_lines (s
, p
->normal_lines
);
4122 /* Mark PARENT as deleted. */
4123 wset_vchild (p
, Qnil
);
4124 wset_hchild (p
, Qnil
);
4125 /* Try to merge SIBLING into its new parent. */
4126 recombine_windows (sibling
);
4131 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4132 /* We deleted the frame's selected window. */
4134 /* Use the frame's first window as fallback ... */
4135 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4136 /* ... but preferably use its most recently used window. */
4137 Lisp_Object mru_window
;
4139 /* `get-mru-window' might fail for some reason so play it safe
4140 - promote the first window _without recording it_ first. */
4141 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4142 Fselect_window (new_selected_window
, Qt
);
4144 fset_selected_window (f
, new_selected_window
);
4148 /* Now look whether `get-mru-window' gets us something. */
4149 mru_window
= call1 (Qget_mru_window
, frame
);
4150 if (WINDOW_LIVE_P (mru_window
)
4151 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4152 new_selected_window
= mru_window
;
4154 /* If all ended up well, we now promote the mru window. */
4155 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4156 Fselect_window (new_selected_window
, Qnil
);
4158 fset_selected_window (f
, new_selected_window
);
4163 /* Must be run by the caller:
4164 run_window_configuration_change_hook (f); */
4167 /* We failed: Relink WINDOW into window tree. */
4171 wset_prev (s
, window
);
4173 wset_hchild (p
, window
);
4175 wset_vchild (p
, window
);
4179 wset_next (s
, window
);
4180 if (!NILP (w
->next
))
4181 wset_prev (XWINDOW (w
->next
), window
);
4183 error ("Deletion failed");
4189 /***********************************************************************
4190 Resizing Mini-Windows
4191 ***********************************************************************/
4193 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4196 grow_mini_window (struct window
*w
, int delta
)
4198 struct frame
*f
= XFRAME (w
->frame
);
4200 Lisp_Object root
, value
;
4202 eassert (MINI_WINDOW_P (w
));
4203 eassert (delta
>= 0);
4205 root
= FRAME_ROOT_WINDOW (f
);
4207 value
= call2 (Qwindow_resize_root_window_vertically
,
4208 root
, make_number (- delta
));
4209 if (INTEGERP (value
) && window_resize_check (r
, 0))
4212 window_resize_apply (r
, 0);
4214 /* Grow the mini-window. */
4216 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4218 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4219 w
->last_modified
= 0;
4220 w
->last_overlay_modified
= 0;
4222 windows_or_buffers_changed
++;
4229 /* Shrink mini-window W. */
4231 shrink_mini_window (struct window
*w
)
4233 struct frame
*f
= XFRAME (w
->frame
);
4235 Lisp_Object root
, value
;
4238 eassert (MINI_WINDOW_P (w
));
4240 size
= XINT (w
->total_lines
);
4243 root
= FRAME_ROOT_WINDOW (f
);
4245 value
= call2 (Qwindow_resize_root_window_vertically
,
4246 root
, make_number (size
- 1));
4247 if (INTEGERP (value
) && window_resize_check (r
, 0))
4250 window_resize_apply (r
, 0);
4252 /* Shrink the mini-window. */
4253 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4254 + XFASTINT (r
->total_lines
)));
4255 wset_total_lines (w
, make_number (1));
4257 w
->last_modified
= 0;
4258 w
->last_overlay_modified
= 0;
4260 windows_or_buffers_changed
++;
4264 /* If the above failed for whatever strange reason we must make a
4265 one window frame here. The same routine will be needed when
4266 shrinking the frame (and probably when making the initial
4267 *scratch* window). For the moment leave things as they are. */
4271 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4272 doc
: /* Resize minibuffer window WINDOW. */)
4273 (Lisp_Object window
)
4275 struct window
*w
= XWINDOW (window
);
4280 CHECK_WINDOW (window
);
4281 f
= XFRAME (w
->frame
);
4283 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4284 error ("Not a valid minibuffer window");
4285 else if (FRAME_MINIBUF_ONLY_P (f
))
4286 error ("Cannot resize a minibuffer-only frame");
4288 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4289 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4290 if (window_resize_check (r
, 0)
4291 && XINT (w
->new_total
) > 0
4292 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4295 window_resize_apply (r
, 0);
4297 wset_total_lines (w
, w
->new_total
);
4298 wset_top_line (w
, make_number (XINT (r
->top_line
)
4299 + XINT (r
->total_lines
)));
4301 windows_or_buffers_changed
++;
4302 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4306 run_window_configuration_change_hook (f
);
4309 else error ("Failed to resize minibuffer window");
4312 /* Mark window cursors off for all windows in the window tree rooted
4313 at W by setting their phys_cursor_on_p flag to zero. Called from
4314 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4315 the frame are cleared. */
4318 mark_window_cursors_off (struct window
*w
)
4322 if (!NILP (w
->hchild
))
4323 mark_window_cursors_off (XWINDOW (w
->hchild
));
4324 else if (!NILP (w
->vchild
))
4325 mark_window_cursors_off (XWINDOW (w
->vchild
));
4327 w
->phys_cursor_on_p
= 0;
4329 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4334 /* Return number of lines of text (not counting mode lines) in W. */
4337 window_internal_height (struct window
*w
)
4339 int ht
= XFASTINT (w
->total_lines
);
4341 if (!MINI_WINDOW_P (w
))
4343 if (!NILP (w
->parent
)
4344 || !NILP (w
->vchild
)
4345 || !NILP (w
->hchild
)
4348 || WINDOW_WANTS_MODELINE_P (w
))
4351 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4358 /************************************************************************
4360 ***********************************************************************/
4362 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4363 N screen-fulls, which is defined as the height of the window minus
4364 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4365 instead. Negative values of N mean scroll down. NOERROR non-zero
4366 means don't signal an error if we try to move over BEGV or ZV,
4370 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4373 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4375 /* If we must, use the pixel-based version which is much slower than
4376 the line-based one but can handle varying line heights. */
4377 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4378 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4380 window_scroll_line_based (window
, n
, whole
, noerror
);
4386 /* Implementation of window_scroll that works based on pixel line
4387 heights. See the comment of window_scroll for parameter
4391 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4394 struct window
*w
= XWINDOW (window
);
4395 struct text_pos start
;
4396 int this_scroll_margin
;
4397 /* True if we fiddled the window vscroll field without really scrolling. */
4399 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4400 void *itdata
= NULL
;
4402 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4403 /* Scrolling a minibuffer window via scroll bar when the echo area
4404 shows long text sometimes resets the minibuffer contents behind
4406 if (CHARPOS (start
) > ZV
)
4407 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4409 /* If PT is not visible in WINDOW, move back one half of
4410 the screen. Allow PT to be partially visible, otherwise
4411 something like (scroll-down 1) with PT in the line before
4412 the partially visible one would recenter. */
4414 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4416 itdata
= bidi_shelve_cache ();
4417 /* Move backward half the height of the window. Performance note:
4418 vmotion used here is about 10% faster, but would give wrong
4419 results for variable height lines. */
4420 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4421 it
.current_y
= it
.last_visible_y
;
4422 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4424 /* The function move_iterator_vertically may move over more than
4425 the specified y-distance. If it->w is small, e.g. a
4426 mini-buffer window, we may end up in front of the window's
4427 display area. This is the case when Start displaying at the
4428 start of the line containing PT in this case. */
4429 if (it
.current_y
<= 0)
4431 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4432 move_it_vertically_backward (&it
, 0);
4436 start
= it
.current
.pos
;
4437 bidi_unshelve_cache (itdata
, 0);
4439 else if (auto_window_vscroll_p
)
4441 if (rtop
|| rbot
) /* partially visible */
4444 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4446 dy
= max ((window_box_height (w
)
4447 - next_screen_context_lines
* dy
),
4453 /* Only vscroll backwards if already vscrolled forwards. */
4454 if (w
->vscroll
< 0 && rtop
> 0)
4456 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4457 Fset_window_vscroll (window
, make_number (px
), Qt
);
4463 /* Do vscroll if already vscrolled or only display line. */
4464 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4466 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4467 Fset_window_vscroll (window
, make_number (px
), Qt
);
4471 /* Maybe modify window start instead of scrolling. */
4472 if (rbot
> 0 || w
->vscroll
< 0)
4476 Fset_window_vscroll (window
, make_number (0), Qt
);
4477 /* If there are other text lines above the current row,
4478 move window start to current row. Else to next row. */
4480 spos
= XINT (Fline_beginning_position (Qnil
));
4482 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4483 set_marker_restricted (w
->start
, make_number (spos
),
4485 w
->start_at_line_beg
= 1;
4486 w
->update_mode_line
= 1;
4487 w
->last_modified
= 0;
4488 w
->last_overlay_modified
= 0;
4489 /* Set force_start so that redisplay_window will run the
4490 window-scroll-functions. */
4496 /* Cancel previous vscroll. */
4497 Fset_window_vscroll (window
, make_number (0), Qt
);
4500 itdata
= bidi_shelve_cache ();
4501 /* If scroll_preserve_screen_position is non-nil, we try to set
4502 point in the same window line as it is now, so get that line. */
4503 if (!NILP (Vscroll_preserve_screen_position
))
4505 /* We preserve the goal pixel coordinate across consecutive
4506 calls to scroll-up, scroll-down and other commands that
4507 have the `scroll-command' property. This avoids the
4508 possibility of point becoming "stuck" on a tall line when
4509 scrolling by one line. */
4510 if (window_scroll_pixel_based_preserve_y
< 0
4511 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4512 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4514 start_display (&it
, w
, start
);
4515 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4516 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4517 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4521 window_scroll_pixel_based_preserve_y
4522 = window_scroll_pixel_based_preserve_x
= -1;
4524 /* Move iterator it from start the specified distance forward or
4525 backward. The result is the new window start. */
4526 start_display (&it
, w
, start
);
4529 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4530 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4531 dy
= max ((window_box_height (w
)
4532 - next_screen_context_lines
* dy
),
4535 /* Note that move_it_vertically always moves the iterator to the
4536 start of a line. So, if the last line doesn't have a newline,
4537 we would end up at the start of the line ending at ZV. */
4540 move_it_vertically_backward (&it
, -dy
);
4541 /* Ensure we actually do move, e.g. in case we are currently
4542 looking at an image that is taller that the window height. */
4543 while (start_pos
== IT_CHARPOS (it
)
4544 && start_pos
> BEGV
)
4545 move_it_by_lines (&it
, -1);
4549 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4550 MOVE_TO_POS
| MOVE_TO_Y
);
4551 /* Ensure we actually do move, e.g. in case we are currently
4552 looking at an image that is taller that the window height. */
4553 while (start_pos
== IT_CHARPOS (it
)
4555 move_it_by_lines (&it
, 1);
4559 move_it_by_lines (&it
, n
);
4561 /* We failed if we find ZV is already on the screen (scrolling up,
4562 means there's nothing past the end), or if we can't start any
4563 earlier (scrolling down, means there's nothing past the top). */
4564 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4565 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4567 if (IT_CHARPOS (it
) == ZV
)
4569 if (it
.current_y
< it
.last_visible_y
4570 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4571 > it
.last_visible_y
))
4573 /* The last line was only partially visible, make it fully
4575 w
->vscroll
= (it
.last_visible_y
4576 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4577 adjust_glyphs (it
.f
);
4581 bidi_unshelve_cache (itdata
, 0);
4584 else if (n
< 0) /* could happen with empty buffers */
4585 xsignal0 (Qbeginning_of_buffer
);
4587 xsignal0 (Qend_of_buffer
);
4592 if (w
->vscroll
!= 0)
4593 /* The first line was only partially visible, make it fully
4598 bidi_unshelve_cache (itdata
, 0);
4602 xsignal0 (Qbeginning_of_buffer
);
4606 /* If control gets here, then we vscrolled. */
4608 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4610 /* Don't try to change the window start below. */
4616 ptrdiff_t pos
= IT_CHARPOS (it
);
4619 /* If in the middle of a multi-glyph character move forward to
4620 the next character. */
4621 if (in_display_vector_p (&it
))
4624 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4627 /* Set the window start, and set up the window for redisplay. */
4628 set_marker_restricted (w
->start
, make_number (pos
),
4630 bytepos
= marker_byte_position (w
->start
);
4631 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4632 w
->update_mode_line
= 1;
4633 w
->last_modified
= 0;
4634 w
->last_overlay_modified
= 0;
4635 /* Set force_start so that redisplay_window will run the
4636 window-scroll-functions. */
4640 /* The rest of this function uses current_y in a nonstandard way,
4641 not including the height of the header line if any. */
4642 it
.current_y
= it
.vpos
= 0;
4644 /* Move PT out of scroll margins.
4645 This code wants current_y to be zero at the window start position
4646 even if there is a header line. */
4647 this_scroll_margin
= max (0, scroll_margin
);
4649 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4650 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4654 /* We moved the window start towards ZV, so PT may be now
4655 in the scroll margin at the top. */
4656 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4657 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4658 && (NILP (Vscroll_preserve_screen_position
)
4659 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4660 /* We found PT at a legitimate height. Leave it alone. */
4662 else if (window_scroll_pixel_based_preserve_y
>= 0)
4664 /* If we have a header line, take account of it.
4665 This is necessary because we set it.current_y to 0, above. */
4666 move_it_to (&it
, -1,
4667 window_scroll_pixel_based_preserve_x
,
4668 window_scroll_pixel_based_preserve_y
4669 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4670 -1, MOVE_TO_Y
| MOVE_TO_X
);
4671 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4675 while (it
.current_y
< this_scroll_margin
)
4677 int prev
= it
.current_y
;
4678 move_it_by_lines (&it
, 1);
4679 if (prev
== it
.current_y
)
4682 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4687 ptrdiff_t charpos
, bytepos
;
4690 /* Save our position, for the
4691 window_scroll_pixel_based_preserve_y case. */
4692 charpos
= IT_CHARPOS (it
);
4693 bytepos
= IT_BYTEPOS (it
);
4695 /* We moved the window start towards BEGV, so PT may be now
4696 in the scroll margin at the bottom. */
4697 move_it_to (&it
, PT
, -1,
4698 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4699 - this_scroll_margin
- 1),
4701 MOVE_TO_POS
| MOVE_TO_Y
);
4703 /* Save our position, in case it's correct. */
4704 charpos
= IT_CHARPOS (it
);
4705 bytepos
= IT_BYTEPOS (it
);
4707 /* See if point is on a partially visible line at the end. */
4708 if (it
.what
== IT_EOB
)
4709 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4712 move_it_by_lines (&it
, 1);
4713 partial_p
= it
.current_y
> it
.last_visible_y
;
4716 if (charpos
== PT
&& !partial_p
4717 && (NILP (Vscroll_preserve_screen_position
)
4718 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4719 /* We found PT before we found the display margin, so PT is ok. */
4721 else if (window_scroll_pixel_based_preserve_y
>= 0)
4723 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4724 start_display (&it
, w
, start
);
4725 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4726 here because we called start_display again and did not
4727 alter it.current_y this time. */
4728 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4729 window_scroll_pixel_based_preserve_y
, -1,
4730 MOVE_TO_Y
| MOVE_TO_X
);
4731 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4736 /* The last line was only partially visible, so back up two
4737 lines to make sure we're on a fully visible line. */
4739 move_it_by_lines (&it
, -2);
4740 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4743 /* No, the position we saved is OK, so use it. */
4744 SET_PT_BOTH (charpos
, bytepos
);
4747 bidi_unshelve_cache (itdata
, 0);
4751 /* Implementation of window_scroll that works based on screen lines.
4752 See the comment of window_scroll for parameter descriptions. */
4755 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4757 register struct window
*w
= XWINDOW (window
);
4758 /* Fvertical_motion enters redisplay, which can trigger
4759 fontification, which in turn can modify buffer text (e.g., if the
4760 fontification functions replace escape sequences with faces, as
4761 in `grep-mode-font-lock-keywords'). So we use a marker to record
4762 the old point position, to prevent crashes in SET_PT_BOTH. */
4763 Lisp_Object opoint_marker
= Fpoint_marker ();
4764 register ptrdiff_t pos
, pos_byte
;
4765 register int ht
= window_internal_height (w
);
4766 register Lisp_Object tem
;
4770 Lisp_Object original_pos
= Qnil
;
4772 /* If scrolling screen-fulls, compute the number of lines to
4773 scroll from the window's height. */
4775 n
*= max (1, ht
- next_screen_context_lines
);
4777 startpos
= marker_position (w
->start
);
4779 if (!NILP (Vscroll_preserve_screen_position
))
4781 if (window_scroll_preserve_vpos
<= 0
4782 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4783 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4785 struct position posit
4786 = *compute_motion (startpos
, 0, 0, 0,
4790 window_scroll_preserve_vpos
= posit
.vpos
;
4791 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4794 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4795 make_number (window_scroll_preserve_vpos
));
4798 XSETFASTINT (tem
, PT
);
4799 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4803 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4808 lose
= n
< 0 && PT
== BEGV
;
4809 Fvertical_motion (make_number (n
), window
);
4813 SET_PT_BOTH (marker_position (opoint_marker
),
4814 marker_byte_position (opoint_marker
));
4821 xsignal0 (Qbeginning_of_buffer
);
4826 /* Don't use a scroll margin that is negative or too large. */
4827 int this_scroll_margin
=
4828 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4830 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4831 w
->start_at_line_beg
= !NILP (bolp
);
4832 w
->update_mode_line
= 1;
4833 w
->last_modified
= 0;
4834 w
->last_overlay_modified
= 0;
4835 /* Set force_start so that redisplay_window will run
4836 the window-scroll-functions. */
4839 if (!NILP (Vscroll_preserve_screen_position
)
4840 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4842 SET_PT_BOTH (pos
, pos_byte
);
4843 Fvertical_motion (original_pos
, window
);
4845 /* If we scrolled forward, put point enough lines down
4846 that it is outside the scroll margin. */
4851 if (this_scroll_margin
> 0)
4853 SET_PT_BOTH (pos
, pos_byte
);
4854 Fvertical_motion (make_number (this_scroll_margin
), window
);
4860 if (top_margin
<= marker_position (opoint_marker
))
4861 SET_PT_BOTH (marker_position (opoint_marker
),
4862 marker_byte_position (opoint_marker
));
4863 else if (!NILP (Vscroll_preserve_screen_position
))
4865 SET_PT_BOTH (pos
, pos_byte
);
4866 Fvertical_motion (original_pos
, window
);
4869 SET_PT (top_margin
);
4875 /* If we scrolled backward, put point near the end of the window
4876 but not within the scroll margin. */
4877 SET_PT_BOTH (pos
, pos_byte
);
4878 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4879 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4882 bottom_margin
= PT
+ 1;
4884 if (bottom_margin
> marker_position (opoint_marker
))
4885 SET_PT_BOTH (marker_position (opoint_marker
),
4886 marker_byte_position (opoint_marker
));
4889 if (!NILP (Vscroll_preserve_screen_position
))
4891 SET_PT_BOTH (pos
, pos_byte
);
4892 Fvertical_motion (original_pos
, window
);
4895 Fvertical_motion (make_number (-1), window
);
4904 xsignal0 (Qend_of_buffer
);
4909 /* Scroll selected_window up or down. If N is nil, scroll a
4910 screen-full which is defined as the height of the window minus
4911 next_screen_context_lines. If N is the symbol `-', scroll.
4912 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4913 up. This is the guts of Fscroll_up and Fscroll_down. */
4916 scroll_command (Lisp_Object n
, int direction
)
4918 ptrdiff_t count
= SPECPDL_INDEX ();
4920 eassert (eabs (direction
) == 1);
4922 /* If selected window's buffer isn't current, make it current for
4923 the moment. But don't screw up if window_scroll gets an error. */
4924 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4926 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4927 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4929 /* Make redisplay consider other windows than just selected_window. */
4930 ++windows_or_buffers_changed
;
4934 window_scroll (selected_window
, direction
, 1, 0);
4935 else if (EQ (n
, Qminus
))
4936 window_scroll (selected_window
, -direction
, 1, 0);
4939 n
= Fprefix_numeric_value (n
);
4940 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4943 unbind_to (count
, Qnil
);
4946 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4947 doc
: /* Scroll text of selected window upward ARG lines.
4948 If ARG is omitted or nil, scroll upward by a near full screen.
4949 A near full screen is `next-screen-context-lines' less than a full screen.
4950 Negative ARG means scroll downward.
4951 If ARG is the atom `-', scroll downward by nearly full screen.
4952 When calling from a program, supply as argument a number, nil, or `-'. */)
4955 scroll_command (arg
, 1);
4959 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4960 doc
: /* Scroll text of selected window down ARG lines.
4961 If ARG is omitted or nil, scroll down by a near full screen.
4962 A near full screen is `next-screen-context-lines' less than a full screen.
4963 Negative ARG means scroll upward.
4964 If ARG is the atom `-', scroll upward by nearly full screen.
4965 When calling from a program, supply as argument a number, nil, or `-'. */)
4968 scroll_command (arg
, -1);
4972 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4973 doc
: /* Return the other window for \"other window scroll\" commands.
4974 If `other-window-scroll-buffer' is non-nil, a window
4975 showing that buffer is used.
4976 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4977 specifies the window. This takes precedence over
4978 `other-window-scroll-buffer'. */)
4983 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4984 && !NILP (Vminibuf_scroll_window
))
4985 window
= Vminibuf_scroll_window
;
4986 /* If buffer is specified, scroll that buffer. */
4987 else if (!NILP (Vother_window_scroll_buffer
))
4989 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4991 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4995 /* Nothing specified; look for a neighboring window on the same
4997 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4999 if (EQ (window
, selected_window
))
5000 /* That didn't get us anywhere; look for a window on another
5003 window
= Fnext_window (window
, Qnil
, Qt
);
5004 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5005 && ! EQ (window
, selected_window
));
5008 CHECK_LIVE_WINDOW (window
);
5010 if (EQ (window
, selected_window
))
5011 error ("There is no other window");
5016 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5017 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5018 A near full screen is `next-screen-context-lines' less than a full screen.
5019 The next window is the one below the current one; or the one at the top
5020 if the current one is at the bottom. Negative ARG means scroll downward.
5021 If ARG is the atom `-', scroll downward by nearly full screen.
5022 When calling from a program, supply as argument a number, nil, or `-'.
5024 If `other-window-scroll-buffer' is non-nil, scroll the window
5025 showing that buffer, popping the buffer up if necessary.
5026 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5027 specifies the window to scroll. This takes precedence over
5028 `other-window-scroll-buffer'. */)
5033 ptrdiff_t count
= SPECPDL_INDEX ();
5035 window
= Fother_window_for_scrolling ();
5036 w
= XWINDOW (window
);
5038 /* Don't screw up if window_scroll gets an error. */
5039 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5040 ++windows_or_buffers_changed
;
5042 Fset_buffer (w
->buffer
);
5043 SET_PT (marker_position (w
->pointm
));
5046 window_scroll (window
, 1, 1, 1);
5047 else if (EQ (arg
, Qminus
))
5048 window_scroll (window
, -1, 1, 1);
5054 window_scroll (window
, XINT (arg
), 0, 1);
5057 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5058 unbind_to (count
, Qnil
);
5063 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5064 doc
: /* Scroll selected window display ARG columns left.
5065 Default for ARG is window width minus 2.
5066 Value is the total amount of leftward horizontal scrolling in
5067 effect after the change.
5068 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5069 lower bound for automatic scrolling, i.e. automatic scrolling
5070 will not scroll a window to a column less than the value returned
5071 by this function. This happens in an interactive call. */)
5072 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5074 struct window
*w
= XWINDOW (selected_window
);
5075 EMACS_INT requested_arg
= (NILP (arg
)
5076 ? window_body_cols (w
) - 2
5077 : XINT (Fprefix_numeric_value (arg
)));
5078 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5080 if (!NILP (set_minimum
))
5081 w
->min_hscroll
= w
->hscroll
;
5086 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5087 doc
: /* Scroll selected window display ARG columns right.
5088 Default for ARG is window width minus 2.
5089 Value is the total amount of leftward horizontal scrolling in
5090 effect after the change.
5091 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5092 lower bound for automatic scrolling, i.e. automatic scrolling
5093 will not scroll a window to a column less than the value returned
5094 by this function. This happens in an interactive call. */)
5095 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5097 struct window
*w
= XWINDOW (selected_window
);
5098 EMACS_INT requested_arg
= (NILP (arg
)
5099 ? window_body_cols (w
) - 2
5100 : XINT (Fprefix_numeric_value (arg
)));
5101 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5103 if (!NILP (set_minimum
))
5104 w
->min_hscroll
= w
->hscroll
;
5109 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5110 doc
: /* Return the window which was selected when entering the minibuffer.
5111 Returns nil, if selected window is not a minibuffer window. */)
5114 if (minibuf_level
> 0
5115 && MINI_WINDOW_P (XWINDOW (selected_window
))
5116 && WINDOW_LIVE_P (minibuf_selected_window
))
5117 return minibuf_selected_window
;
5122 /* Value is the number of lines actually displayed in window W,
5123 as opposed to its height. */
5126 displayed_window_lines (struct window
*w
)
5129 struct text_pos start
;
5130 ptrdiff_t charpos
= marker_position (w
->start
);
5131 int height
= window_box_height (w
);
5132 struct buffer
*old_buffer
;
5134 void *itdata
= NULL
;
5136 if (XBUFFER (w
->buffer
) != current_buffer
)
5138 old_buffer
= current_buffer
;
5139 set_buffer_internal (XBUFFER (w
->buffer
));
5144 /* In case W->start is out of the accessible range, do something
5145 reasonable. This happens in Info mode when Info-scroll-down
5146 calls (recenter -1) while W->start is 1. */
5148 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5149 else if (charpos
> ZV
)
5150 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5152 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5154 itdata
= bidi_shelve_cache ();
5155 start_display (&it
, w
, start
);
5156 move_it_vertically (&it
, height
);
5157 bottom_y
= line_bottom_y (&it
);
5158 bidi_unshelve_cache (itdata
, 0);
5160 /* rms: On a non-window display,
5161 the value of it.vpos at the bottom of the screen
5162 seems to be 1 larger than window_box_height (w).
5163 This kludge fixes a bug whereby (move-to-window-line -1)
5164 when ZV is on the last screen line
5165 moves to the previous screen line instead of the last one. */
5166 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5169 /* Add in empty lines at the bottom of the window. */
5170 if (bottom_y
< height
)
5172 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5173 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5177 set_buffer_internal (old_buffer
);
5183 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5184 doc
: /* Center point in selected window and maybe redisplay frame.
5185 With prefix argument ARG, recenter putting point on screen line ARG
5186 relative to the selected window. If ARG is negative, it counts up from the
5187 bottom of the window. (ARG should be less than the height of the window.)
5189 If ARG is omitted or nil, then recenter with point on the middle line of
5190 the selected window; if the variable `recenter-redisplay' is non-nil,
5191 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5192 is set to `grow-only', this resets the tool-bar's height to the minimum
5193 height needed); if `recenter-redisplay' has the special value `tty',
5194 then only tty frames are redrawn.
5196 Just C-u as prefix means put point in the center of the window
5197 and redisplay normally--don't erase and redraw the frame. */)
5198 (register Lisp_Object arg
)
5200 struct window
*w
= XWINDOW (selected_window
);
5201 struct buffer
*buf
= XBUFFER (w
->buffer
);
5202 struct buffer
*obuf
= current_buffer
;
5204 ptrdiff_t charpos
, bytepos
;
5205 EMACS_INT iarg
IF_LINT (= 0);
5206 int this_scroll_margin
;
5208 /* If redisplay is suppressed due to an error, try again. */
5209 obuf
->display_error_modiff
= 0;
5213 if (!NILP (Vrecenter_redisplay
)
5214 && (!EQ (Vrecenter_redisplay
, Qtty
)
5215 || !NILP (Ftty_type (selected_frame
))))
5219 /* Invalidate pixel data calculated for all compositions. */
5220 for (i
= 0; i
< n_compositions
; i
++)
5221 composition_table
[i
]->font
= NULL
;
5223 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5225 Fredraw_frame (WINDOW_FRAME (w
));
5226 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5231 else if (CONSP (arg
)) /* Just C-u. */
5235 arg
= Fprefix_numeric_value (arg
);
5240 set_buffer_internal (buf
);
5242 /* Do this after making BUF current
5243 in case scroll_margin is buffer-local. */
5244 this_scroll_margin
=
5245 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5247 /* Handle centering on a graphical frame specially. Such frames can
5248 have variable-height lines and centering point on the basis of
5249 line counts would lead to strange effects. */
5250 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5256 void *itdata
= bidi_shelve_cache ();
5258 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5259 start_display (&it
, w
, pt
);
5260 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5261 charpos
= IT_CHARPOS (it
);
5262 bytepos
= IT_BYTEPOS (it
);
5263 bidi_unshelve_cache (itdata
, 0);
5269 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5270 int extra_line_spacing
;
5271 int h
= window_box_height (w
);
5272 void *itdata
= bidi_shelve_cache ();
5274 iarg
= - max (-iarg
, this_scroll_margin
);
5276 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5277 start_display (&it
, w
, pt
);
5279 /* Be sure we have the exact height of the full line containing PT. */
5280 move_it_by_lines (&it
, 0);
5282 /* The amount of pixels we have to move back is the window
5283 height minus what's displayed in the line containing PT,
5284 and the lines below. */
5287 move_it_by_lines (&it
, nlines
);
5289 if (it
.vpos
== nlines
)
5293 /* Last line has no newline */
5294 h
-= line_bottom_y (&it
);
5298 /* Don't reserve space for extra line spacing of last line. */
5299 extra_line_spacing
= it
.max_extra_line_spacing
;
5301 /* If we can't move down NLINES lines because we hit
5302 the end of the buffer, count in some empty lines. */
5303 if (it
.vpos
< nlines
)
5306 extra_line_spacing
= it
.extra_line_spacing
;
5307 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5311 bidi_unshelve_cache (itdata
, 0);
5315 /* Now find the new top line (starting position) of the window. */
5316 start_display (&it
, w
, pt
);
5318 move_it_vertically_backward (&it
, h
);
5320 /* If extra line spacing is present, we may move too far
5321 back. This causes the last line to be only partially
5322 visible (which triggers redisplay to recenter that line
5323 in the middle), so move forward.
5324 But ignore extra line spacing on last line, as it is not
5325 considered to be part of the visible height of the line.
5327 h
+= extra_line_spacing
;
5328 while (-it
.current_y
> h
)
5329 move_it_by_lines (&it
, 1);
5331 charpos
= IT_CHARPOS (it
);
5332 bytepos
= IT_BYTEPOS (it
);
5334 bidi_unshelve_cache (itdata
, 0);
5338 struct position pos
;
5340 iarg
= max (iarg
, this_scroll_margin
);
5342 pos
= *vmotion (PT
, -iarg
, w
);
5343 charpos
= pos
.bufpos
;
5344 bytepos
= pos
.bytepos
;
5349 struct position pos
;
5350 int ht
= window_internal_height (w
);
5357 /* Don't let it get into the margin at either top or bottom. */
5358 iarg
= clip_to_bounds (this_scroll_margin
, iarg
,
5359 ht
- this_scroll_margin
- 1);
5361 pos
= *vmotion (PT
, - iarg
, w
);
5362 charpos
= pos
.bufpos
;
5363 bytepos
= pos
.bytepos
;
5366 /* Set the new window start. */
5367 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5368 wset_window_end_valid (w
, Qnil
);
5370 w
->optional_new_start
= 1;
5372 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5373 FETCH_BYTE (bytepos
- 1) == '\n');
5375 set_buffer_internal (obuf
);
5379 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5381 doc
: /* Return the height in lines of the text display area of WINDOW.
5382 WINDOW must be a live window and defaults to the selected one.
5384 The returned height does not include the mode line, any header line,
5385 nor any partial-height lines at the bottom of the text area. */)
5386 (Lisp_Object window
)
5388 struct window
*w
= decode_live_window (window
);
5389 int pixel_height
= window_box_height (w
);
5390 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5391 return make_number (line_height
);
5396 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5398 doc
: /* Position point relative to window.
5399 ARG nil means position point at center of window.
5400 Else, ARG specifies vertical position within the window;
5401 zero means top of window, negative means relative to bottom of window. */)
5404 struct window
*w
= XWINDOW (selected_window
);
5408 int this_scroll_margin
;
5411 if (!(BUFFERP (w
->buffer
)
5412 && XBUFFER (w
->buffer
) == current_buffer
))
5413 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5414 when passed below to set_marker_both. */
5415 error ("move-to-window-line called from unrelated buffer");
5417 window
= selected_window
;
5418 start
= marker_position (w
->start
);
5419 if (start
< BEGV
|| start
> ZV
)
5421 int height
= window_internal_height (w
);
5422 Fvertical_motion (make_number (- (height
/ 2)), window
);
5423 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5424 w
->start_at_line_beg
= !NILP (Fbolp ());
5428 Fgoto_char (w
->start
);
5430 lines
= displayed_window_lines (w
);
5433 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5437 XSETFASTINT (arg
, lines
/ 2);
5440 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5443 iarg
= iarg
+ lines
;
5445 #if 0 /* This code would prevent move-to-window-line from moving point
5446 to a place inside the scroll margins (which would cause the
5447 next redisplay to scroll). I wrote this code, but then concluded
5448 it is probably better not to install it. However, it is here
5449 inside #if 0 so as not to lose it. -- rms. */
5451 /* Don't let it get into the margin at either top or bottom. */
5452 iarg
= max (iarg
, this_scroll_margin
);
5453 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5456 arg
= make_number (iarg
);
5459 /* Skip past a partially visible first line. */
5461 XSETINT (arg
, XINT (arg
) + 1);
5463 return Fvertical_motion (arg
, window
);
5468 /***********************************************************************
5469 Window Configuration
5470 ***********************************************************************/
5472 struct save_window_data
5474 struct vectorlike_header header
;
5475 Lisp_Object selected_frame
;
5476 Lisp_Object current_window
;
5477 Lisp_Object current_buffer
;
5478 Lisp_Object minibuf_scroll_window
;
5479 Lisp_Object minibuf_selected_window
;
5480 Lisp_Object root_window
;
5481 Lisp_Object focus_frame
;
5482 /* A vector, each of whose elements is a struct saved_window
5484 Lisp_Object saved_windows
;
5486 /* All fields above are traced by the GC.
5487 From `fame-cols' down, the fields are ignored by the GC. */
5489 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5490 int frame_tool_bar_lines
;
5493 /* This is saved as a Lisp_Vector */
5496 struct vectorlike_header header
;
5498 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5499 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5500 Lisp_Object normal_cols
, normal_lines
;
5501 Lisp_Object hscroll
, min_hscroll
;
5502 Lisp_Object parent
, prev
;
5503 Lisp_Object start_at_line_beg
;
5504 Lisp_Object display_table
;
5505 Lisp_Object left_margin_cols
, right_margin_cols
;
5506 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5507 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5508 Lisp_Object combination_limit
, window_parameters
;
5511 #define SAVED_WINDOW_N(swv,n) \
5512 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5514 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5515 doc
: /* Return t if OBJECT is a window-configuration object. */)
5516 (Lisp_Object object
)
5518 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5521 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5522 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5523 (Lisp_Object config
)
5525 register struct save_window_data
*data
;
5526 struct Lisp_Vector
*saved_windows
;
5528 CHECK_WINDOW_CONFIGURATION (config
);
5530 data
= (struct save_window_data
*) XVECTOR (config
);
5531 saved_windows
= XVECTOR (data
->saved_windows
);
5532 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5535 DEFUN ("set-window-configuration", Fset_window_configuration
,
5536 Sset_window_configuration
, 1, 1, 0,
5537 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5538 CONFIGURATION must be a value previously returned
5539 by `current-window-configuration' (which see).
5540 If CONFIGURATION was made from a frame that is now deleted,
5541 only frame-independent values can be restored. In this case,
5542 the return value is nil. Otherwise the value is t. */)
5543 (Lisp_Object configuration
)
5545 register struct save_window_data
*data
;
5546 struct Lisp_Vector
*saved_windows
;
5547 Lisp_Object new_current_buffer
;
5550 ptrdiff_t old_point
= -1;
5552 CHECK_WINDOW_CONFIGURATION (configuration
);
5554 data
= (struct save_window_data
*) XVECTOR (configuration
);
5555 saved_windows
= XVECTOR (data
->saved_windows
);
5557 new_current_buffer
= data
->current_buffer
;
5558 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5559 new_current_buffer
= Qnil
;
5562 if (XBUFFER (new_current_buffer
) == current_buffer
)
5563 /* The code further down "preserves point" by saving here PT in
5564 old_point and then setting it later back into PT. When the
5565 current-selected-window and the final-selected-window both show
5566 the current buffer, this suffers from the problem that the
5567 current PT is the window-point of the current-selected-window,
5568 while the final PT is the point of the final-selected-window, so
5569 this copy from one PT to the other would end up moving the
5570 window-point of the final-selected-window to the window-point of
5571 the current-selected-window. So we have to be careful which
5572 point of the current-buffer we copy into old_point. */
5573 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5574 && WINDOWP (selected_window
)
5575 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5576 && !EQ (selected_window
, data
->current_window
))
5577 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5581 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5582 point in new_current_buffer as of the last time this buffer was
5583 used. This can be non-deterministic since it can be changed by
5584 things like jit-lock by mere temporary selection of some random
5585 window that happens to show this buffer.
5586 So if possible we want this arbitrary choice of "which point" to
5587 be the one from the to-be-selected-window so as to prevent this
5588 window's cursor from being copied from another window. */
5589 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5590 /* If current_window = selected_window, its point is in BUF_PT. */
5591 && !EQ (selected_window
, data
->current_window
))
5592 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5594 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5597 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5600 /* If f is a dead frame, don't bother rebuilding its window tree.
5601 However, there is other stuff we should still try to do below. */
5602 if (FRAME_LIVE_P (f
))
5605 Lisp_Object dead_windows
= Qnil
;
5606 register Lisp_Object tem
, par
, pers
;
5607 register struct window
*w
;
5608 register struct saved_window
*p
;
5609 struct window
*root_window
;
5610 struct window
**leaf_windows
;
5615 /* If the frame has been resized since this window configuration was
5616 made, we change the frame to the size specified in the
5617 configuration, restore the configuration, and then resize it
5618 back. We keep track of the prevailing height in these variables. */
5619 int previous_frame_lines
= FRAME_LINES (f
);
5620 int previous_frame_cols
= FRAME_COLS (f
);
5621 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5622 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5624 /* Don't do this within the main loop below: This may call Lisp
5625 code and is thus potentially unsafe while input is blocked. */
5626 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5628 p
= SAVED_WINDOW_N (saved_windows
, k
);
5630 w
= XWINDOW (window
);
5631 if (!NILP (w
->buffer
)
5632 && !EQ (w
->buffer
, p
->buffer
)
5633 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5634 /* If a window we restore gets another buffer, record the
5635 window's old buffer. */
5636 call1 (Qrecord_window_buffer
, window
);
5639 /* The mouse highlighting code could get screwed up
5640 if it runs during this. */
5643 if (data
->frame_lines
!= previous_frame_lines
5644 || data
->frame_cols
!= previous_frame_cols
)
5645 change_frame_size (f
, data
->frame_lines
,
5646 data
->frame_cols
, 0, 0, 0);
5647 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5648 if (data
->frame_menu_bar_lines
5649 != previous_frame_menu_bar_lines
)
5650 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5652 #ifdef HAVE_WINDOW_SYSTEM
5653 if (data
->frame_tool_bar_lines
5654 != previous_frame_tool_bar_lines
)
5655 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5660 /* "Swap out" point from the selected window's buffer
5661 into the window itself. (Normally the pointm of the selected
5662 window holds garbage.) We do this now, before
5663 restoring the window contents, and prevent it from
5664 being done later on when we select a new window. */
5665 if (! NILP (XWINDOW (selected_window
)->buffer
))
5667 w
= XWINDOW (selected_window
);
5668 set_marker_both (w
->pointm
,
5670 BUF_PT (XBUFFER (w
->buffer
)),
5671 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5674 windows_or_buffers_changed
++;
5675 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5677 /* Problem: Freeing all matrices and later allocating them again
5678 is a serious redisplay flickering problem. What we would
5679 really like to do is to free only those matrices not reused
5681 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5682 leaf_windows
= alloca (count_windows (root_window
)
5683 * sizeof *leaf_windows
);
5684 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5687 Mark all windows now on frame as "deleted".
5688 Restoring the new configuration "undeletes" any that are in it.
5690 Save their current buffers in their height fields, since we may
5691 need it later, if a buffer saved in the configuration is now
5693 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5695 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5697 p
= SAVED_WINDOW_N (saved_windows
, k
);
5699 w
= XWINDOW (window
);
5700 wset_next (w
, Qnil
);
5702 if (!NILP (p
->parent
))
5704 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5706 wset_parent (w
, Qnil
);
5708 if (!NILP (p
->prev
))
5711 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5712 wset_next (XWINDOW (w
->prev
), p
->window
);
5716 wset_prev (w
, Qnil
);
5717 if (!NILP (w
->parent
))
5719 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5721 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5722 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5726 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5727 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5732 /* If we squirreled away the buffer in the window's height,
5734 if (BUFFERP (w
->total_lines
))
5735 wset_buffer (w
, w
->total_lines
);
5736 wset_left_col (w
, p
->left_col
);
5737 wset_top_line (w
, p
->top_line
);
5738 wset_total_cols (w
, p
->total_cols
);
5739 wset_total_lines (w
, p
->total_lines
);
5740 wset_normal_cols (w
, p
->normal_cols
);
5741 wset_normal_lines (w
, p
->normal_lines
);
5742 w
->hscroll
= XFASTINT (p
->hscroll
);
5743 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5744 wset_display_table (w
, p
->display_table
);
5745 wset_left_margin_cols (w
, p
->left_margin_cols
);
5746 wset_right_margin_cols (w
, p
->right_margin_cols
);
5747 wset_left_fringe_width (w
, p
->left_fringe_width
);
5748 wset_right_fringe_width (w
, p
->right_fringe_width
);
5749 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5750 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5751 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5752 wset_dedicated (w
, p
->dedicated
);
5753 wset_combination_limit (w
, p
->combination_limit
);
5754 /* Restore any window parameters that have been saved.
5755 Parameters that have not been saved are left alone. */
5756 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5761 if (NILP (XCDR (pers
)))
5763 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5764 if (CONSP (par
) && !NILP (XCDR (par
)))
5765 /* Reset a parameter to nil if and only if it
5766 has a non-nil association. Don't make new
5768 Fsetcdr (par
, Qnil
);
5771 /* Always restore a non-nil value. */
5772 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5776 w
->last_modified
= 0;
5777 w
->last_overlay_modified
= 0;
5779 /* Reinstall the saved buffer and pointers into it. */
5780 if (NILP (p
->buffer
))
5781 /* An internal window. */
5782 wset_buffer (w
, p
->buffer
);
5783 else if (BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5784 /* If saved buffer is alive, install it. */
5786 wset_buffer (w
, p
->buffer
);
5787 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5788 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5789 set_marker_restricted (w
->pointm
, p
->pointm
,
5791 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5792 p
->mark
, w
->buffer
);
5794 /* As documented in Fcurrent_window_configuration, don't
5795 restore the location of point in the buffer which was
5796 current when the window configuration was recorded. */
5797 if (!EQ (p
->buffer
, new_current_buffer
)
5798 && XBUFFER (p
->buffer
) == current_buffer
)
5799 Fgoto_char (w
->pointm
);
5801 else if (!NILP (w
->buffer
)
5802 && BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
5803 /* Keep window's old buffer; make sure the markers are
5806 /* Set window markers at start of visible range. */
5807 if (XMARKER (w
->start
)->buffer
== 0)
5808 set_marker_restricted (w
->start
, make_number (0),
5810 if (XMARKER (w
->pointm
)->buffer
== 0)
5811 set_marker_restricted_both
5812 (w
->pointm
, w
->buffer
,
5813 BUF_PT (XBUFFER (w
->buffer
)),
5814 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5815 w
->start_at_line_beg
= 1;
5818 /* Window has no live buffer, get one. */
5820 /* Get the buffer via other_buffer_safely in order to
5821 avoid showing an unimportant buffer and, if necessary, to
5822 recreate *scratch* in the course (part of Juanma's bs-show
5823 scenario from March 2011). */
5824 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5825 /* This will set the markers to beginning of visible
5827 set_marker_restricted (w
->start
,
5828 make_number (0), w
->buffer
);
5829 set_marker_restricted (w
->pointm
,
5830 make_number (0), w
->buffer
);
5831 w
->start_at_line_beg
= 1;
5832 if (!NILP (w
->dedicated
))
5833 /* Record this window as dead. */
5834 dead_windows
= Fcons (window
, dead_windows
);
5835 /* Make sure window is no more dedicated. */
5836 wset_dedicated (w
, Qnil
);
5840 fset_root_window (f
, data
->root_window
);
5841 /* Arrange *not* to restore point in the buffer that was
5842 current when the window configuration was saved. */
5843 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5844 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5845 make_number (old_point
),
5846 XWINDOW (data
->current_window
)->buffer
);
5848 /* In the following call to `select-window', prevent "swapping out
5849 point" in the old selected window using the buffer that has
5850 been restored into it. We already swapped out that point from
5851 that window's old buffer. */
5852 select_window (data
->current_window
, Qnil
, 1);
5853 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5856 if (NILP (data
->focus_frame
)
5857 || (FRAMEP (data
->focus_frame
)
5858 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5859 Fredirect_frame_focus (frame
, data
->focus_frame
);
5861 /* Set the screen height to the value it had before this function. */
5862 if (previous_frame_lines
!= FRAME_LINES (f
)
5863 || previous_frame_cols
!= FRAME_COLS (f
))
5864 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5866 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5867 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5868 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5870 #ifdef HAVE_WINDOW_SYSTEM
5871 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5872 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5877 /* Now, free glyph matrices in windows that were not reused. */
5878 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5880 if (NILP (leaf_windows
[i
]->buffer
))
5882 /* Assert it's not reused as a combination. */
5883 eassert (NILP (leaf_windows
[i
]->hchild
)
5884 && NILP (leaf_windows
[i
]->vchild
));
5885 free_window_matrices (leaf_windows
[i
]);
5887 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5894 /* Scan dead buffer windows. */
5895 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5897 window
= XCAR (dead_windows
);
5898 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5899 delete_deletable_window (window
);
5902 /* Fselect_window will have made f the selected frame, so we
5903 reselect the proper frame here. Fhandle_switch_frame will change the
5904 selected window too, but that doesn't make the call to
5905 Fselect_window above totally superfluous; it still sets f's
5907 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5908 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5910 run_window_configuration_change_hook (f
);
5913 if (!NILP (new_current_buffer
))
5915 Fset_buffer (new_current_buffer
);
5916 /* If the new current buffer doesn't appear in the selected
5917 window, go to its old point (see bug#12208). */
5918 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5919 Fgoto_char (make_number (old_point
));
5922 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5923 minibuf_selected_window
= data
->minibuf_selected_window
;
5925 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5929 /* Recursively delete all child windows reachable via the next, vchild,
5930 and hchild slots of WINDOW. */
5932 delete_all_child_windows (Lisp_Object window
)
5934 register struct window
*w
;
5936 w
= XWINDOW (window
);
5938 if (!NILP (w
->next
))
5939 /* Delete WINDOW's siblings (we traverse postorderly). */
5940 delete_all_child_windows (w
->next
);
5942 /* See Fset_window_configuration for excuse. */
5943 wset_total_lines (w
, w
->buffer
);
5945 if (!NILP (w
->vchild
))
5947 delete_all_child_windows (w
->vchild
);
5948 wset_vchild (w
, Qnil
);
5950 else if (!NILP (w
->hchild
))
5952 delete_all_child_windows (w
->hchild
);
5953 wset_hchild (w
, Qnil
);
5955 else if (!NILP (w
->buffer
))
5958 unchain_marker (XMARKER (w
->pointm
));
5959 unchain_marker (XMARKER (w
->start
));
5960 wset_buffer (w
, Qnil
);
5963 Vwindow_list
= Qnil
;
5967 count_windows (register struct window
*window
)
5969 register int count
= 1;
5970 if (!NILP (window
->next
))
5971 count
+= count_windows (XWINDOW (window
->next
));
5972 if (!NILP (window
->vchild
))
5973 count
+= count_windows (XWINDOW (window
->vchild
));
5974 if (!NILP (window
->hchild
))
5975 count
+= count_windows (XWINDOW (window
->hchild
));
5980 /* Fill vector FLAT with leaf windows under W, starting at index I.
5981 Value is last index + 1. */
5983 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5987 if (!NILP (w
->hchild
))
5988 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5989 else if (!NILP (w
->vchild
))
5990 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5994 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6001 /* Return a pointer to the glyph W's physical cursor is on. Value is
6002 null if W's current matrix is invalid, so that no meaningful glyph
6005 get_phys_cursor_glyph (struct window
*w
)
6007 struct glyph_row
*row
;
6008 struct glyph
*glyph
;
6009 int hpos
= w
->phys_cursor
.hpos
;
6011 if (!(w
->phys_cursor
.vpos
>= 0
6012 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
6015 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
6016 if (!row
->enabled_p
)
6021 /* When the window is hscrolled, cursor hpos can legitimately be
6022 out of bounds, but we draw the cursor at the corresponding
6023 window margin in that case. */
6024 if (!row
->reversed_p
&& hpos
< 0)
6026 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
6027 hpos
= row
->used
[TEXT_AREA
] - 1;
6030 if (row
->used
[TEXT_AREA
] > hpos
6032 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
6041 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6043 register struct saved_window
*p
;
6044 register struct window
*w
;
6045 register Lisp_Object tem
, pers
, par
;
6047 for (;!NILP (window
); window
= w
->next
)
6049 p
= SAVED_WINDOW_N (vector
, i
);
6050 w
= XWINDOW (window
);
6052 wset_temslot (w
, make_number (i
)); i
++;
6054 p
->buffer
= w
->buffer
;
6055 p
->left_col
= w
->left_col
;
6056 p
->top_line
= w
->top_line
;
6057 p
->total_cols
= w
->total_cols
;
6058 p
->total_lines
= w
->total_lines
;
6059 p
->normal_cols
= w
->normal_cols
;
6060 p
->normal_lines
= w
->normal_lines
;
6061 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6062 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6063 p
->display_table
= w
->display_table
;
6064 p
->left_margin_cols
= w
->left_margin_cols
;
6065 p
->right_margin_cols
= w
->right_margin_cols
;
6066 p
->left_fringe_width
= w
->left_fringe_width
;
6067 p
->right_fringe_width
= w
->right_fringe_width
;
6068 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6069 p
->scroll_bar_width
= w
->scroll_bar_width
;
6070 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6071 p
->dedicated
= w
->dedicated
;
6072 p
->combination_limit
= w
->combination_limit
;
6073 p
->window_parameters
= Qnil
;
6075 if (!NILP (Vwindow_persistent_parameters
))
6077 /* Run cycle detection on Vwindow_persistent_parameters. */
6078 Lisp_Object tortoise
, hare
;
6080 hare
= tortoise
= Vwindow_persistent_parameters
;
6081 while (CONSP (hare
))
6088 tortoise
= XCDR (tortoise
);
6090 if (EQ (hare
, tortoise
))
6091 /* Reset Vwindow_persistent_parameters to Qnil. */
6093 Vwindow_persistent_parameters
= Qnil
;
6098 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6102 /* Save values for persistent window parameters. */
6103 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6105 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6107 /* If the window has no value for the parameter,
6109 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6110 p
->window_parameters
);
6112 /* If the window has a value for the parameter,
6114 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6116 p
->window_parameters
);
6121 if (!NILP (w
->buffer
))
6123 /* Save w's value of point in the window configuration. If w
6124 is the selected window, then get the value of point from
6125 the buffer; pointm is garbage in the selected window. */
6126 if (EQ (window
, selected_window
))
6127 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6128 BUF_PT (XBUFFER (w
->buffer
)),
6129 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6131 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6132 XMARKER (p
->pointm
)->insertion_type
6133 = !NILP (Vwindow_point_insertion_type
);
6135 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6136 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6138 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6139 p
->mark
= Fcopy_marker (tem
, Qnil
);
6146 p
->start_at_line_beg
= Qnil
;
6149 if (NILP (w
->parent
))
6152 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6157 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6159 if (!NILP (w
->vchild
))
6160 i
= save_window_save (w
->vchild
, vector
, i
);
6161 if (!NILP (w
->hchild
))
6162 i
= save_window_save (w
->hchild
, vector
, i
);
6168 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6169 Scurrent_window_configuration
, 0, 1, 0,
6170 doc
: /* Return an object representing the current window configuration of FRAME.
6171 If FRAME is nil or omitted, use the selected frame.
6172 This describes the number of windows, their sizes and current buffers,
6173 and for each displayed buffer, where display starts, and the positions of
6174 point and mark. An exception is made for point in the current buffer:
6175 its value is -not- saved.
6176 This also records the currently selected frame, and FRAME's focus
6177 redirection (see `redirect-frame-focus'). The variable
6178 `window-persistent-parameters' specifies which window parameters are
6179 saved by this function. */)
6182 register Lisp_Object tem
;
6183 register int n_windows
;
6184 register struct save_window_data
*data
;
6186 struct frame
*f
= decode_live_frame (frame
);
6188 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6189 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6190 PVEC_WINDOW_CONFIGURATION
);
6192 data
->frame_cols
= FRAME_COLS (f
);
6193 data
->frame_lines
= FRAME_LINES (f
);
6194 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6195 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6196 data
->selected_frame
= selected_frame
;
6197 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6198 XSETBUFFER (data
->current_buffer
, current_buffer
);
6199 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6200 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6201 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6202 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6203 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6204 data
->saved_windows
= tem
;
6205 for (i
= 0; i
< n_windows
; i
++)
6207 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6208 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6209 XSETWINDOW_CONFIGURATION (tem
, data
);
6213 /***********************************************************************
6215 ***********************************************************************/
6217 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6219 doc
: /* Set width of marginal areas of window WINDOW.
6220 WINDOW must be a live window and defaults to the selected one.
6222 Second arg LEFT-WIDTH specifies the number of character cells to
6223 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6224 does the same for the right marginal area. A nil width parameter
6225 means no margin. */)
6226 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6228 struct window
*w
= decode_live_window (window
);
6230 /* Translate negative or zero widths to nil.
6231 Margins that are too wide have to be checked elsewhere. */
6233 if (!NILP (left_width
))
6235 CHECK_NUMBER (left_width
);
6236 if (XINT (left_width
) <= 0)
6240 if (!NILP (right_width
))
6242 CHECK_NUMBER (right_width
);
6243 if (XINT (right_width
) <= 0)
6247 if (!EQ (w
->left_margin_cols
, left_width
)
6248 || !EQ (w
->right_margin_cols
, right_width
))
6250 wset_left_margin_cols (w
, left_width
);
6251 wset_right_margin_cols (w
, right_width
);
6253 adjust_window_margins (w
);
6255 ++windows_or_buffers_changed
;
6256 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6263 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6265 doc
: /* Get width of marginal areas of window WINDOW.
6266 WINDOW must be a live window and defaults to the selected one.
6268 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6269 If a marginal area does not exist, its width will be returned
6271 (Lisp_Object window
)
6273 struct window
*w
= decode_live_window (window
);
6274 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6279 /***********************************************************************
6281 ***********************************************************************/
6283 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6285 doc
: /* Set the fringe widths of window WINDOW.
6286 WINDOW must be a live window and defaults to the selected one.
6288 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6289 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6290 fringe width. If a fringe width arg is nil, that means to use the
6291 frame's default fringe width. Default fringe widths can be set with
6292 the command `set-fringe-style'.
6293 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6294 outside of the display margins. By default, fringes are drawn between
6295 display marginal areas and the text area. */)
6296 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6298 struct window
*w
= decode_live_window (window
);
6299 int outside
= !NILP (outside_margins
);
6301 if (!NILP (left_width
))
6302 CHECK_NATNUM (left_width
);
6303 if (!NILP (right_width
))
6304 CHECK_NATNUM (right_width
);
6306 /* Do nothing on a tty. */
6307 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6308 && (!EQ (w
->left_fringe_width
, left_width
)
6309 || !EQ (w
->right_fringe_width
, right_width
)
6310 || w
->fringes_outside_margins
!= outside
))
6312 wset_left_fringe_width (w
, left_width
);
6313 wset_right_fringe_width (w
, right_width
);
6314 w
->fringes_outside_margins
= outside
;
6316 adjust_window_margins (w
);
6318 clear_glyph_matrix (w
->current_matrix
);
6319 wset_window_end_valid (w
, Qnil
);
6321 ++windows_or_buffers_changed
;
6322 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6329 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6331 doc
: /* Get width of fringes of window WINDOW.
6332 WINDOW must be a live window and defaults to the selected one.
6334 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6335 (Lisp_Object window
)
6337 struct window
*w
= decode_live_window (window
);
6339 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6340 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6341 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6346 /***********************************************************************
6348 ***********************************************************************/
6350 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6351 Sset_window_scroll_bars
, 2, 4, 0,
6352 doc
: /* Set width and type of scroll bars of window WINDOW.
6353 WINDOW must be a live window and defaults to the selected one.
6355 Second parameter WIDTH specifies the pixel width for the scroll bar;
6356 this is automatically adjusted to a multiple of the frame column width.
6357 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6358 bar: left, right, or nil.
6359 If WIDTH is nil, use the frame's scroll-bar width.
6360 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6361 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6362 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6364 struct window
*w
= decode_live_window (window
);
6368 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6370 if (XINT (width
) == 0)
6371 vertical_type
= Qnil
;
6374 if (!(NILP (vertical_type
)
6375 || EQ (vertical_type
, Qleft
)
6376 || EQ (vertical_type
, Qright
)
6377 || EQ (vertical_type
, Qt
)))
6378 error ("Invalid type of vertical scroll bar");
6380 if (!EQ (w
->scroll_bar_width
, width
)
6381 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6383 wset_scroll_bar_width (w
, width
);
6384 wset_vertical_scroll_bar_type (w
, vertical_type
);
6386 adjust_window_margins (w
);
6388 clear_glyph_matrix (w
->current_matrix
);
6389 wset_window_end_valid (w
, Qnil
);
6391 ++windows_or_buffers_changed
;
6392 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6399 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6401 doc
: /* Get width and type of scroll bars of window WINDOW.
6402 WINDOW must be a live window and defaults to the selected one.
6404 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6405 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6407 (Lisp_Object window
)
6409 struct window
*w
= decode_live_window (window
);
6411 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6412 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6413 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6414 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6415 w
->vertical_scroll_bar_type
, Qnil
);
6420 /***********************************************************************
6422 ***********************************************************************/
6424 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6425 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6426 If WINDOW is omitted or nil, it defaults to the selected window.
6427 Normally, value is a multiple of the canonical character height of WINDOW;
6428 optional second arg PIXELS-P means value is measured in pixels. */)
6429 (Lisp_Object window
, Lisp_Object pixels_p
)
6432 struct window
*w
= decode_live_window (window
);
6433 struct frame
*f
= XFRAME (w
->frame
);
6435 if (FRAME_WINDOW_P (f
))
6436 result
= (NILP (pixels_p
)
6437 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6438 : make_number (-w
->vscroll
));
6440 result
= make_number (0);
6445 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6447 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6448 WINDOW nil means use the selected window. Normally, VSCROLL is a
6449 non-negative multiple of the canonical character height of WINDOW;
6450 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6451 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6452 corresponds to an integral number of pixels. The return value is the
6453 result of this rounding.
6454 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6455 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6457 struct window
*w
= decode_live_window (window
);
6458 struct frame
*f
= XFRAME (w
->frame
);
6460 CHECK_NUMBER_OR_FLOAT (vscroll
);
6462 if (FRAME_WINDOW_P (f
))
6464 int old_dy
= w
->vscroll
;
6466 w
->vscroll
= - (NILP (pixels_p
)
6467 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6468 : XFLOATINT (vscroll
));
6469 w
->vscroll
= min (w
->vscroll
, 0);
6471 if (w
->vscroll
!= old_dy
)
6473 /* Adjust glyph matrix of the frame if the virtual display
6474 area becomes larger than before. */
6475 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6478 /* Prevent redisplay shortcuts. */
6479 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6483 return Fwindow_vscroll (window
, pixels_p
);
6487 /* Call FN for all leaf windows on frame F. FN is called with the
6488 first argument being a pointer to the leaf window, and with
6489 additional argument USER_DATA. Stops when FN returns 0. */
6492 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6495 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6496 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6497 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6501 /* Helper function for foreach_window. Call FN for all leaf windows
6502 reachable from W. FN is called with the first argument being a
6503 pointer to the leaf window, and with additional argument USER_DATA.
6504 Stop when FN returns 0. Value is 0 if stopped by FN. */
6507 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6511 for (cont
= 1; w
&& cont
;)
6513 if (!NILP (w
->hchild
))
6514 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6515 else if (!NILP (w
->vchild
))
6516 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6518 cont
= fn (w
, user_data
);
6520 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6527 /* Freeze or unfreeze the window start of W unless it is a
6528 mini-window or the selected window. FREEZE_P non-null means freeze
6529 the window start. */
6532 freeze_window_start (struct window
*w
, void *freeze_p
)
6534 if (MINI_WINDOW_P (w
)
6535 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6536 && (w
== XWINDOW (selected_window
)
6537 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6538 && ! NILP (Vminibuf_scroll_window
)
6539 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6542 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6547 /* Freeze or unfreeze the window starts of all leaf windows on frame
6548 F, except the selected window and a mini-window. FREEZE_P non-zero
6549 means freeze the window start. */
6552 freeze_window_starts (struct frame
*f
, int freeze_p
)
6554 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6558 /***********************************************************************
6560 ***********************************************************************/
6562 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6563 describe the same state of affairs. This is used by Fequal.
6565 IGNORE_POSITIONS means ignore non-matching scroll positions
6568 This ignores a couple of things like the dedication status of
6569 window, combination_limit and the like. This might have to be
6573 compare_window_configurations (Lisp_Object configuration1
,
6574 Lisp_Object configuration2
,
6575 bool ignore_positions
)
6577 register struct save_window_data
*d1
, *d2
;
6578 struct Lisp_Vector
*sws1
, *sws2
;
6581 CHECK_WINDOW_CONFIGURATION (configuration1
);
6582 CHECK_WINDOW_CONFIGURATION (configuration2
);
6584 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6585 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6586 sws1
= XVECTOR (d1
->saved_windows
);
6587 sws2
= XVECTOR (d2
->saved_windows
);
6589 /* Frame settings must match. */
6590 if (d1
->frame_cols
!= d2
->frame_cols
6591 || d1
->frame_lines
!= d2
->frame_lines
6592 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6593 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6594 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6595 || (!ignore_positions
6596 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6597 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6598 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6599 /* Verify that the two configurations have the same number of windows. */
6600 || sws1
->header
.size
!= sws2
->header
.size
)
6603 for (i
= 0; i
< sws1
->header
.size
; i
++)
6605 struct saved_window
*sw1
, *sw2
;
6607 sw1
= SAVED_WINDOW_N (sws1
, i
);
6608 sw2
= SAVED_WINDOW_N (sws2
, i
);
6611 /* The "current" windows in the two configurations must
6612 correspond to each other. */
6613 EQ (d1
->current_window
, sw1
->window
)
6614 != EQ (d2
->current_window
, sw2
->window
)
6615 /* Windows' buffers must match. */
6616 || !EQ (sw1
->buffer
, sw2
->buffer
)
6617 || !EQ (sw1
->left_col
, sw2
->left_col
)
6618 || !EQ (sw1
->top_line
, sw2
->top_line
)
6619 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6620 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6621 || !EQ (sw1
->display_table
, sw2
->display_table
)
6622 /* The next two disjuncts check the window structure for
6624 || !EQ (sw1
->parent
, sw2
->parent
)
6625 || !EQ (sw1
->prev
, sw2
->prev
)
6626 || (!ignore_positions
6627 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6628 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6629 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6630 || NILP (Fequal (sw1
->start
, sw2
->start
))
6631 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6632 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6633 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6634 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6635 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6636 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6637 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6638 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6639 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6646 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6647 Scompare_window_configurations
, 2, 2, 0,
6648 doc
: /* Compare two window configurations as regards the structure of windows.
6649 This function ignores details such as the values of point and mark
6650 and scrolling positions. */)
6651 (Lisp_Object x
, Lisp_Object y
)
6653 if (compare_window_configurations (x
, y
, 1))
6659 init_window_once (void)
6661 struct frame
*f
= make_initial_frame ();
6662 XSETFRAME (selected_frame
, f
);
6663 Vterminal_frame
= selected_frame
;
6664 minibuf_window
= f
->minibuffer_window
;
6665 selected_window
= f
->selected_window
;
6666 last_nonminibuf_frame
= f
;
6668 window_initialized
= 1;
6674 Vwindow_list
= Qnil
;
6678 syms_of_window (void)
6680 DEFSYM (Qscroll_up
, "scroll-up");
6681 DEFSYM (Qscroll_down
, "scroll-down");
6682 DEFSYM (Qscroll_command
, "scroll-command");
6684 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6685 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6687 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6688 DEFSYM (Qwindowp
, "windowp");
6689 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6690 DEFSYM (Qwindow_live_p
, "window-live-p");
6691 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6692 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6693 DEFSYM (Qdelete_window
, "delete-window");
6694 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6695 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6696 DEFSYM (Qsafe
, "safe");
6697 DEFSYM (Qdisplay_buffer
, "display-buffer");
6698 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6699 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6700 DEFSYM (Qget_mru_window
, "get-mru-window");
6701 DEFSYM (Qwindow_size
, "window-size");
6702 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6703 DEFSYM (Qabove
, "above");
6704 DEFSYM (Qbelow
, "below");
6705 DEFSYM (Qclone_of
, "clone-of");
6707 staticpro (&Vwindow_list
);
6709 minibuf_selected_window
= Qnil
;
6710 staticpro (&minibuf_selected_window
);
6712 window_scroll_pixel_based_preserve_x
= -1;
6713 window_scroll_pixel_based_preserve_y
= -1;
6714 window_scroll_preserve_hpos
= -1;
6715 window_scroll_preserve_vpos
= -1;
6717 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6718 doc
: /* Non-nil means call as function to display a help buffer.
6719 The function is called with one argument, the buffer to be displayed.
6720 Used by `with-output-to-temp-buffer'.
6721 If this function is used, then it must do the entire job of showing
6722 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6723 Vtemp_buffer_show_function
= Qnil
;
6725 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6726 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6727 Vminibuf_scroll_window
= Qnil
;
6729 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6730 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6731 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6732 is displayed in the `mode-line' face. */);
6733 mode_line_in_non_selected_windows
= 1;
6735 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6736 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6737 Vother_window_scroll_buffer
= Qnil
;
6739 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6740 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6741 auto_window_vscroll_p
= 1;
6743 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6744 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6745 next_screen_context_lines
= 2;
6747 DEFVAR_LISP ("scroll-preserve-screen-position",
6748 Vscroll_preserve_screen_position
,
6749 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6750 A value of nil means point does not keep its screen position except
6751 at the scroll margin or window boundary respectively.
6752 A value of t means point keeps its screen position if the scroll
6753 command moved it vertically out of the window, e.g. when scrolling
6755 Any other value means point always keeps its screen position.
6756 Scroll commands should have the `scroll-command' property
6757 on their symbols to be controlled by this variable. */);
6758 Vscroll_preserve_screen_position
= Qnil
;
6760 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6761 doc
: /* Type of marker to use for `window-point'. */);
6762 Vwindow_point_insertion_type
= Qnil
;
6764 DEFVAR_LISP ("window-configuration-change-hook",
6765 Vwindow_configuration_change_hook
,
6766 doc
: /* Functions to call when window configuration changes.
6767 The buffer-local part is run once per window, with the relevant window
6768 selected; while the global part is run only once for the modified frame,
6769 with the relevant frame selected. */);
6770 Vwindow_configuration_change_hook
= Qnil
;
6772 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6773 doc
: /* Non-nil means `recenter' redraws entire frame.
6774 If this option is non-nil, then the `recenter' command with a nil
6775 argument will redraw the entire frame; the special value `tty' causes
6776 the frame to be redrawn only if it is a tty frame. */);
6777 Vrecenter_redisplay
= Qtty
;
6779 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6780 doc
: /* If t, resize window combinations proportionally.
6781 If this variable is nil, splitting a window gets the entire screen space
6782 for displaying the new window from the window to split. Deleting and
6783 resizing a window preferably resizes one adjacent window only.
6785 If this variable is t, splitting a window tries to get the space
6786 proportionally from all windows in the same combination. This also
6787 allows to split a window that is otherwise too small or of fixed size.
6788 Resizing and deleting a window proportionally resize all windows in the
6791 Other values are reserved for future use.
6793 This variable takes no effect if `window-combination-limit' is non-nil. */);
6794 Vwindow_combination_resize
= Qnil
;
6796 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6797 doc
: /* If non-nil, splitting a window makes a new parent window.
6798 The following values are recognized:
6800 nil means splitting a window will create a new parent window only if the
6801 window has no parent window or the window shall become part of a
6802 combination orthogonal to the one it is part of.
6804 `window-size' means that splitting a window for displaying a buffer
6805 makes a new parent window provided `display-buffer' is supposed to
6806 explicitly set the window's size due to the presence of a
6807 `window-height' or `window-width' entry in the alist used by
6808 `display-buffer'. Otherwise, this value is handled like nil.
6810 `temp-buffer' means that splitting a window for displaying a temporary
6811 buffer always makes a new parent window. Otherwise, this value is
6814 `display-buffer' means that splitting a window for displaying a buffer
6815 always makes a new parent window. Since temporary buffers are
6816 displayed by the function `display-buffer', this value is stronger
6817 than `temp-buffer'. Splitting a window for other purpose makes a
6818 new parent window only if needed.
6820 t means that splitting a window always creates a new parent window. If
6821 all splits behave this way, each frame's window tree is a binary
6822 tree and every window but the frame's root window has exactly one
6825 Other values are reserved for future use. */);
6826 Vwindow_combination_limit
= Qwindow_size
;
6828 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6829 doc
: /* Alist of persistent window parameters.
6830 This alist specifies which window parameters shall get saved by
6831 `current-window-configuration' and `window-state-get' and subsequently
6832 restored to their previous values by `set-window-configuration' and
6835 The car of each entry of this alist is the symbol specifying the
6836 parameter. The cdr is one of the following:
6838 nil means the parameter is neither saved by `window-state-get' nor by
6839 `current-window-configuration'.
6841 t means the parameter is saved by `current-window-configuration' and,
6842 provided its WRITABLE argument is nil, by `window-state-get'.
6844 The symbol `writable' means the parameter is saved unconditionally by
6845 both `current-window-configuration' and `window-state-get'. Do not use
6846 this value for parameters without read syntax (like windows or frames).
6848 Parameters not saved by `current-window-configuration' or
6849 `window-state-get' are left alone by `set-window-configuration'
6850 respectively are not installed by `window-state-put'. */);
6851 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6853 defsubr (&Sselected_window
);
6854 defsubr (&Sminibuffer_window
);
6855 defsubr (&Swindow_minibuffer_p
);
6856 defsubr (&Swindowp
);
6857 defsubr (&Swindow_valid_p
);
6858 defsubr (&Swindow_live_p
);
6859 defsubr (&Swindow_frame
);
6860 defsubr (&Sframe_root_window
);
6861 defsubr (&Sframe_first_window
);
6862 defsubr (&Sframe_selected_window
);
6863 defsubr (&Sset_frame_selected_window
);
6864 defsubr (&Spos_visible_in_window_p
);
6865 defsubr (&Swindow_line_height
);
6866 defsubr (&Swindow_buffer
);
6867 defsubr (&Swindow_parent
);
6868 defsubr (&Swindow_top_child
);
6869 defsubr (&Swindow_left_child
);
6870 defsubr (&Swindow_next_sibling
);
6871 defsubr (&Swindow_prev_sibling
);
6872 defsubr (&Swindow_combination_limit
);
6873 defsubr (&Sset_window_combination_limit
);
6874 defsubr (&Swindow_use_time
);
6875 defsubr (&Swindow_top_line
);
6876 defsubr (&Swindow_left_column
);
6877 defsubr (&Swindow_total_height
);
6878 defsubr (&Swindow_total_width
);
6879 defsubr (&Swindow_normal_size
);
6880 defsubr (&Swindow_new_total
);
6881 defsubr (&Swindow_new_normal
);
6882 defsubr (&Sset_window_new_total
);
6883 defsubr (&Sset_window_new_normal
);
6884 defsubr (&Swindow_resize_apply
);
6885 defsubr (&Swindow_body_height
);
6886 defsubr (&Swindow_body_width
);
6887 defsubr (&Swindow_hscroll
);
6888 defsubr (&Sset_window_hscroll
);
6889 defsubr (&Swindow_redisplay_end_trigger
);
6890 defsubr (&Sset_window_redisplay_end_trigger
);
6891 defsubr (&Swindow_edges
);
6892 defsubr (&Swindow_pixel_edges
);
6893 defsubr (&Swindow_absolute_pixel_edges
);
6894 defsubr (&Swindow_inside_edges
);
6895 defsubr (&Swindow_inside_pixel_edges
);
6896 defsubr (&Swindow_inside_absolute_pixel_edges
);
6897 defsubr (&Scoordinates_in_window_p
);
6898 defsubr (&Swindow_at
);
6899 defsubr (&Swindow_point
);
6900 defsubr (&Swindow_start
);
6901 defsubr (&Swindow_end
);
6902 defsubr (&Sset_window_point
);
6903 defsubr (&Sset_window_start
);
6904 defsubr (&Swindow_dedicated_p
);
6905 defsubr (&Sset_window_dedicated_p
);
6906 defsubr (&Swindow_display_table
);
6907 defsubr (&Sset_window_display_table
);
6908 defsubr (&Snext_window
);
6909 defsubr (&Sprevious_window
);
6910 defsubr (&Sget_buffer_window
);
6911 defsubr (&Sdelete_other_windows_internal
);
6912 defsubr (&Sdelete_window_internal
);
6913 defsubr (&Sresize_mini_window_internal
);
6914 defsubr (&Sset_window_buffer
);
6915 defsubr (&Srun_window_configuration_change_hook
);
6916 defsubr (&Sselect_window
);
6917 defsubr (&Sforce_window_update
);
6918 defsubr (&Ssplit_window_internal
);
6919 defsubr (&Sscroll_up
);
6920 defsubr (&Sscroll_down
);
6921 defsubr (&Sscroll_left
);
6922 defsubr (&Sscroll_right
);
6923 defsubr (&Sother_window_for_scrolling
);
6924 defsubr (&Sscroll_other_window
);
6925 defsubr (&Sminibuffer_selected_window
);
6926 defsubr (&Srecenter
);
6927 defsubr (&Swindow_text_height
);
6928 defsubr (&Smove_to_window_line
);
6929 defsubr (&Swindow_configuration_p
);
6930 defsubr (&Swindow_configuration_frame
);
6931 defsubr (&Sset_window_configuration
);
6932 defsubr (&Scurrent_window_configuration
);
6933 defsubr (&Sset_window_margins
);
6934 defsubr (&Swindow_margins
);
6935 defsubr (&Sset_window_fringes
);
6936 defsubr (&Swindow_fringes
);
6937 defsubr (&Sset_window_scroll_bars
);
6938 defsubr (&Swindow_scroll_bars
);
6939 defsubr (&Swindow_vscroll
);
6940 defsubr (&Sset_window_vscroll
);
6941 defsubr (&Scompare_window_configurations
);
6942 defsubr (&Swindow_list
);
6943 defsubr (&Swindow_list_1
);
6944 defsubr (&Swindow_prev_buffers
);
6945 defsubr (&Sset_window_prev_buffers
);
6946 defsubr (&Swindow_next_buffers
);
6947 defsubr (&Sset_window_next_buffers
);
6948 defsubr (&Swindow_parameters
);
6949 defsubr (&Swindow_parameter
);
6950 defsubr (&Sset_window_parameter
);
6954 keys_of_window (void)
6956 initial_define_key (control_x_map
, '<', "scroll-left");
6957 initial_define_key (control_x_map
, '>', "scroll-right");
6959 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6960 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6961 initial_define_key (meta_map
, 'v', "scroll-down-command");