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
29 #include "character.h"
39 #include "dispextern.h"
40 #include "blockinput.h"
41 #include "intervals.h"
42 #include "termhooks.h" /* For FRAME_TERMINAL. */
46 #endif /* HAVE_X_WINDOWS */
59 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_valid_p
;
60 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
61 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
62 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
63 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
64 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
65 static Lisp_Object Qsafe
, Qabove
, Qbelow
;
66 static Lisp_Object Qclone_of
;
68 static int displayed_window_lines (struct window
*);
69 static int count_windows (struct window
*);
70 static int get_leaf_windows (struct window
*, struct window
**, int);
71 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
72 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
73 static void window_scroll_line_based (Lisp_Object
, int, int, int);
74 static int freeze_window_start (struct window
*, void *);
75 static Lisp_Object
window_list (void);
76 static int add_window_to_list (struct window
*, void *);
77 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
79 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
81 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
83 static void foreach_window (struct frame
*,
84 int (* fn
) (struct window
*, void *),
86 static int foreach_window_1 (struct window
*,
87 int (* fn
) (struct window
*, void *),
89 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
90 static int window_resize_check (struct window
*, int);
91 static void window_resize_apply (struct window
*, int);
92 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
94 /* This is the window in which the terminal's cursor should
95 be left when nothing is being done with it. This must
96 always be a leaf window, and its buffer is selected by
97 the top level editing loop at the end of each command.
99 This value is always the same as
100 FRAME_SELECTED_WINDOW (selected_frame). */
101 Lisp_Object selected_window
;
103 /* A list of all windows for use by next_window and Fwindow_list.
104 Functions creating or deleting windows should invalidate this cache
105 by setting it to nil. */
106 Lisp_Object Vwindow_list
;
108 /* The mini-buffer window of the selected frame.
109 Note that you cannot test for mini-bufferness of an arbitrary window
110 by comparing against this; but you can test for mini-bufferness of
111 the selected window. */
112 Lisp_Object minibuf_window
;
114 /* Non-nil means it is the window whose mode line should be
115 shown as the selected window when the minibuffer is selected. */
116 Lisp_Object minibuf_selected_window
;
118 /* Hook run at end of temp_output_buffer_show. */
119 static Lisp_Object Qtemp_buffer_show_hook
;
121 /* Incremented for each window created. */
122 static int sequence_number
;
124 /* Nonzero after init_window_once has finished. */
125 static int window_initialized
;
127 /* Hook to run when window config changes. */
128 static Lisp_Object Qwindow_configuration_change_hook
;
130 /* Used by the function window_scroll_pixel_based */
131 static int window_scroll_pixel_based_preserve_x
;
132 static int window_scroll_pixel_based_preserve_y
;
134 /* Same for window_scroll_line_based. */
135 static EMACS_INT window_scroll_preserve_hpos
;
136 static EMACS_INT window_scroll_preserve_vpos
;
138 /* These setters are used only in this file, so they can be private. */
140 wset_combination_limit (struct window
*w
, Lisp_Object val
)
142 w
->combination_limit
= val
;
145 wset_dedicated (struct window
*w
, Lisp_Object val
)
150 wset_display_table (struct window
*w
, Lisp_Object val
)
152 w
->display_table
= val
;
155 wset_hchild (struct window
*w
, Lisp_Object val
)
160 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
162 w
->left_fringe_width
= val
;
165 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
167 w
->left_margin_cols
= val
;
170 wset_new_normal (struct window
*w
, Lisp_Object val
)
175 wset_new_total (struct window
*w
, Lisp_Object val
)
180 wset_next_buffers (struct window
*w
, Lisp_Object val
)
182 w
->next_buffers
= val
;
185 wset_normal_cols (struct window
*w
, Lisp_Object val
)
187 w
->normal_cols
= val
;
190 wset_normal_lines (struct window
*w
, Lisp_Object val
)
192 w
->normal_lines
= val
;
195 wset_parent (struct window
*w
, Lisp_Object val
)
200 wset_pointm (struct window
*w
, Lisp_Object val
)
205 wset_prev_buffers (struct window
*w
, Lisp_Object val
)
207 w
->prev_buffers
= val
;
210 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
212 w
->right_fringe_width
= val
;
215 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
217 w
->right_margin_cols
= val
;
220 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
222 w
->scroll_bar_width
= val
;
225 wset_start (struct window
*w
, Lisp_Object val
)
230 wset_temslot (struct window
*w
, Lisp_Object val
)
235 wset_vchild (struct window
*w
, Lisp_Object val
)
240 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
242 w
->vertical_scroll_bar_type
= val
;
245 wset_window_parameters (struct window
*w
, Lisp_Object val
)
247 w
->window_parameters
= val
;
251 decode_live_window (register Lisp_Object window
)
254 return XWINDOW (selected_window
);
256 CHECK_LIVE_WINDOW (window
);
257 return XWINDOW (window
);
260 static struct window
*
261 decode_any_window (register Lisp_Object window
)
266 return XWINDOW (selected_window
);
268 CHECK_WINDOW (window
);
269 w
= XWINDOW (window
);
273 static struct window
*
274 decode_valid_window (register Lisp_Object window
)
279 return XWINDOW (selected_window
);
281 CHECK_VALID_WINDOW (window
);
282 w
= XWINDOW (window
);
286 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
287 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
290 return WINDOWP (object
) ? Qt
: Qnil
;
293 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
294 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
295 A valid window is either a window that displays a buffer or an internal
296 window. Deleted windows are not live. */)
299 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
302 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
303 doc
: /* Return t if OBJECT is a live window and nil otherwise.
304 A live window is a window that displays a buffer.
305 Internal windows and deleted windows are not live. */)
308 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
311 /* Frames and windows. */
312 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
313 doc
: /* Return the frame that window WINDOW is on.
314 WINDOW must be a valid window and defaults to the selected one. */)
317 return decode_valid_window (window
)->frame
;
320 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
321 doc
: /* Return the root window of FRAME-OR-WINDOW.
322 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
323 With a frame argument, return that frame's root window.
324 With a window argument, return the root window of that window's frame. */)
325 (Lisp_Object frame_or_window
)
329 if (NILP (frame_or_window
))
330 window
= SELECTED_FRAME ()->root_window
;
331 else if (WINDOW_VALID_P (frame_or_window
))
332 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
335 CHECK_LIVE_FRAME (frame_or_window
);
336 window
= XFRAME (frame_or_window
)->root_window
;
342 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
343 doc
: /* Return the minibuffer window for frame FRAME.
344 If FRAME is omitted or nil, it defaults to the selected frame. */)
348 frame
= selected_frame
;
349 CHECK_LIVE_FRAME (frame
);
350 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
353 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
354 Swindow_minibuffer_p
, 0, 1, 0,
355 doc
: /* Return non-nil if WINDOW is a minibuffer window.
356 WINDOW must be a valid window and defaults to the selected one. */)
359 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
362 /* Don't move this to window.el - this must be a safe routine. */
363 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
364 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
365 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
366 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
367 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
368 the first window of that frame. */)
369 (Lisp_Object frame_or_window
)
373 if (NILP (frame_or_window
))
374 window
= SELECTED_FRAME ()->root_window
;
375 else if (WINDOW_VALID_P (frame_or_window
))
376 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
379 CHECK_LIVE_FRAME (frame_or_window
);
380 window
= XFRAME (frame_or_window
)->root_window
;
383 while (NILP (XWINDOW (window
)->buffer
))
385 if (! NILP (XWINDOW (window
)->hchild
))
386 window
= XWINDOW (window
)->hchild
;
387 else if (! NILP (XWINDOW (window
)->vchild
))
388 window
= XWINDOW (window
)->vchild
;
396 DEFUN ("frame-selected-window", Fframe_selected_window
,
397 Sframe_selected_window
, 0, 1, 0,
398 doc
: /* Return the selected window of FRAME-OR-WINDOW.
399 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
400 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
401 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
402 return the selected window of that frame. */)
403 (Lisp_Object frame_or_window
)
407 if (NILP (frame_or_window
))
408 window
= SELECTED_FRAME ()->selected_window
;
409 else if (WINDOW_VALID_P (frame_or_window
))
410 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
413 CHECK_LIVE_FRAME (frame_or_window
);
414 window
= XFRAME (frame_or_window
)->selected_window
;
420 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
421 Sset_frame_selected_window
, 2, 3, 0,
422 doc
: /* Set selected window of FRAME to WINDOW.
423 FRAME must be a live frame and defaults to the selected one. If FRAME
424 is the selected frame, this makes WINDOW the selected window. Optional
425 argument NORECORD non-nil means to neither change the order of recently
426 selected windows nor the buffer list. WINDOW must denote a live window.
428 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
431 frame
= selected_frame
;
433 CHECK_LIVE_FRAME (frame
);
434 CHECK_LIVE_WINDOW (window
);
436 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
437 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
439 if (EQ (frame
, selected_frame
))
440 return Fselect_window (window
, norecord
);
443 fset_selected_window (XFRAME (frame
), window
);
448 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
449 doc
: /* Return the selected window.
450 The selected window is the window in which the standard cursor for
451 selected windows appears and to which many commands apply. */)
454 return selected_window
;
457 int window_select_count
;
459 /* If select_window is called with inhibit_point_swap non-zero it will
460 not store point of the old selected window's buffer back into that
461 window's pointm slot. This is needed by Fset_window_configuration to
462 avoid that the display routine is called with selected_window set to
463 Qnil causing a subsequent crash. */
465 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
467 register struct window
*w
;
468 register struct window
*ow
;
471 CHECK_LIVE_WINDOW (window
);
473 w
= XWINDOW (window
);
474 w
->frozen_window_start_p
= 0;
478 w
->use_time
= ++window_select_count
;
479 record_buffer (w
->buffer
);
482 /* Make the selected window's buffer current. */
483 Fset_buffer (w
->buffer
);
485 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
488 sf
= SELECTED_FRAME ();
489 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
491 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
492 /* Use this rather than Fhandle_switch_frame
493 so that FRAME_FOCUS_FRAME is moved appropriately as we
494 move around in the state where a minibuffer in a separate
496 Fselect_frame (WINDOW_FRAME (w
), norecord
);
497 /* Fselect_frame called us back so we've done all the work already. */
498 eassert (EQ (window
, selected_window
));
502 fset_selected_window (sf
, window
);
504 /* Store the old selected window's buffer's point in pointm of the old
505 selected window. It belongs to that window, and when the window is
506 not selected, must be in the window. */
507 if (!inhibit_point_swap
)
509 ow
= XWINDOW (selected_window
);
510 if (! NILP (ow
->buffer
))
511 set_marker_both (ow
->pointm
, ow
->buffer
,
512 BUF_PT (XBUFFER (ow
->buffer
)),
513 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
516 selected_window
= window
;
517 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
519 /* Go to the point recorded in the window.
520 This is important when the buffer is in more
521 than one window. It also matters when
522 redisplay_window has altered point after scrolling,
523 because it makes the change only in the window. */
525 register ptrdiff_t new_point
= marker_position (w
->pointm
);
526 if (new_point
< BEGV
)
528 else if (new_point
> ZV
)
534 windows_or_buffers_changed
++;
538 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
539 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
540 Also make WINDOW's buffer current and make WINDOW the frame's selected
541 window. Return WINDOW.
543 Optional second arg NORECORD non-nil means do not put this buffer at the
544 front of the buffer list and do not make this window the most recently
547 Note that the main editor command loop sets the current buffer to the
548 buffer of the selected window before each command. */)
549 (register Lisp_Object window
, Lisp_Object norecord
)
551 return select_window (window
, norecord
, 0);
554 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
555 doc
: /* Return the buffer displayed in window WINDOW.
556 If WINDOW is omitted or nil, it defaults to the selected window.
557 Return nil for an internal window or a deleted window. */)
560 return decode_any_window (window
)->buffer
;
563 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
564 doc
: /* Return the parent window of window WINDOW.
565 WINDOW must be a valid window and defaults to the selected one.
566 Return nil for a window with no parent (e.g. a root window). */)
569 return decode_valid_window (window
)->parent
;
572 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 1, 1, 0,
573 doc
: /* Return the topmost child window of window WINDOW.
574 WINDOW must be a valid window and defaults to the selected one.
575 Return nil if WINDOW is a live window (live windows have no children).
576 Return nil if WINDOW is an internal window whose children form a
577 horizontal combination. */)
580 CHECK_WINDOW (window
);
581 return decode_valid_window (window
)->vchild
;
584 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 1, 1, 0,
585 doc
: /* Return the leftmost child window of window WINDOW.
586 WINDOW must be a valid window and defaults to the selected one.
587 Return nil if WINDOW is a live window (live windows have no children).
588 Return nil if WINDOW is an internal window whose children form a
589 vertical combination. */)
592 CHECK_WINDOW (window
);
593 return decode_valid_window (window
)->hchild
;
596 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
597 doc
: /* Return the next sibling window of window WINDOW.
598 WINDOW must be a valid window and defaults to the selected one.
599 Return nil if WINDOW has no next sibling. */)
602 return decode_valid_window (window
)->next
;
605 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
606 doc
: /* Return the previous sibling window of window WINDOW.
607 WINDOW must be a valid window and defaults to the selected one.
608 Return nil if WINDOW has no previous sibling. */)
611 return decode_valid_window (window
)->prev
;
614 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
615 doc
: /* Return combination limit of window WINDOW.
616 WINDOW must be a valid window and defaults to the selected one.
617 If the return value is nil, child windows of WINDOW can be recombined with
618 WINDOW's siblings. A return value of t means that child windows of
619 WINDOW are never \(re-)combined with WINDOW's siblings. */)
622 return decode_valid_window (window
)->combination_limit
;
625 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
626 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
627 WINDOW must be a valid window and defaults to the selected one.
628 If LIMIT is nil, child windows of WINDOW can be recombined with
629 WINDOW's siblings. LIMIT t means that child windows of WINDOW are
630 never \(re-)combined with WINDOW's siblings. Other values are reserved
632 (Lisp_Object window
, Lisp_Object limit
)
634 wset_combination_limit (decode_valid_window (window
), limit
);
638 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
639 doc
: /* Return the use time of window WINDOW.
640 WINDOW must be a live window and defaults to the selected one.
641 The window with the highest use time is the most recently selected
642 one. The window with the lowest use time is the least recently
646 return make_number (decode_live_window (window
)->use_time
);
649 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
650 doc
: /* Return the total height, in lines, of window WINDOW.
651 WINDOW must be a valid window and defaults to the selected one.
653 The return value includes the mode line and header line, if any.
654 If WINDOW is an internal window, the total height is the height
655 of the screen areas spanned by its children.
657 On a graphical display, this total height is reported as an
658 integer multiple of the default character height. */)
661 return decode_valid_window (window
)->total_lines
;
664 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
665 doc
: /* Return the total width, in columns, of window WINDOW.
666 WINDOW must be a valid window and defaults to the selected one.
668 The return value includes any vertical dividers or scroll bars
669 belonging to WINDOW. If WINDOW is an internal window, the total width
670 is the width of the screen areas spanned by its children.
672 On a graphical display, this total width is reported as an
673 integer multiple of the default character width. */)
676 return decode_valid_window (window
)->total_cols
;
679 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
680 doc
: /* Return the new total size of window WINDOW.
681 WINDOW must be a valid window and defaults to the selected one. */)
684 return decode_valid_window (window
)->new_total
;
687 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
688 doc
: /* Return the normal height of window WINDOW.
689 WINDOW must be a valid window and defaults to the selected one.
690 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
691 (Lisp_Object window
, Lisp_Object horizontal
)
693 struct window
*w
= decode_valid_window (window
);
695 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
698 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
699 doc
: /* Return new normal size of window WINDOW.
700 WINDOW must be a valid window and defaults to the selected one. */)
703 return decode_valid_window (window
)->new_normal
;
706 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
707 doc
: /* Return left column of window WINDOW.
708 This is the distance, in columns, between the left edge of WINDOW and
709 the left edge of the frame's window area. For instance, the return
710 value is 0 if there is no window to the left of WINDOW.
712 WINDOW must be a valid window and defaults to the selected one. */)
715 return decode_valid_window (window
)->left_col
;
718 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
719 doc
: /* Return top line of window WINDOW.
720 This is the distance, in lines, between the top of WINDOW and the top
721 of the frame's window area. For instance, the return value is 0 if
722 there is no window above WINDOW.
724 WINDOW must be a valid window and defaults to the selected one. */)
727 return decode_valid_window (window
)->top_line
;
730 /* Return the number of lines of W's body. Don't count any mode or
734 window_body_lines (struct window
*w
)
736 int height
= XFASTINT (w
->total_lines
);
738 if (!MINI_WINDOW_P (w
))
740 if (WINDOW_WANTS_MODELINE_P (w
))
742 if (WINDOW_WANTS_HEADER_LINE_P (w
))
749 /* Return the number of columns of W's body. Don't count columns
750 occupied by the scroll bar or the vertical bar separating W from its
751 right sibling. On window-systems don't count fringes or display
755 window_body_cols (struct window
*w
)
757 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
758 int width
= XINT (w
->total_cols
);
760 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
761 /* Scroll bars occupy a few columns. */
762 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
763 else if (!FRAME_WINDOW_P (f
)
764 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
765 /* The column of `|' characters separating side-by-side windows
766 occupies one column only. */
769 if (FRAME_WINDOW_P (f
))
770 /* On window-systems, fringes and display margins cannot be
771 used for normal text. */
772 width
-= (WINDOW_FRINGE_COLS (w
)
773 + WINDOW_LEFT_MARGIN_COLS (w
)
774 + WINDOW_RIGHT_MARGIN_COLS (w
));
779 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
780 doc
: /* Return the height, in lines, of WINDOW's text area.
781 WINDOW must be a live window and defaults to the selected one.
783 The returned height does not include the mode line or header line.
784 On a graphical display, the height is expressed as an integer multiple
785 of the default character height. If a line at the bottom of the text
786 area is only partially visible, that counts as a whole line; to
787 exclude partially-visible lines, use `window-text-height'. */)
790 struct window
*w
= decode_live_window (window
);
791 return make_number (window_body_lines (w
));
794 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
795 doc
: /* Return the width, in columns, of WINDOW's text area.
796 WINDOW must be a live window and defaults to the selected one.
798 The return value does not include any vertical dividers, fringe or
799 marginal areas, or scroll bars. On a graphical display, the width is
800 expressed as an integer multiple of the default character width. */)
803 struct window
*w
= decode_live_window (window
);
804 return make_number (window_body_cols (w
));
807 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
808 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
809 WINDOW must be a live window and defaults to the selected one. */)
812 return make_number (decode_live_window (window
)->hscroll
);
815 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
816 range, returning the new amount as a fixnum. */
818 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
820 /* Horizontal scrolling has problems with large scroll amounts.
821 It's too slow with long lines, and even with small lines the
822 display can be messed up. For now, though, impose only the limits
823 required by the internal representation: horizontal scrolling must
824 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
825 (since it's stored in a ptrdiff_t). */
826 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
827 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
829 /* Prevent redisplay shortcuts when changing the hscroll. */
830 if (w
->hscroll
!= new_hscroll
)
831 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
833 w
->hscroll
= new_hscroll
;
834 return make_number (new_hscroll
);
837 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
838 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
839 WINDOW must be a live window and defaults to the selected one.
840 Clip the number to a reasonable value if out of range.
841 Return the new number. NCOL should be zero or positive.
843 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
844 window so that the location of point moves off-window. */)
845 (Lisp_Object window
, Lisp_Object ncol
)
847 struct window
*w
= decode_live_window (window
);
850 return set_window_hscroll (w
, XINT (ncol
));
853 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
854 Swindow_redisplay_end_trigger
, 0, 1, 0,
855 doc
: /* Return WINDOW's redisplay end trigger value.
856 WINDOW must be a live window and defaults to the selected one.
857 See `set-window-redisplay-end-trigger' for more information. */)
860 return decode_live_window (window
)->redisplay_end_trigger
;
863 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
864 Sset_window_redisplay_end_trigger
, 2, 2, 0,
865 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
866 WINDOW must be a live window and defaults to the selected one. VALUE
867 should be a buffer position (typically a marker) or nil. If it is a
868 buffer position, then if redisplay in WINDOW reaches a position beyond
869 VALUE, the functions in `redisplay-end-trigger-functions' are called
870 with two arguments: WINDOW, and the end trigger value. Afterwards the
871 end-trigger value is reset to nil. */)
872 (register Lisp_Object window
, Lisp_Object value
)
874 wset_redisplay_end_trigger (decode_live_window (window
), value
);
878 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
879 doc
: /* Return a list of the edge coordinates of WINDOW.
880 WINDOW must be a valid window and defaults to the selected one.
882 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
883 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
884 0 at top left corner of frame.
886 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
887 is one more than the bottommost row occupied by WINDOW. The edges
888 include the space used by WINDOW's scroll bar, display margins, fringes,
889 header line, and/or mode line. For the edges of just the text area, use
890 `window-inside-edges'. */)
893 register struct window
*w
= decode_valid_window (window
);
895 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
896 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
897 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
898 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
902 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
903 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
904 WINDOW must be a valid window and defaults to the selected one.
906 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
907 0, 0 at the top left corner of the frame.
909 RIGHT is one more than the rightmost x position occupied by WINDOW.
910 BOTTOM is one more than the bottommost y position occupied by WINDOW.
911 The pixel edges include the space used by WINDOW's scroll bar, display
912 margins, fringes, header line, and/or mode line. For the pixel edges
913 of just the text area, use `window-inside-pixel-edges'. */)
916 register struct window
*w
= decode_valid_window (window
);
918 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
919 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
920 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
921 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
926 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
928 struct frame
*f
= XFRAME (w
->frame
);
930 #ifdef FRAME_MENUBAR_HEIGHT
931 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
933 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
934 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
935 #elif FRAME_TOOLBAR_HEIGHT
936 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
938 #ifdef FRAME_NS_TITLEBAR_HEIGHT
939 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
941 *add_x
= f
->left_pos
;
942 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
943 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
947 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
948 Swindow_absolute_pixel_edges
, 0, 1, 0,
949 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
950 WINDOW must be a valid window and defaults to the selected one.
952 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
953 0, 0 at the top left corner of the display.
955 RIGHT is one more than the rightmost x position occupied by WINDOW.
956 BOTTOM is one more than the bottommost y position occupied by WINDOW.
957 The pixel edges include the space used by WINDOW's scroll bar, display
958 margins, fringes, header line, and/or mode line. For the pixel edges
959 of just the text area, use `window-inside-absolute-pixel-edges'. */)
962 register struct window
*w
= decode_valid_window (window
);
964 calc_absolute_offset (w
, &add_x
, &add_y
);
966 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
967 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
968 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
969 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
973 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
974 doc
: /* Return a list of the edge coordinates of WINDOW.
975 WINDOW must be a live window and defaults to the selected one.
977 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
978 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
979 0 at top left corner of frame.
981 RIGHT is one more than the rightmost column of WINDOW's text area.
982 BOTTOM is one more than the bottommost row of WINDOW's text area. The
983 inside edges do not include the space used by the WINDOW's scroll bar,
984 display margins, fringes, header line, and/or mode line. */)
987 register struct window
*w
= decode_live_window (window
);
989 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
990 + WINDOW_LEFT_MARGIN_COLS (w
)
991 + WINDOW_LEFT_FRINGE_COLS (w
)),
992 make_number (WINDOW_TOP_EDGE_LINE (w
)
993 + WINDOW_HEADER_LINE_LINES (w
)),
994 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
995 - WINDOW_RIGHT_MARGIN_COLS (w
)
996 - WINDOW_RIGHT_FRINGE_COLS (w
)),
997 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
998 - WINDOW_MODE_LINE_LINES (w
)));
1001 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
1002 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1003 WINDOW must be a live window and defaults to the selected one.
1005 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1006 (0,0) at the top left corner of the frame's window area.
1008 RIGHT is one more than the rightmost x position of WINDOW's text area.
1009 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1010 The inside edges do not include the space used by WINDOW's scroll bar,
1011 display margins, fringes, header line, and/or mode line. */)
1012 (Lisp_Object window
)
1014 register struct window
*w
= decode_live_window (window
);
1016 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
1017 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1018 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1019 make_number (WINDOW_TOP_EDGE_Y (w
)
1020 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1021 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
1022 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1023 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1024 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
1025 - WINDOW_MODE_LINE_HEIGHT (w
)));
1028 DEFUN ("window-inside-absolute-pixel-edges",
1029 Fwindow_inside_absolute_pixel_edges
,
1030 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1031 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1032 WINDOW must be a live window and defaults to the selected one.
1034 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1035 (0,0) at the top left corner of the frame's window area.
1037 RIGHT is one more than the rightmost x position of WINDOW's text area.
1038 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1039 The inside edges do not include the space used by WINDOW's scroll bar,
1040 display margins, fringes, header line, and/or mode line. */)
1041 (Lisp_Object window
)
1043 register struct window
*w
= decode_live_window (window
);
1045 calc_absolute_offset (w
, &add_x
, &add_y
);
1047 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
1048 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1049 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1050 make_number (WINDOW_TOP_EDGE_Y (w
)
1051 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1052 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
1053 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1054 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1055 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
1056 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1059 /* Test if the character at column X, row Y is within window W.
1060 If it is not, return ON_NOTHING;
1061 if it is in the window's text area, return ON_TEXT;
1062 if it is on the window's modeline, return ON_MODE_LINE;
1063 if it is on the border between the window and its right sibling,
1064 return ON_VERTICAL_BORDER.
1065 if it is on a scroll bar, return ON_SCROLL_BAR.
1066 if it is on the window's top line, return ON_HEADER_LINE;
1067 if it is in left or right fringe of the window,
1068 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1069 if it is in the marginal area to the left/right of the window,
1070 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1072 X and Y are frame relative pixel coordinates. */
1074 static enum window_part
1075 coordinates_in_window (register struct window
*w
, int x
, int y
)
1077 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1078 enum window_part part
;
1079 int ux
= FRAME_COLUMN_WIDTH (f
);
1080 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1081 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1082 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1083 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1084 /* The width of the area where the vertical line can be dragged.
1085 (Between mode lines for instance. */
1086 int grabbable_width
= ux
;
1087 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1089 /* Outside any interesting row or column? */
1090 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1093 /* On the mode line or header line? */
1094 if ((WINDOW_WANTS_MODELINE_P (w
)
1095 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1096 && (part
= ON_MODE_LINE
))
1097 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1098 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1099 && (part
= ON_HEADER_LINE
)))
1101 /* If it's under/over the scroll bar portion of the mode/header
1102 line, say it's on the vertical line. That's to be able to
1103 resize windows horizontally in case we're using toolkit scroll
1104 bars. Note: If scrollbars are on the left, the window that
1105 must be eventually resized is that on the left of WINDOW. */
1106 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1107 && !WINDOW_LEFTMOST_P (w
)
1108 && eabs (x
- left_x
) < grabbable_width
)
1109 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1110 && !WINDOW_RIGHTMOST_P (w
)
1111 && eabs (x
- right_x
) < grabbable_width
))
1112 return ON_VERTICAL_BORDER
;
1117 /* In what's below, we subtract 1 when computing right_x because we
1118 want the rightmost pixel, which is given by left_pixel+width-1. */
1119 if (w
->pseudo_window_p
)
1122 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1126 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1127 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1130 /* Outside any interesting column? */
1131 if (x
< left_x
|| x
> right_x
)
1132 return ON_SCROLL_BAR
;
1134 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1135 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1137 text_left
= window_box_left (w
, TEXT_AREA
);
1138 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1140 if (FRAME_WINDOW_P (f
))
1142 if (!w
->pseudo_window_p
1143 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1144 && !WINDOW_RIGHTMOST_P (w
)
1145 && (eabs (x
- right_x
) < grabbable_width
))
1146 return ON_VERTICAL_BORDER
;
1148 /* Need to say "x > right_x" rather than >=, since on character
1149 terminals, the vertical line's x coordinate is right_x. */
1150 else if (!w
->pseudo_window_p
1151 && !WINDOW_RIGHTMOST_P (w
)
1152 && x
> right_x
- ux
)
1153 return ON_VERTICAL_BORDER
;
1157 if (lmargin_width
> 0
1158 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1159 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1160 : (x
< left_x
+ lmargin_width
)))
1161 return ON_LEFT_MARGIN
;
1163 return ON_LEFT_FRINGE
;
1166 if (x
>= text_right
)
1168 if (rmargin_width
> 0
1169 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1170 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1171 : (x
>= right_x
- rmargin_width
)))
1172 return ON_RIGHT_MARGIN
;
1174 return ON_RIGHT_FRINGE
;
1177 /* Everything special ruled out - must be on text area */
1181 /* Take X is the frame-relative pixel x-coordinate, and return the
1182 x-coordinate relative to part PART of window W. */
1184 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1186 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1191 return x
- window_box_left (w
, TEXT_AREA
);
1193 case ON_LEFT_FRINGE
:
1196 case ON_RIGHT_FRINGE
:
1197 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1199 case ON_LEFT_MARGIN
:
1201 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1202 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1204 case ON_RIGHT_MARGIN
:
1206 - ((w
->pseudo_window_p
)
1207 ? WINDOW_TOTAL_WIDTH (w
)
1208 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1209 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1210 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1211 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1214 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1219 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1220 Scoordinates_in_window_p
, 2, 2, 0,
1221 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1222 WINDOW must be a live window and defaults to the selected one.
1223 COORDINATES is a cons of the form (X . Y), X and Y being distances
1224 measured in characters from the upper-left corner of the frame.
1225 \(0 . 0) denotes the character in the upper left corner of the
1227 If COORDINATES are in the text portion of WINDOW,
1228 the coordinates relative to the window are returned.
1229 If they are in the mode line of WINDOW, `mode-line' is returned.
1230 If they are in the top mode line of WINDOW, `header-line' is returned.
1231 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1232 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1233 If they are on the border between WINDOW and its right sibling,
1234 `vertical-line' is returned.
1235 If they are in the windows's left or right marginal areas, `left-margin'\n\
1236 or `right-margin' is returned. */)
1237 (register Lisp_Object coordinates
, Lisp_Object window
)
1244 w
= decode_live_window (window
);
1245 f
= XFRAME (w
->frame
);
1246 CHECK_CONS (coordinates
);
1247 lx
= Fcar (coordinates
);
1248 ly
= Fcdr (coordinates
);
1249 CHECK_NUMBER_OR_FLOAT (lx
);
1250 CHECK_NUMBER_OR_FLOAT (ly
);
1251 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1252 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1254 switch (coordinates_in_window (w
, x
, y
))
1260 /* Convert X and Y to window relative pixel coordinates, and
1261 return the canonical char units. */
1262 x
-= window_box_left (w
, TEXT_AREA
);
1263 y
-= WINDOW_TOP_EDGE_Y (w
);
1264 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1265 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1270 case ON_VERTICAL_BORDER
:
1271 return Qvertical_line
;
1273 case ON_HEADER_LINE
:
1274 return Qheader_line
;
1276 case ON_LEFT_FRINGE
:
1277 return Qleft_fringe
;
1279 case ON_RIGHT_FRINGE
:
1280 return Qright_fringe
;
1282 case ON_LEFT_MARGIN
:
1283 return Qleft_margin
;
1285 case ON_RIGHT_MARGIN
:
1286 return Qright_margin
;
1289 /* Historically we are supposed to return nil in this case. */
1298 /* Callback for foreach_window, used in window_from_coordinates.
1299 Check if window W contains coordinates specified by USER_DATA which
1300 is actually a pointer to a struct check_window_data CW.
1302 Check if window W contains coordinates *CW->x and *CW->y. If it
1303 does, return W in *CW->window, as Lisp_Object, and return in
1304 *CW->part the part of the window under coordinates *X,*Y. Return
1305 zero from this function to stop iterating over windows. */
1307 struct check_window_data
1309 Lisp_Object
*window
;
1311 enum window_part
*part
;
1315 check_window_containing (struct window
*w
, void *user_data
)
1317 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1318 enum window_part found
;
1321 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1322 if (found
!= ON_NOTHING
)
1325 XSETWINDOW (*cw
->window
, w
);
1333 /* Find the window containing frame-relative pixel position X/Y and
1334 return it as a Lisp_Object.
1336 If X, Y is on one of the window's special `window_part' elements,
1337 set *PART to the id of that element.
1339 If there is no window under X, Y return nil and leave *PART
1340 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1342 This function was previously implemented with a loop cycling over
1343 windows with Fnext_window, and starting with the frame's selected
1344 window. It turned out that this doesn't work with an
1345 implementation of next_window using Vwindow_list, because
1346 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1347 tree of F when this function is called asynchronously from
1348 note_mouse_highlight. The original loop didn't terminate in this
1352 window_from_coordinates (struct frame
*f
, int x
, int y
,
1353 enum window_part
*part
, int tool_bar_p
)
1356 struct check_window_data cw
;
1357 enum window_part dummy
;
1363 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1364 foreach_window (f
, check_window_containing
, &cw
);
1366 /* If not found above, see if it's in the tool bar window, if a tool
1370 && WINDOWP (f
->tool_bar_window
)
1371 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1372 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1376 window
= f
->tool_bar_window
;
1382 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1383 doc
: /* Return window containing coordinates X and Y on FRAME.
1384 FRAME must be a live frame and defaults to the selected one.
1385 The top left corner of the frame is considered to be row 0,
1387 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1392 frame
= selected_frame
;
1393 CHECK_LIVE_FRAME (frame
);
1396 /* Check that arguments are integers or floats. */
1397 CHECK_NUMBER_OR_FLOAT (x
);
1398 CHECK_NUMBER_OR_FLOAT (y
);
1400 return window_from_coordinates (f
,
1401 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1402 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1403 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1404 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1408 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1409 doc
: /* Return current value of point in WINDOW.
1410 WINDOW must be a live window and defaults to the selected one.
1412 For a nonselected window, this is the value point would have if that
1413 window were selected.
1415 Note that, when WINDOW is selected, the value returned is the same as
1416 that returned by `point' for WINDOW's buffer. It would be more strictly
1417 correct to return the `top-level' value of `point', outside of any
1418 `save-excursion' forms. But that is hard to define. */)
1419 (Lisp_Object window
)
1421 register struct window
*w
= decode_live_window (window
);
1423 if (w
== XWINDOW (selected_window
))
1424 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1426 return Fmarker_position (w
->pointm
);
1429 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1430 doc
: /* Return position at which display currently starts in WINDOW.
1431 WINDOW must be a live window and defaults to the selected one.
1432 This is updated by redisplay or by calling `set-window-start'. */)
1433 (Lisp_Object window
)
1435 return Fmarker_position (decode_live_window (window
)->start
);
1438 /* This is text temporarily removed from the doc string below.
1440 This function returns nil if the position is not currently known.
1441 That happens when redisplay is preempted and doesn't finish.
1442 If in that case you want to compute where the end of the window would
1443 have been if redisplay had finished, do this:
1445 (goto-char (window-start window))
1446 (vertical-motion (1- (window-height window)) window)
1449 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1450 doc
: /* Return position at which display currently ends in WINDOW.
1451 WINDOW must be a live window and defaults to the selected one.
1452 This is updated by redisplay, when it runs to completion.
1453 Simply changing the buffer text or setting `window-start'
1454 does not update this value.
1455 Return nil if there is no recorded value. (This can happen if the
1456 last redisplay of WINDOW was preempted, and did not finish.)
1457 If UPDATE is non-nil, compute the up-to-date position
1458 if it isn't already recorded. */)
1459 (Lisp_Object window
, Lisp_Object update
)
1462 struct window
*w
= decode_live_window (window
);
1470 #if 0 /* This change broke some things. We should make it later. */
1471 /* If we don't know the end position, return nil.
1472 The user can compute it with vertical-motion if he wants to.
1473 It would be nicer to do it automatically,
1474 but that's so slow that it would probably bother people. */
1475 if (NILP (w
->window_end_valid
))
1480 && ! (! NILP (w
->window_end_valid
)
1481 && w
->last_modified
>= BUF_MODIFF (b
)
1482 && w
->last_overlay_modified
>= BUF_OVERLAY_MODIFF (b
))
1485 struct text_pos startp
;
1487 struct buffer
*old_buffer
= NULL
;
1488 void *itdata
= NULL
;
1490 /* Cannot use Fvertical_motion because that function doesn't
1491 cope with variable-height lines. */
1492 if (b
!= current_buffer
)
1494 old_buffer
= current_buffer
;
1495 set_buffer_internal (b
);
1498 /* In case W->start is out of the range, use something
1499 reasonable. This situation occurred when loading a file with
1500 `-l' containing a call to `rmail' with subsequent other
1501 commands. At the end, W->start happened to be BEG, while
1502 rmail had already narrowed the buffer. */
1503 if (XMARKER (w
->start
)->charpos
< BEGV
)
1504 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1505 else if (XMARKER (w
->start
)->charpos
> ZV
)
1506 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1508 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1510 itdata
= bidi_shelve_cache ();
1511 start_display (&it
, w
, startp
);
1512 move_it_vertically (&it
, window_box_height (w
));
1513 if (it
.current_y
< it
.last_visible_y
)
1514 move_it_past_eol (&it
);
1515 value
= make_number (IT_CHARPOS (it
));
1516 bidi_unshelve_cache (itdata
, 0);
1519 set_buffer_internal (old_buffer
);
1522 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1527 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1528 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1529 WINDOW must be a live window and defaults to the selected one.
1531 (Lisp_Object window
, Lisp_Object pos
)
1533 register struct window
*w
= decode_live_window (window
);
1535 CHECK_NUMBER_COERCE_MARKER (pos
);
1537 if (w
== XWINDOW (selected_window
))
1539 if (XBUFFER (w
->buffer
) == current_buffer
)
1543 struct buffer
*old_buffer
= current_buffer
;
1545 set_buffer_internal (XBUFFER (w
->buffer
));
1547 set_buffer_internal (old_buffer
);
1552 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1553 /* We have to make sure that redisplay updates the window to show
1554 the new value of point. */
1555 ++windows_or_buffers_changed
;
1561 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1562 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1563 WINDOW must be a live window and defaults to the selected one. Return
1564 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1565 overriding motion of point in order to display at this exact start. */)
1566 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1568 register struct window
*w
= decode_live_window (window
);
1570 CHECK_NUMBER_COERCE_MARKER (pos
);
1571 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1572 /* this is not right, but much easier than doing what is right. */
1573 w
->start_at_line_beg
= 0;
1576 w
->update_mode_line
= 1;
1577 w
->last_modified
= 0;
1578 w
->last_overlay_modified
= 0;
1579 if (!EQ (window
, selected_window
))
1580 windows_or_buffers_changed
++;
1585 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1586 Spos_visible_in_window_p
, 0, 3, 0,
1587 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1588 WINDOW must be a live window and defaults to the selected one.
1590 Return nil if that position is scrolled vertically out of view. If a
1591 character is only partially visible, nil is returned, unless the
1592 optional argument PARTIALLY is non-nil. If POS is only out of view
1593 because of horizontal scrolling, return non-nil. If POS is t, it
1594 specifies the position of the last visible glyph in WINDOW. POS
1595 defaults to point in WINDOW; WINDOW defaults to the selected window.
1597 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1598 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1599 where X and Y are the pixel coordinates relative to the top left corner
1600 of the window. The remaining elements are omitted if the character after
1601 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1602 off-window at the top and bottom of the row, ROWH is the height of the
1603 display row, and VPOS is the row number (0-based) containing POS. */)
1604 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1606 register struct window
*w
;
1607 register EMACS_INT posint
;
1608 register struct buffer
*buf
;
1609 struct text_pos top
;
1610 Lisp_Object in_window
= Qnil
;
1611 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1614 w
= decode_live_window (window
);
1615 buf
= XBUFFER (w
->buffer
);
1616 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1620 else if (!NILP (pos
))
1622 CHECK_NUMBER_COERCE_MARKER (pos
);
1623 posint
= XINT (pos
);
1625 else if (w
== XWINDOW (selected_window
))
1628 posint
= XMARKER (w
->pointm
)->charpos
;
1630 /* If position is above window start or outside buffer boundaries,
1631 or if window start is out of range, position is not visible. */
1633 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1634 && CHARPOS (top
) >= BUF_BEGV (buf
)
1635 && CHARPOS (top
) <= BUF_ZV (buf
)
1636 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1637 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1640 if (!NILP (in_window
) && !NILP (partially
))
1642 Lisp_Object part
= Qnil
;
1644 part
= list4 (make_number (rtop
), make_number (rbot
),
1645 make_number (rowh
), make_number (vpos
));
1646 in_window
= Fcons (make_number (x
),
1647 Fcons (make_number (y
), part
));
1653 DEFUN ("window-line-height", Fwindow_line_height
,
1654 Swindow_line_height
, 0, 2, 0,
1655 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1656 WINDOW must be a live window and defaults to the selected one.
1658 Return height of current line if LINE is omitted or nil. Return height of
1659 header or mode line if LINE is `header-line' or `mode-line'.
1660 Otherwise, LINE is a text line number starting from 0. A negative number
1661 counts from the end of the window.
1663 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1664 in pixels of the visible part of the line, VPOS and YPOS are the
1665 vertical position in lines and pixels of the line, relative to the top
1666 of the first text line, and OFFBOT is the number of off-window pixels at
1667 the bottom of the text line. If there are off-window pixels at the top
1668 of the (first) text line, YPOS is negative.
1670 Return nil if window display is not up-to-date. In that case, use
1671 `pos-visible-in-window-p' to obtain the information. */)
1672 (Lisp_Object line
, Lisp_Object window
)
1674 register struct window
*w
;
1675 register struct buffer
*b
;
1676 struct glyph_row
*row
, *end_row
;
1680 w
= decode_live_window (window
);
1682 if (noninteractive
|| w
->pseudo_window_p
)
1685 CHECK_BUFFER (w
->buffer
);
1686 b
= XBUFFER (w
->buffer
);
1688 /* Fail if current matrix is not up-to-date. */
1689 if (NILP (w
->window_end_valid
)
1690 || current_buffer
->clip_changed
1691 || current_buffer
->prevent_redisplay_optimizations_p
1692 || w
->last_modified
< BUF_MODIFF (b
)
1693 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1699 if (i
< 0 || i
>= w
->current_matrix
->nrows
1700 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1702 max_y
= window_text_bottom_y (w
);
1706 if (EQ (line
, Qheader_line
))
1708 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1710 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1711 if (!row
->enabled_p
)
1713 return list4 (make_number (row
->height
),
1714 make_number (0), make_number (0),
1718 if (EQ (line
, Qmode_line
))
1720 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1721 if (!row
->enabled_p
)
1723 return list4 (make_number (row
->height
),
1724 make_number (0), /* not accurate */
1725 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
1726 + window_text_bottom_y (w
)),
1730 CHECK_NUMBER (line
);
1733 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1734 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1735 max_y
= window_text_bottom_y (w
);
1738 while ((n
< 0 || i
< n
)
1739 && row
<= end_row
&& row
->enabled_p
1740 && row
->y
+ row
->height
< max_y
)
1743 if (row
> end_row
|| !row
->enabled_p
)
1755 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1756 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
1758 make_number (row
->y
),
1759 make_number (crop
));
1762 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1764 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1765 More precisely, return the value assigned by the last call of
1766 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1767 never called with WINDOW as its argument, or the value set by that
1768 function was internally reset since its last call. WINDOW must be a
1769 live window and defaults to the selected one.
1771 When a window is dedicated to its buffer, `display-buffer' will refrain
1772 from displaying another buffer in it. `get-lru-window' and
1773 `get-largest-window' treat dedicated windows specially.
1774 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1775 `kill-buffer' can delete a dedicated window and the containing frame.
1777 Functions like `set-window-buffer' may change the buffer displayed by a
1778 window, unless that window is "strongly" dedicated to its buffer, that
1779 is the value returned by `window-dedicated-p' is t. */)
1780 (Lisp_Object window
)
1782 return decode_live_window (window
)->dedicated
;
1785 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1786 Sset_window_dedicated_p
, 2, 2, 0,
1787 doc
: /* Mark WINDOW as dedicated according to FLAG.
1788 WINDOW must be a live window and defaults to the selected one. FLAG
1789 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1790 mark WINDOW as non-dedicated. Return FLAG.
1792 When a window is dedicated to its buffer, `display-buffer' will refrain
1793 from displaying another buffer in it. `get-lru-window' and
1794 `get-largest-window' treat dedicated windows specially.
1795 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1796 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1797 and the containing frame.
1799 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1800 its buffer. Functions like `set-window-buffer' may change the buffer
1801 displayed by a window, unless that window is strongly dedicated to its
1802 buffer. If and when `set-window-buffer' displays another buffer in a
1803 window, it also makes sure that the window is no more dedicated. */)
1804 (Lisp_Object window
, Lisp_Object flag
)
1806 wset_dedicated (decode_live_window (window
), flag
);
1810 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1812 doc
: /* Return buffers previously shown in WINDOW.
1813 WINDOW must be a live window and defaults to the selected one.
1815 The return value is a list of elements (BUFFER WINDOW-START POS),
1816 where BUFFER is a buffer, WINDOW-START is the start position of the
1817 window for that buffer, and POS is a window-specific point value. */)
1818 (Lisp_Object window
)
1820 return decode_live_window (window
)->prev_buffers
;
1823 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1824 Sset_window_prev_buffers
, 2, 2, 0,
1825 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1826 WINDOW must be a live window and defaults to the selected one.
1828 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1829 where BUFFER is a buffer, WINDOW-START is the start position of the
1830 window for that buffer, and POS is a window-specific point value. */)
1831 (Lisp_Object window
, Lisp_Object prev_buffers
)
1833 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1834 return prev_buffers
;
1837 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1839 doc
: /* Return list of buffers recently re-shown in WINDOW.
1840 WINDOW must be a live window and defaults to the selected one. */)
1841 (Lisp_Object window
)
1843 return decode_live_window (window
)->next_buffers
;
1846 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1847 Sset_window_next_buffers
, 2, 2, 0,
1848 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1849 WINDOW must be a live window and defaults to the selected one.
1850 NEXT-BUFFERS should be a list of buffers. */)
1851 (Lisp_Object window
, Lisp_Object next_buffers
)
1853 wset_next_buffers (decode_live_window (window
), next_buffers
);
1854 return next_buffers
;
1857 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1859 doc
: /* Return the parameters of WINDOW and their values.
1860 WINDOW must be a valid window and defaults to the selected one. The
1861 return value is a list of elements of the form (PARAMETER . VALUE). */)
1862 (Lisp_Object window
)
1864 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1867 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1869 doc
: /* Return WINDOW's value for PARAMETER.
1870 WINDOW must be a valid window and defaults to the selected one. */)
1871 (Lisp_Object window
, Lisp_Object parameter
)
1875 result
= Fassq (parameter
, decode_valid_window (window
)->window_parameters
);
1876 return CDR_SAFE (result
);
1879 DEFUN ("set-window-parameter", Fset_window_parameter
,
1880 Sset_window_parameter
, 3, 3, 0,
1881 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1882 WINDOW must be a valid window and defaults to the selected one.
1884 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1886 register struct window
*w
= decode_valid_window (window
);
1887 Lisp_Object old_alist_elt
;
1889 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1890 if (NILP (old_alist_elt
))
1891 wset_window_parameters
1892 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1894 Fsetcdr (old_alist_elt
, value
);
1898 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1900 doc
: /* Return the display-table that WINDOW is using.
1901 WINDOW must be a live window and defaults to the selected one. */)
1902 (Lisp_Object window
)
1904 return decode_live_window (window
)->display_table
;
1907 /* Get the display table for use on window W. This is either W's
1908 display table or W's buffer's display table. Ignore the specified
1909 tables if they are not valid; if no valid table is specified,
1912 struct Lisp_Char_Table
*
1913 window_display_table (struct window
*w
)
1915 struct Lisp_Char_Table
*dp
= NULL
;
1917 if (DISP_TABLE_P (w
->display_table
))
1918 dp
= XCHAR_TABLE (w
->display_table
);
1919 else if (BUFFERP (w
->buffer
))
1921 struct buffer
*b
= XBUFFER (w
->buffer
);
1923 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1924 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1925 else if (DISP_TABLE_P (Vstandard_display_table
))
1926 dp
= XCHAR_TABLE (Vstandard_display_table
);
1932 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1933 doc
: /* Set WINDOW's display-table to TABLE.
1934 WINDOW must be a live window and defaults to the selected one. */)
1935 (register Lisp_Object window
, Lisp_Object table
)
1937 wset_display_table (decode_live_window (window
), table
);
1941 /* Record info on buffer window W is displaying
1942 when it is about to cease to display that buffer. */
1944 unshow_buffer (register struct window
*w
)
1951 if (b
!= XMARKER (w
->pointm
)->buffer
)
1955 if (w
== XWINDOW (selected_window
)
1956 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1957 /* Do this except when the selected window's buffer
1958 is being removed from some other window. */
1960 /* last_window_start records the start position that this buffer
1961 had in the last window to be disconnected from it.
1962 Now that this statement is unconditional,
1963 it is possible for the buffer to be displayed in the
1964 selected window, while last_window_start reflects another
1965 window which was recently showing the same buffer.
1966 Some people might say that might be a good thing. Let's see. */
1967 b
->last_window_start
= marker_position (w
->start
);
1969 /* Point in the selected window's buffer
1970 is actually stored in that buffer, and the window's pointm isn't used.
1971 So don't clobber point in that buffer. */
1972 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1973 /* Don't clobber point in current buffer either (this could be
1974 useful in connection with bug#12208).
1975 && XBUFFER (buf) != current_buffer */
1976 /* This line helps to fix Horsley's testbug.el bug. */
1977 && !(WINDOWP (BVAR (b
, last_selected_window
))
1978 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1979 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1980 temp_set_point_both (b
,
1981 clip_to_bounds (BUF_BEGV (b
),
1982 XMARKER (w
->pointm
)->charpos
,
1984 clip_to_bounds (BUF_BEGV_BYTE (b
),
1985 marker_byte_position (w
->pointm
),
1988 if (WINDOWP (BVAR (b
, last_selected_window
))
1989 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1990 bset_last_selected_window (b
, Qnil
);
1993 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1994 means change window structure only. Otherwise store geometry and
1995 other settings as well. */
1997 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1999 register Lisp_Object tem
;
2000 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
2002 /* If OLD is its frame's root window, then NEW is the new
2003 root window for that frame. */
2004 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
2005 fset_root_window (XFRAME (o
->frame
), new);
2009 wset_left_col (n
, o
->left_col
);
2010 wset_top_line (n
, o
->top_line
);
2011 wset_total_cols (n
, o
->total_cols
);
2012 wset_total_lines (n
, o
->total_lines
);
2013 wset_normal_cols (n
, o
->normal_cols
);
2014 wset_normal_cols (o
, make_float (1.0));
2015 wset_normal_lines (n
, o
->normal_lines
);
2016 wset_normal_lines (o
, make_float (1.0));
2017 n
->desired_matrix
= n
->current_matrix
= 0;
2019 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
2020 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
2021 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
2022 n
->phys_cursor_type
= -1;
2023 n
->phys_cursor_width
= -1;
2024 n
->must_be_updated_p
= 0;
2025 n
->pseudo_window_p
= 0;
2026 wset_window_end_vpos (n
, make_number (0));
2027 wset_window_end_pos (n
, make_number (0));
2028 wset_window_end_valid (n
, Qnil
);
2029 n
->frozen_window_start_p
= 0;
2035 wset_prev (XWINDOW (tem
), new);
2040 wset_next (XWINDOW (tem
), new);
2043 wset_parent (n
, tem
);
2046 if (EQ (XWINDOW (tem
)->vchild
, old
))
2047 wset_vchild (XWINDOW (tem
), new);
2048 if (EQ (XWINDOW (tem
)->hchild
, old
))
2049 wset_hchild (XWINDOW (tem
), new);
2053 /* If window WINDOW and its parent window are iso-combined, merge
2054 WINDOW's children into those of its parent window and mark WINDOW as
2058 recombine_windows (Lisp_Object window
)
2060 struct window
*w
, *p
, *c
;
2061 Lisp_Object parent
, child
;
2064 w
= XWINDOW (window
);
2066 if (!NILP (parent
) && NILP (w
->combination_limit
))
2068 p
= XWINDOW (parent
);
2069 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2070 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2071 /* WINDOW and PARENT are both either a vertical or a horizontal
2074 horflag
= NILP (w
->vchild
);
2075 child
= horflag
? w
->hchild
: w
->vchild
;
2076 c
= XWINDOW (child
);
2078 /* Splice WINDOW's children into its parent's children and
2079 assign new normal sizes. */
2082 wset_hchild (p
, child
);
2084 wset_vchild (p
, child
);
2087 wset_prev (c
, w
->prev
);
2088 wset_next (XWINDOW (w
->prev
), child
);
2093 wset_parent (c
, parent
);
2096 wset_normal_cols (c
,
2097 make_float (XFLOATINT (c
->total_cols
)
2098 / XFLOATINT (p
->total_cols
)));
2100 wset_normal_lines (c
,
2101 make_float (XFLOATINT (c
->total_lines
)
2102 / XFLOATINT (p
->total_lines
)));
2106 if (!NILP (w
->next
))
2108 wset_next (c
, w
->next
);
2109 wset_prev (XWINDOW (c
->next
), child
);
2117 c
= XWINDOW (child
);
2121 /* WINDOW can be deleted now. */
2122 wset_vchild (w
, Qnil
);
2123 wset_hchild (w
, Qnil
);
2128 /* If WINDOW can be deleted, delete it. */
2130 delete_deletable_window (Lisp_Object window
)
2132 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2133 call1 (Qdelete_window
, window
);
2136 /***********************************************************************
2138 ***********************************************************************/
2140 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2141 pointer. This is a callback function for foreach_window, used in
2142 the window_list function. */
2145 add_window_to_list (struct window
*w
, void *user_data
)
2147 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2149 XSETWINDOW (window
, w
);
2150 *list
= Fcons (window
, *list
);
2155 /* Return a list of all windows, for use by next_window. If
2156 Vwindow_list is a list, return that list. Otherwise, build a new
2157 list, cache it in Vwindow_list, and return that. */
2162 if (!CONSP (Vwindow_list
))
2166 Vwindow_list
= Qnil
;
2167 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
2169 Lisp_Object args
[2];
2171 /* We are visiting windows in canonical order, and add
2172 new windows at the front of args[1], which means we
2173 have to reverse this list at the end. */
2175 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
2176 args
[0] = Vwindow_list
;
2177 args
[1] = Fnreverse (args
[1]);
2178 Vwindow_list
= Fnconc (2, args
);
2182 return Vwindow_list
;
2186 /* Value is non-zero if WINDOW satisfies the constraints given by
2187 OWINDOW, MINIBUF and ALL_FRAMES.
2189 MINIBUF t means WINDOW may be minibuffer windows.
2190 `lambda' means WINDOW may not be a minibuffer window.
2191 a window means a specific minibuffer window
2193 ALL_FRAMES t means search all frames,
2194 nil means search just current frame,
2195 `visible' means search just visible frames on the
2197 0 means search visible and iconified frames on the
2199 a window means search the frame that window belongs to,
2200 a frame means consider windows on that frame, only. */
2203 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2205 struct window
*w
= XWINDOW (window
);
2206 struct frame
*f
= XFRAME (w
->frame
);
2207 int candidate_p
= 1;
2209 if (!BUFFERP (w
->buffer
))
2211 else if (MINI_WINDOW_P (w
)
2212 && (EQ (minibuf
, Qlambda
)
2213 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2215 /* If MINIBUF is `lambda' don't consider any mini-windows.
2216 If it is a window, consider only that one. */
2219 else if (EQ (all_frames
, Qt
))
2221 else if (NILP (all_frames
))
2223 eassert (WINDOWP (owindow
));
2224 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2226 else if (EQ (all_frames
, Qvisible
))
2228 FRAME_SAMPLE_VISIBILITY (f
);
2229 candidate_p
= FRAME_VISIBLE_P (f
)
2230 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2231 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2234 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2236 FRAME_SAMPLE_VISIBILITY (f
);
2237 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2238 #ifdef HAVE_X_WINDOWS
2239 /* Yuck!! If we've just created the frame and the
2240 window-manager requested the user to place it
2241 manually, the window may still not be considered
2242 `visible'. I'd argue it should be at least
2243 something like `iconified', but don't know how to do
2245 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2246 && !f
->output_data
.x
->has_been_visible
)
2249 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2250 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2252 else if (WINDOWP (all_frames
))
2253 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2254 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2255 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2256 else if (FRAMEP (all_frames
))
2257 candidate_p
= EQ (all_frames
, w
->frame
);
2263 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2264 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2265 MINIBUF, and ALL_FRAMES. */
2268 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2271 *window
= selected_window
;
2273 CHECK_LIVE_WINDOW (*window
);
2275 /* MINIBUF nil may or may not include minibuffers. Decide if it
2277 if (NILP (*minibuf
))
2278 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2279 else if (!EQ (*minibuf
, Qt
))
2282 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2283 => count none of them, or a specific minibuffer window (the
2284 active one) to count. */
2286 /* ALL_FRAMES nil doesn't specify which frames to include. */
2287 if (NILP (*all_frames
))
2289 = (!EQ (*minibuf
, Qlambda
)
2290 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
2292 else if (EQ (*all_frames
, Qvisible
))
2294 else if (EQ (*all_frames
, make_number (0)))
2296 else if (FRAMEP (*all_frames
))
2298 else if (!EQ (*all_frames
, Qt
))
2303 /* Return the next or previous window of WINDOW in cyclic ordering
2304 of windows. NEXT_P non-zero means return the next window. See the
2305 documentation string of next-window for the meaning of MINIBUF and
2309 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2311 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2313 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2314 return the first window on the frame. */
2315 if (FRAMEP (all_frames
)
2316 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2317 return Fframe_first_window (all_frames
);
2323 /* Find WINDOW in the list of all windows. */
2324 list
= Fmemq (window
, window_list ());
2326 /* Scan forward from WINDOW to the end of the window list. */
2328 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2329 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2332 /* Scan from the start of the window list up to WINDOW. */
2334 for (list
= Vwindow_list
;
2335 CONSP (list
) && !EQ (XCAR (list
), window
);
2337 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2341 window
= XCAR (list
);
2345 Lisp_Object candidate
, list
;
2347 /* Scan through the list of windows for candidates. If there are
2348 candidate windows in front of WINDOW, the last one of these
2349 is the one we want. If there are candidates following WINDOW
2350 in the list, again the last one of these is the one we want. */
2352 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2354 if (EQ (XCAR (list
), window
))
2356 if (WINDOWP (candidate
))
2359 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2361 candidate
= XCAR (list
);
2364 if (WINDOWP (candidate
))
2372 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2373 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2374 WINDOW must be a live window and defaults to the selected one. The
2375 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2378 MINIBUF nil or omitted means consider the minibuffer window only if the
2379 minibuffer is active. MINIBUF t means consider the minibuffer window
2380 even if the minibuffer is not active. Any other value means do not
2381 consider the minibuffer window even if the minibuffer is active.
2383 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2384 plus the minibuffer window if specified by the MINIBUF argument. If the
2385 minibuffer counts, consider all windows on all frames that share that
2386 minibuffer too. The following non-nil values of ALL-FRAMES have special
2389 - t means consider all windows on all existing frames.
2391 - `visible' means consider all windows on all visible frames.
2393 - 0 (the number zero) means consider all windows on all visible and
2396 - A frame means consider all windows on that frame only.
2398 Anything else means consider all windows on WINDOW's frame and no
2401 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2402 `next-window' to iterate through the entire cycle of acceptable
2403 windows, eventually ending up back at the window you started with.
2404 `previous-window' traverses the same cycle, in the reverse order. */)
2405 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2407 return next_window (window
, minibuf
, all_frames
, 1);
2411 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2412 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2413 WINDOW must be a live window and defaults to the selected one. The
2414 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2417 MINIBUF nil or omitted means consider the minibuffer window only if the
2418 minibuffer is active. MINIBUF t means consider the minibuffer window
2419 even if the minibuffer is not active. Any other value means do not
2420 consider the minibuffer window even if the minibuffer is active.
2422 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2423 plus the minibuffer window if specified by the MINIBUF argument. If the
2424 minibuffer counts, consider all windows on all frames that share that
2425 minibuffer too. The following non-nil values of ALL-FRAMES have special
2428 - t means consider all windows on all existing frames.
2430 - `visible' means consider all windows on all visible frames.
2432 - 0 (the number zero) means consider all windows on all visible and
2435 - A frame means consider all windows on that frame only.
2437 Anything else means consider all windows on WINDOW's frame and no
2440 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2441 use `previous-window' to iterate through the entire cycle of
2442 acceptable windows, eventually ending up back at the window you
2443 started with. `next-window' traverses the same cycle, in the
2445 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2447 return next_window (window
, minibuf
, all_frames
, 0);
2451 /* Return a list of windows in cyclic ordering. Arguments are like
2452 for `next-window'. */
2455 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2457 Lisp_Object tail
, list
, rest
;
2459 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2462 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2463 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2464 list
= Fcons (XCAR (tail
), list
);
2466 /* Rotate the list to start with WINDOW. */
2467 list
= Fnreverse (list
);
2468 rest
= Fmemq (window
, list
);
2469 if (!NILP (rest
) && !EQ (rest
, list
))
2471 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2473 XSETCDR (tail
, Qnil
);
2474 list
= nconc2 (rest
, list
);
2480 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2481 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2482 FRAME nil or omitted means use the selected frame.
2483 WINDOW nil or omitted means use the window selected within FRAME.
2484 MINIBUF t means include the minibuffer window, even if it isn't active.
2485 MINIBUF nil or omitted means include the minibuffer window only
2487 MINIBUF neither nil nor t means never include the minibuffer window. */)
2488 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2491 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2492 CHECK_WINDOW (window
);
2494 frame
= selected_frame
;
2496 if (!EQ (frame
, XWINDOW (window
)->frame
))
2497 error ("Window is on a different frame");
2499 return window_list_1 (window
, minibuf
, frame
);
2503 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2504 doc
: /* Return a list of all live windows.
2505 WINDOW specifies the first window to list and defaults to the selected
2508 Optional argument MINIBUF nil or omitted means consider the minibuffer
2509 window only if the minibuffer is active. MINIBUF t means consider the
2510 minibuffer window even if the minibuffer is not active. Any other value
2511 means do not consider the minibuffer window even if the minibuffer is
2514 Optional argument ALL-FRAMES nil or omitted means consider all windows
2515 on WINDOW's frame, plus the minibuffer window if specified by the
2516 MINIBUF argument. If the minibuffer counts, consider all windows on all
2517 frames that share that minibuffer too. The following non-nil values of
2518 ALL-FRAMES have special meanings:
2520 - t means consider all windows on all existing frames.
2522 - `visible' means consider all windows on all visible frames.
2524 - 0 (the number zero) means consider all windows on all visible and
2527 - A frame means consider all windows on that frame only.
2529 Anything else means consider all windows on WINDOW's frame and no
2532 If WINDOW is not on the list of windows returned, some other window will
2533 be listed first but no error is signaled. */)
2534 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2536 return window_list_1 (window
, minibuf
, all_frames
);
2539 /* Look at all windows, performing an operation specified by TYPE
2541 If FRAMES is Qt, look at all frames;
2542 Qnil, look at just the selected frame;
2543 Qvisible, look at visible frames;
2544 a frame, just look at windows on that frame.
2545 If MINI is non-zero, perform the operation on minibuffer windows too. */
2550 GET_BUFFER_WINDOW
, /* Arg is buffer */
2551 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2552 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2557 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2559 Lisp_Object window
, windows
, best_window
, frame_arg
;
2560 int frame_best_window_flag
= 0;
2562 struct gcpro gcpro1
;
2564 /* If we're only looping through windows on a particular frame,
2565 frame points to that frame. If we're looping through windows
2566 on all frames, frame is 0. */
2567 if (FRAMEP (frames
))
2568 f
= XFRAME (frames
);
2569 else if (NILP (frames
))
2570 f
= SELECTED_FRAME ();
2575 frame_arg
= Qlambda
;
2576 else if (EQ (frames
, make_number (0)))
2578 else if (EQ (frames
, Qvisible
))
2583 /* frame_arg is Qlambda to stick to one frame,
2584 Qvisible to consider all visible frames,
2587 /* Pick a window to start with. */
2591 window
= FRAME_SELECTED_WINDOW (f
);
2593 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2595 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2599 for (; CONSP (windows
); windows
= XCDR (windows
))
2603 window
= XCAR (windows
);
2604 w
= XWINDOW (window
);
2606 /* Note that we do not pay attention here to whether the frame
2607 is visible, since Fwindow_list skips non-visible frames if
2608 that is desired, under the control of frame_arg. */
2609 if (!MINI_WINDOW_P (w
)
2610 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2611 consider all windows. */
2612 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2613 || (mini
&& minibuf_level
> 0))
2616 case GET_BUFFER_WINDOW
:
2617 if (EQ (w
->buffer
, obj
)
2618 /* Don't find any minibuffer window except the one that
2619 is currently in use. */
2620 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2622 if (EQ (window
, selected_window
))
2623 /* Preferably return the selected window. */
2624 RETURN_UNGCPRO (window
);
2625 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2626 && !frame_best_window_flag
)
2627 /* Prefer windows on the current frame (but don't
2628 choose another one if we have one already). */
2630 best_window
= window
;
2631 frame_best_window_flag
= 1;
2633 else if (NILP (best_window
))
2634 best_window
= window
;
2638 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2639 /* We could simply check whether the buffer shown by window
2640 is live, and show another buffer in case it isn't. */
2641 if (EQ (w
->buffer
, obj
))
2643 /* Undedicate WINDOW. */
2644 wset_dedicated (w
, Qnil
);
2645 /* Make WINDOW show the buffer returned by
2646 other_buffer_safely, don't run any hooks. */
2648 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2649 /* If WINDOW is the selected window, make its buffer
2650 current. But do so only if the window shows the
2651 current buffer (Bug#6454). */
2652 if (EQ (window
, selected_window
)
2653 && XBUFFER (w
->buffer
) == current_buffer
)
2654 Fset_buffer (w
->buffer
);
2658 case REDISPLAY_BUFFER_WINDOWS
:
2659 if (EQ (w
->buffer
, obj
))
2661 mark_window_display_accurate (window
, 0);
2662 w
->update_mode_line
= 1;
2663 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2664 ++update_mode_lines
;
2665 best_window
= window
;
2669 /* Check for a window that has a killed buffer. */
2670 case CHECK_ALL_WINDOWS
:
2671 if (! NILP (w
->buffer
)
2672 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2676 case WINDOW_LOOP_UNUSED
:
2685 /* Used for debugging. Abort if any window has a dead buffer. */
2687 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2689 check_all_windows (void)
2691 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2694 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2695 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2696 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2699 The optional argument ALL-FRAMES specifies the frames to consider:
2701 - t means consider all windows on all existing frames.
2703 - `visible' means consider all windows on all visible frames.
2705 - 0 (the number zero) means consider all windows on all visible
2706 and iconified frames.
2708 - A frame means consider all windows on that frame only.
2710 Any other value of ALL-FRAMES means consider all windows on the
2711 selected frame and no others. */)
2712 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2716 if (NILP (buffer_or_name
))
2717 buffer
= Fcurrent_buffer ();
2719 buffer
= Fget_buffer (buffer_or_name
);
2721 if (BUFFERP (buffer
))
2722 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2728 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2730 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2734 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2735 Sdelete_other_windows_internal
, 0, 2, "",
2736 doc
: /* Make WINDOW fill its frame.
2737 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2738 and defaults to the selected one.
2740 Optional argument ROOT, if non-nil, must specify an internal window such
2741 that WINDOW is in its window subtree. If this is the case, replace ROOT
2742 by WINDOW and leave alone any windows not part of ROOT's subtree.
2744 When WINDOW is live try to reduce display jumps by keeping the text
2745 previously visible in WINDOW in the same place on the frame. Doing this
2746 depends on the value of (window-start WINDOW), so if calling this
2747 function in a program gives strange scrolling, make sure the
2748 window-start value is reasonable when this function is called. */)
2749 (Lisp_Object window
, Lisp_Object root
)
2751 struct window
*w
, *r
, *s
;
2753 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2754 ptrdiff_t startpos
IF_LINT (= 0);
2755 int top
IF_LINT (= 0), new_top
, resize_failed
;
2757 w
= decode_valid_window (window
);
2758 XSETWINDOW (window
, w
);
2759 f
= XFRAME (w
->frame
);
2762 /* ROOT is the frame's root window. */
2764 root
= FRAME_ROOT_WINDOW (f
);
2768 /* ROOT must be an ancestor of WINDOW. */
2770 r
= decode_valid_window (root
);
2771 pwindow
= XWINDOW (window
)->parent
;
2772 while (!NILP (pwindow
))
2773 if (EQ (pwindow
, root
))
2776 pwindow
= XWINDOW (pwindow
)->parent
;
2777 if (!EQ (pwindow
, root
))
2778 error ("Specified root is not an ancestor of specified window");
2781 if (EQ (window
, root
))
2784 /* I don't understand the "top > 0" part below. If we deal with a
2785 standalone minibuffer it would have been caught by the preceding
2787 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2788 error ("Can't expand minibuffer to full frame");
2790 if (!NILP (w
->buffer
))
2792 startpos
= marker_position (w
->start
);
2793 top
= WINDOW_TOP_EDGE_LINE (w
)
2794 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2795 /* Make sure WINDOW is the frame's selected window. */
2796 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2798 if (EQ (selected_frame
, w
->frame
))
2799 Fselect_window (window
, Qnil
);
2801 fset_selected_window (f
, window
);
2806 /* See if the frame's selected window is a part of the window
2807 subtree rooted at WINDOW, by finding all the selected window's
2808 parents and comparing each one with WINDOW. If it isn't we
2809 need a new selected window for this frame. */
2810 swindow
= FRAME_SELECTED_WINDOW (f
);
2814 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2815 pwindow
= XWINDOW (pwindow
)->parent
;
2817 if (EQ (window
, pwindow
))
2818 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2819 as the new selected window. */
2822 /* Else try the previous window of SWINDOW. */
2823 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2826 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2828 if (EQ (selected_frame
, w
->frame
))
2829 Fselect_window (swindow
, Qnil
);
2831 fset_selected_window (f
, swindow
);
2836 if (!FRAME_INITIAL_P (f
))
2838 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2840 /* We are going to free the glyph matrices of WINDOW, and with
2841 that we might lose any information about glyph rows that have
2842 some of their glyphs highlighted in mouse face. (These rows
2843 are marked with a non-zero mouse_face_p flag.) If WINDOW
2844 indeed has some glyphs highlighted in mouse face, signal to
2845 frame's up-to-date hook that mouse highlight was overwritten,
2846 so that it will arrange for redisplaying the highlight. */
2847 if (EQ (hlinfo
->mouse_face_window
, window
))
2849 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2850 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2851 hlinfo
->mouse_face_window
= Qnil
;
2854 free_window_matrices (r
);
2856 windows_or_buffers_changed
++;
2857 Vwindow_list
= Qnil
;
2858 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2861 if (NILP (w
->buffer
))
2863 /* Resize child windows vertically. */
2864 XSETINT (delta
, XINT (r
->total_lines
)
2865 - XINT (w
->total_lines
));
2866 wset_top_line (w
, r
->top_line
);
2867 resize_root_window (window
, delta
, Qnil
, Qnil
);
2868 if (window_resize_check (w
, 0))
2869 window_resize_apply (w
, 0);
2872 resize_root_window (window
, delta
, Qnil
, Qt
);
2873 if (window_resize_check (w
, 0))
2874 window_resize_apply (w
, 0);
2879 /* Resize child windows horizontally. */
2882 wset_left_col (w
, r
->left_col
);
2884 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2885 wset_left_col (w
, r
->left_col
);
2886 resize_root_window (window
, delta
, Qt
, Qnil
);
2887 if (window_resize_check (w
, 1))
2888 window_resize_apply (w
, 1);
2891 resize_root_window (window
, delta
, Qt
, Qt
);
2892 if (window_resize_check (w
, 1))
2893 window_resize_apply (w
, 1);
2900 /* Play safe, if we still can ... */
2903 w
= XWINDOW (window
);
2907 /* Cleanly unlink WINDOW from window-tree. */
2908 if (!NILP (w
->prev
))
2909 /* Get SIBLING above (on the left of) WINDOW. */
2912 s
= XWINDOW (sibling
);
2913 wset_next (s
, w
->next
);
2914 if (!NILP (s
->next
))
2915 wset_prev (XWINDOW (s
->next
), sibling
);
2918 /* Get SIBLING below (on the right of) WINDOW. */
2921 s
= XWINDOW (sibling
);
2922 wset_prev (s
, Qnil
);
2923 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2924 wset_vchild (XWINDOW (w
->parent
), sibling
);
2926 wset_hchild (XWINDOW (w
->parent
), sibling
);
2929 /* Delete ROOT and all child windows of ROOT. */
2930 if (!NILP (r
->vchild
))
2932 delete_all_child_windows (r
->vchild
);
2933 wset_vchild (r
, Qnil
);
2935 else if (!NILP (r
->hchild
))
2937 delete_all_child_windows (r
->hchild
);
2938 wset_hchild (r
, Qnil
);
2941 replace_window (root
, window
, 1);
2943 /* This must become SWINDOW anyway ....... */
2944 if (!NILP (w
->buffer
) && !resize_failed
)
2946 /* Try to minimize scrolling, by setting the window start to the
2947 point will cause the text at the old window start to be at the
2948 same place on the frame. But don't try to do this if the
2949 window start is outside the visible portion (as might happen
2950 when the display is not current, due to typeahead). */
2951 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2953 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2954 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2956 struct position pos
;
2957 struct buffer
*obuf
= current_buffer
;
2959 Fset_buffer (w
->buffer
);
2960 /* This computation used to temporarily move point, but that
2961 can have unwanted side effects due to text properties. */
2962 pos
= *vmotion (startpos
, -top
, w
);
2964 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2965 wset_window_end_valid (w
, Qnil
);
2966 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2967 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2968 /* We need to do this, so that the window-scroll-functions
2970 w
->optional_new_start
= 1;
2972 set_buffer_internal (obuf
);
2979 run_window_configuration_change_hook (f
);
2986 replace_buffer_in_windows (Lisp_Object buffer
)
2988 call1 (Qreplace_buffer_in_windows
, buffer
);
2992 /* Safely replace BUFFER with some other buffer in all windows of all
2993 frames, even those on other keyboards. */
2996 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2998 Lisp_Object tail
, frame
;
3000 /* A single call to window_loop won't do the job because it only
3001 considers frames on the current keyboard. So loop manually over
3002 frames, and handle each one. */
3003 FOR_EACH_FRAME (tail
, frame
)
3004 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
3007 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
3008 minimum allowable size. */
3011 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
3013 /* For height, we have to see:
3014 how many windows the frame has at minimum (one or two),
3015 and whether it has a menu bar or other special stuff at the top. */
3017 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
3018 ? MIN_SAFE_WINDOW_HEIGHT
3019 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
3021 if (FRAME_TOP_MARGIN (frame
) > 0)
3022 min_height
+= FRAME_TOP_MARGIN (frame
);
3024 if (*rows
< min_height
)
3026 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
3027 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3030 /* Adjust the margins of window W if text area is too small.
3031 Return 1 if window width is ok after adjustment; 0 if window
3032 is still too narrow. */
3035 adjust_window_margins (struct window
*w
)
3037 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3038 - WINDOW_FRINGE_COLS (w
)
3039 - WINDOW_SCROLL_BAR_COLS (w
));
3040 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3041 + WINDOW_RIGHT_MARGIN_COLS (w
));
3043 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3046 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3049 /* Window's text area is too narrow, but reducing the window
3050 margins will fix that. */
3051 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3052 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3054 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3056 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3057 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3060 wset_right_margin_cols (w
, make_number (margin_cols
));
3063 wset_left_margin_cols (w
, make_number (margin_cols
));
3067 /* The following three routines are needed for running a window's
3068 configuration change hook. */
3070 run_funs (Lisp_Object funs
)
3072 for (; CONSP (funs
); funs
= XCDR (funs
))
3073 if (!EQ (XCAR (funs
), Qt
))
3074 call0 (XCAR (funs
));
3078 select_window_norecord (Lisp_Object window
)
3080 return WINDOW_LIVE_P (window
)
3081 ? Fselect_window (window
, Qt
) : selected_window
;
3085 select_frame_norecord (Lisp_Object frame
)
3087 return FRAME_LIVE_P (XFRAME (frame
))
3088 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3092 run_window_configuration_change_hook (struct frame
*f
)
3094 ptrdiff_t count
= SPECPDL_INDEX ();
3095 Lisp_Object frame
, global_wcch
3096 = Fdefault_value (Qwindow_configuration_change_hook
);
3097 XSETFRAME (frame
, f
);
3099 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3102 /* Use the right buffer. Matters when running the local hooks. */
3103 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3105 record_unwind_current_buffer ();
3106 Fset_buffer (Fwindow_buffer (Qnil
));
3109 if (SELECTED_FRAME () != f
)
3111 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3112 select_frame_norecord (frame
);
3115 /* Look for buffer-local values. */
3117 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3118 for (; CONSP (windows
); windows
= XCDR (windows
))
3120 Lisp_Object window
= XCAR (windows
);
3121 Lisp_Object buffer
= Fwindow_buffer (window
);
3122 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3125 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3126 record_unwind_protect (select_window_norecord
, Fselected_window ());
3127 select_window_norecord (window
);
3128 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3130 unbind_to (inner_count
, Qnil
);
3135 run_funs (global_wcch
);
3136 unbind_to (count
, Qnil
);
3139 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3140 Srun_window_configuration_change_hook
, 1, 1, 0,
3141 doc
: /* Run `window-configuration-change-hook' for FRAME. */)
3144 CHECK_LIVE_FRAME (frame
);
3145 run_window_configuration_change_hook (XFRAME (frame
));
3149 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3150 means it's allowed to run hooks. See make_frame for a case where
3151 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3152 margins, fringes, and scroll-bar settings of the window are not
3153 reset from the buffer's local settings. */
3156 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3158 struct window
*w
= XWINDOW (window
);
3159 struct buffer
*b
= XBUFFER (buffer
);
3160 ptrdiff_t count
= SPECPDL_INDEX ();
3161 int samebuf
= EQ (buffer
, w
->buffer
);
3163 wset_buffer (w
, buffer
);
3165 if (EQ (window
, selected_window
))
3166 bset_last_selected_window (b
, window
);
3168 /* Let redisplay errors through. */
3169 b
->display_error_modiff
= 0;
3171 /* Update time stamps of buffer display. */
3172 if (INTEGERP (BVAR (b
, display_count
)))
3173 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3174 bset_display_time (b
, Fcurrent_time ());
3176 wset_window_end_pos (w
, make_number (0));
3177 wset_window_end_vpos (w
, make_number (0));
3178 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3179 wset_window_end_valid (w
, Qnil
);
3180 if (!(keep_margins_p
&& samebuf
))
3181 { /* If we're not actually changing the buffer, don't reset hscroll and
3182 vscroll. This case happens for example when called from
3183 change_frame_size_1, where we use a dummy call to
3184 Fset_window_buffer on the frame's selected window (and no other)
3185 just in order to run window-configuration-change-hook.
3186 Resetting hscroll and vscroll here is problematic for things like
3187 image-mode and doc-view-mode since it resets the image's position
3188 whenever we resize the frame. */
3189 w
->hscroll
= w
->min_hscroll
= 0;
3191 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3192 set_marker_restricted (w
->start
,
3193 make_number (b
->last_window_start
),
3195 w
->start_at_line_beg
= 0;
3197 w
->last_modified
= 0;
3198 w
->last_overlay_modified
= 0;
3200 /* Maybe we could move this into the `if' but it's not obviously safe and
3201 I doubt it's worth the trouble. */
3202 windows_or_buffers_changed
++;
3204 /* We must select BUFFER for running the window-scroll-functions. */
3205 /* We can't check ! NILP (Vwindow_scroll_functions) here
3206 because that might itself be a local variable. */
3207 if (window_initialized
)
3209 record_unwind_current_buffer ();
3210 Fset_buffer (buffer
);
3213 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3215 if (!keep_margins_p
)
3217 /* Set left and right marginal area width etc. from buffer. */
3219 /* This may call adjust_window_margins three times, so
3220 temporarily disable window margins. */
3221 Lisp_Object save_left
= w
->left_margin_cols
;
3222 Lisp_Object save_right
= w
->right_margin_cols
;
3224 wset_left_margin_cols (w
, Qnil
);
3225 wset_right_margin_cols (w
, Qnil
);
3227 Fset_window_fringes (window
,
3228 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3229 BVAR (b
, fringes_outside_margins
));
3231 Fset_window_scroll_bars (window
,
3232 BVAR (b
, scroll_bar_width
),
3233 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3235 wset_left_margin_cols (w
, save_left
);
3236 wset_right_margin_cols (w
, save_right
);
3238 Fset_window_margins (window
,
3239 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3244 if (! NILP (Vwindow_scroll_functions
))
3245 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3246 Fmarker_position (w
->start
));
3247 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3250 unbind_to (count
, Qnil
);
3253 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3254 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3255 WINDOW must be a live window and defaults to the selected one.
3256 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3258 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3259 display margins, fringe widths, and scroll bar settings are preserved;
3260 the default is to reset these from the local settings for BUFFER-OR-NAME
3261 or the frame defaults. Return nil.
3263 This function throws an error when WINDOW is strongly dedicated to its
3264 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3265 already display BUFFER-OR-NAME.
3267 This function runs `window-scroll-functions' before running
3268 `window-configuration-change-hook'. */)
3269 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3271 register Lisp_Object tem
, buffer
;
3272 register struct window
*w
= decode_live_window (window
);
3274 XSETWINDOW (window
, w
);
3275 buffer
= Fget_buffer (buffer_or_name
);
3276 CHECK_BUFFER (buffer
);
3277 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3278 error ("Attempt to display deleted buffer");
3282 error ("Window is deleted");
3283 else if (!EQ (tem
, Qt
))
3284 /* w->buffer is t when the window is first being set up. */
3286 if (!EQ (tem
, buffer
))
3288 if (EQ (w
->dedicated
, Qt
))
3289 /* WINDOW is strongly dedicated to its buffer, signal an
3291 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3293 /* WINDOW is weakly dedicated to its buffer, reset
3295 wset_dedicated (w
, Qnil
);
3297 call1 (Qrecord_window_buffer
, window
);
3303 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3309 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3311 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3314 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3316 doc
: /* Force all windows to be updated on next redisplay.
3317 If optional arg OBJECT is a window, force redisplay of that window only.
3318 If OBJECT is a buffer or buffer name, force redisplay of all windows
3319 displaying that buffer. */)
3320 (Lisp_Object object
)
3324 windows_or_buffers_changed
++;
3325 update_mode_lines
++;
3329 if (WINDOWP (object
))
3331 struct window
*w
= XWINDOW (object
);
3332 mark_window_display_accurate (object
, 0);
3333 w
->update_mode_line
= 1;
3334 if (BUFFERP (w
->buffer
))
3335 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3336 ++update_mode_lines
;
3340 if (STRINGP (object
))
3341 object
= Fget_buffer (object
);
3342 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3344 /* Walk all windows looking for buffer, and force update
3345 of each of those windows. */
3347 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3348 return NILP (object
) ? Qnil
: Qt
;
3351 /* If nothing suitable was found, just return.
3352 We could signal an error, but this feature will typically be used
3353 asynchronously in timers or process sentinels, so we don't. */
3359 temp_output_buffer_show (register Lisp_Object buf
)
3361 register struct buffer
*old
= current_buffer
;
3362 register Lisp_Object window
;
3363 register struct window
*w
;
3365 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3368 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3372 set_buffer_internal (old
);
3374 if (!NILP (Vtemp_buffer_show_function
))
3375 call1 (Vtemp_buffer_show_function
, buf
);
3378 window
= display_buffer (buf
, Qnil
, Qnil
);
3380 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3381 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3382 Vminibuf_scroll_window
= window
;
3383 w
= XWINDOW (window
);
3386 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3387 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3389 /* Run temp-buffer-show-hook, with the chosen window selected
3390 and its buffer current. */
3392 ptrdiff_t count
= SPECPDL_INDEX ();
3393 Lisp_Object prev_window
, prev_buffer
;
3394 prev_window
= selected_window
;
3395 XSETBUFFER (prev_buffer
, old
);
3397 /* Select the window that was chosen, for running the hook.
3398 Note: Both Fselect_window and select_window_norecord may
3399 set-buffer to the buffer displayed in the window,
3400 so we need to save the current buffer. --stef */
3401 record_unwind_protect (Fset_buffer
, prev_buffer
);
3402 record_unwind_protect (select_window_norecord
, prev_window
);
3403 Fselect_window (window
, Qt
);
3404 Fset_buffer (w
->buffer
);
3405 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3406 unbind_to (count
, Qnil
);
3411 DEFUN ("internal-temp-output-buffer-show",
3412 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3414 doc
: /* Internal function for `with-output-to-temp-buffer'. */)
3417 temp_output_buffer_show (buf
);
3421 /* Make new window, have it replace WINDOW in window-tree, and make
3422 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3423 horizontal child). */
3425 make_parent_window (Lisp_Object window
, int horflag
)
3428 register struct window
*o
, *p
;
3430 o
= XWINDOW (window
);
3431 p
= allocate_window ();
3432 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3433 (char *) o
+ sizeof (struct vectorlike_header
),
3434 word_size
* VECSIZE (struct window
));
3435 XSETWINDOW (parent
, p
);
3437 p
->sequence_number
= ++sequence_number
;
3439 replace_window (window
, parent
, 1);
3441 wset_next (o
, Qnil
);
3442 wset_prev (o
, Qnil
);
3443 wset_parent (o
, parent
);
3445 wset_hchild (p
, horflag
? window
: Qnil
);
3446 wset_vchild (p
, horflag
? Qnil
: window
);
3447 wset_start (p
, Qnil
);
3448 wset_pointm (p
, Qnil
);
3449 wset_buffer (p
, Qnil
);
3450 wset_combination_limit (p
, Qnil
);
3451 wset_window_parameters (p
, Qnil
);
3454 /* Make new window from scratch. */
3459 register struct window
*w
;
3461 w
= allocate_window ();
3462 /* Initialize Lisp data. Note that allocate_window initializes all
3463 Lisp data to nil, so do it only for slots which should not be nil. */
3464 wset_left_col (w
, make_number (0));
3465 wset_top_line (w
, make_number (0));
3466 wset_total_lines (w
, make_number (0));
3467 wset_total_cols (w
, make_number (0));
3468 wset_normal_lines (w
, make_float (1.0));
3469 wset_normal_cols (w
, make_float (1.0));
3470 wset_new_total (w
, make_number (0));
3471 wset_new_normal (w
, make_number (0));
3472 wset_start (w
, Fmake_marker ());
3473 wset_pointm (w
, Fmake_marker ());
3474 wset_vertical_scroll_bar_type (w
, Qt
);
3475 wset_window_end_pos (w
, make_number (0));
3476 wset_window_end_vpos (w
, make_number (0));
3478 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3479 non-Lisp data, so do it only for slots which should not be zero. */
3480 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3481 w
->phys_cursor_type
= -1;
3482 w
->phys_cursor_width
= -1;
3483 w
->sequence_number
= ++sequence_number
;
3485 /* Reset window_list. */
3486 Vwindow_list
= Qnil
;
3487 /* Return window. */
3488 XSETWINDOW (window
, w
);
3492 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3493 doc
: /* Set new total size of WINDOW to SIZE.
3494 WINDOW must be a valid window and defaults to the selected one.
3497 Optional argument ADD non-nil means add SIZE to the new total size of
3498 WINDOW and return the sum.
3500 Note: This function does not operate on any child windows of WINDOW. */)
3501 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3503 struct window
*w
= decode_valid_window (window
);
3505 CHECK_NUMBER (size
);
3507 wset_new_total (w
, size
);
3509 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3511 return w
->new_total
;
3514 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3515 doc
: /* Set new normal size of WINDOW to SIZE.
3516 WINDOW must be a valid window and defaults to the selected one.
3519 Note: This function does not operate on any child windows of WINDOW. */)
3520 (Lisp_Object window
, Lisp_Object size
)
3522 wset_new_normal (decode_valid_window (window
), size
);
3526 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3527 non-zero) to w->new_total would result in correct heights (widths)
3528 for window W and recursively all child windows of W.
3530 Note: This function does not check any of `window-fixed-size-p',
3531 `window-min-height' or `window-min-width'. It does check that window
3532 sizes do not drop below one line (two columns). */
3534 window_resize_check (struct window
*w
, int horflag
)
3538 if (!NILP (w
->vchild
))
3539 /* W is a vertical combination. */
3541 c
= XWINDOW (w
->vchild
);
3543 /* All child windows of W must have the same width as W. */
3547 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3548 || !window_resize_check (c
, horflag
))
3550 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3555 /* The sum of the heights of the child windows of W must equal
3558 int sum_of_sizes
= 0;
3561 if (!window_resize_check (c
, horflag
))
3563 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3564 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3566 return (sum_of_sizes
== XINT (w
->new_total
));
3569 else if (!NILP (w
->hchild
))
3570 /* W is a horizontal combination. */
3572 c
= XWINDOW (w
->hchild
);
3574 /* The sum of the widths of the child windows of W must equal W's
3577 int sum_of_sizes
= 0;
3580 if (!window_resize_check (c
, horflag
))
3582 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3583 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3585 return (sum_of_sizes
== XINT (w
->new_total
));
3588 /* All child windows of W must have the same height as W. */
3592 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3593 || !window_resize_check (c
, horflag
))
3595 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3601 /* A leaf window. Make sure it's not too small. The following
3602 hardcodes the values of `window-safe-min-width' (2) and
3603 `window-safe-min-height' (1) which are defined in window.el. */
3604 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3607 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3608 w->new_total for window W and recursively all child windows of W.
3609 Also calculate and assign the new vertical (horizontal) start
3610 positions of each of these windows.
3612 This function does not perform any error checks. Make sure you have
3613 run window_resize_check on W before applying this function. */
3615 window_resize_apply (struct window
*w
, int horflag
)
3620 /* Note: Assigning new_normal requires that the new total size of the
3621 parent window has been set *before*. */
3624 wset_total_cols (w
, w
->new_total
);
3625 if (NUMBERP (w
->new_normal
))
3626 wset_normal_cols (w
, w
->new_normal
);
3628 pos
= XINT (w
->left_col
);
3632 wset_total_lines (w
, w
->new_total
);
3633 if (NUMBERP (w
->new_normal
))
3634 wset_normal_lines (w
, w
->new_normal
);
3636 pos
= XINT (w
->top_line
);
3639 if (!NILP (w
->vchild
))
3640 /* W is a vertical combination. */
3642 c
= XWINDOW (w
->vchild
);
3646 wset_left_col (c
, make_number (pos
));
3648 wset_top_line (c
, make_number (pos
));
3649 window_resize_apply (c
, horflag
);
3651 pos
= pos
+ XINT (c
->total_lines
);
3652 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3655 else if (!NILP (w
->hchild
))
3656 /* W is a horizontal combination. */
3658 c
= XWINDOW (w
->hchild
);
3662 wset_left_col (c
, make_number (pos
));
3664 wset_top_line (c
, make_number (pos
));
3665 window_resize_apply (c
, horflag
);
3667 pos
= pos
+ XINT (c
->total_cols
);
3668 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3672 /* Clear out some redisplay caches. */
3673 w
->last_modified
= 0;
3674 w
->last_overlay_modified
= 0;
3678 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 1, 2, 0,
3679 doc
: /* Apply requested size values for window-tree of FRAME.
3680 Optional argument HORIZONTAL omitted or nil means apply requested height
3681 values. HORIZONTAL non-nil means apply requested width values.
3683 This function checks whether the requested values sum up to a valid
3684 window layout, recursively assigns the new sizes of all child windows
3685 and calculates and assigns the new start positions of these windows.
3687 Note: This function does not check any of `window-fixed-size-p',
3688 `window-min-height' or `window-min-width'. All these checks have to
3689 be applied on the Elisp level. */)
3690 (Lisp_Object frame
, Lisp_Object horizontal
)
3694 int horflag
= !NILP (horizontal
);
3697 frame
= selected_frame
;
3698 CHECK_LIVE_FRAME (frame
);
3701 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
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
)));
3810 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3811 doc
: /* Split window OLD.
3812 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3813 new window. In any case TOTAL-SIZE must be a positive integer.
3815 Third argument SIDE nil (or `below') specifies that the new window shall
3816 be located below WINDOW. SIDE `above' means the new window shall be
3817 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3818 lines of the new window including space reserved for the mode and/or
3821 SIDE t (or `right') specifies that the new window shall be located on
3822 the right side of WINDOW. SIDE `left' means the new window shall be
3823 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3824 number of columns of the new window including space reserved for fringes
3825 and the scrollbar or a divider column.
3827 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3828 according to the SIDE argument.
3830 The new total and normal sizes of all involved windows must have been
3831 set correctly. See the code of `split-window' for how this is done. */)
3832 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3834 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3835 parent window or an internal window we have to install as OLD's new
3836 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3837 provided OLD is a leaf window, or to the frame's selected window.
3838 NEW (*n) is the new window created with some parameters taken from
3840 register Lisp_Object
new, frame
, reference
;
3841 register struct window
*o
, *p
, *n
, *r
;
3844 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3845 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3846 int combination_limit
= 0;
3850 frame
= WINDOW_FRAME (o
);
3853 CHECK_NUMBER (total_size
);
3855 /* Set combination_limit to 1 if we have to make a new parent window.
3856 We do that if either `window-combination-limit' is t, or OLD has no
3857 parent, or OLD is ortho-combined. */
3859 !NILP (Vwindow_combination_limit
)
3862 ? (XWINDOW (o
->parent
)->hchild
)
3863 : (XWINDOW (o
->parent
)->vchild
));
3865 /* We need a live reference window to initialize some parameters. */
3866 if (WINDOW_LIVE_P (old
))
3867 /* OLD is live, use it as reference window. */
3870 /* Use the frame's selected window as reference window. */
3871 reference
= FRAME_SELECTED_WINDOW (f
);
3872 r
= XWINDOW (reference
);
3874 /* The following bugs are caught by `split-window'. */
3875 if (MINI_WINDOW_P (o
))
3876 error ("Attempt to split minibuffer window");
3877 else if (XINT (total_size
) < (horflag
? 2 : 1))
3878 error ("Size of new window too small (after split)");
3879 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3880 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3883 p
= XWINDOW (o
->parent
);
3884 /* Temporarily pretend we split the parent window. */
3886 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3887 - XINT (total_size
)));
3888 if (!window_resize_check (p
, horflag
))
3889 error ("Window sizes don't fit");
3891 /* Undo the temporary pretension. */
3892 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3896 if (!window_resize_check (o
, horflag
))
3897 error ("Resizing old window failed");
3898 else if (XINT (total_size
) + XINT (o
->new_total
)
3899 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3900 error ("Sum of sizes of old and new window don't fit");
3903 /* This is our point of no return. */
3904 if (combination_limit
)
3906 /* Save the old value of o->normal_cols/lines. It gets corrupted
3907 by make_parent_window and we need it below for assigning it to
3909 Lisp_Object new_normal
3910 = horflag
? o
->normal_cols
: o
->normal_lines
;
3912 make_parent_window (old
, horflag
);
3913 p
= XWINDOW (o
->parent
);
3914 /* Store value of `window-combination-limit' in new parent's
3915 combination_limit slot. */
3916 wset_combination_limit (p
, Vwindow_combination_limit
);
3917 /* These get applied below. */
3918 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3919 wset_new_normal (p
, new_normal
);
3922 p
= XWINDOW (o
->parent
);
3924 windows_or_buffers_changed
++;
3925 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3926 new = make_window ();
3928 wset_frame (n
, frame
);
3929 wset_parent (n
, o
->parent
);
3930 wset_vchild (n
, Qnil
);
3931 wset_hchild (n
, Qnil
);
3933 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3935 wset_prev (n
, o
->prev
);
3938 wset_hchild (p
, new);
3940 wset_vchild (p
, new);
3942 wset_next (XWINDOW (n
->prev
), new);
3948 wset_next (n
, o
->next
);
3949 if (!NILP (n
->next
))
3950 wset_prev (XWINDOW (n
->next
), new);
3955 wset_buffer (n
, Qt
);
3956 wset_window_end_valid (n
, Qnil
);
3957 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3959 /* Get special geometry settings from reference window. */
3960 wset_left_margin_cols (n
, r
->left_margin_cols
);
3961 wset_right_margin_cols (n
, r
->right_margin_cols
);
3962 wset_left_fringe_width (n
, r
->left_fringe_width
);
3963 wset_right_fringe_width (n
, r
->right_fringe_width
);
3964 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3965 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3966 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3968 /* Directly assign orthogonal coordinates and sizes. */
3971 wset_top_line (n
, o
->top_line
);
3972 wset_total_lines (n
, o
->total_lines
);
3976 wset_left_col (n
, o
->left_col
);
3977 wset_total_cols (n
, o
->total_cols
);
3980 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3981 get them ready here. */
3982 wset_new_total (n
, total_size
);
3983 wset_new_normal (n
, normal_size
);
3986 window_resize_apply (p
, horflag
);
3988 /* Set buffer of NEW to buffer of reference window. Don't run
3990 set_window_buffer (new, r
->buffer
, 0, 1);
3993 /* Maybe we should run the scroll functions in Elisp (which already
3994 runs the configuration change hook). */
3995 if (! NILP (Vwindow_scroll_functions
))
3996 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3997 Fmarker_position (n
->start
));
4003 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
4004 doc
: /* Remove WINDOW from its frame.
4005 WINDOW defaults to the selected window. Return nil.
4006 Signal an error when WINDOW is the only window on its frame. */)
4007 (register Lisp_Object window
)
4009 register Lisp_Object parent
, sibling
, frame
, root
;
4010 struct window
*w
, *p
, *s
, *r
;
4013 int before_sibling
= 0;
4015 w
= decode_any_window (window
);
4016 XSETWINDOW (window
, w
);
4017 if (NILP (w
->buffer
)
4018 && NILP (w
->hchild
) && NILP (w
->vchild
))
4019 /* It's a no-op to delete an already deleted window. */
4024 /* Never delete a minibuffer or frame root window. */
4025 error ("Attempt to delete minibuffer or sole ordinary window");
4026 else if (NILP (w
->prev
) && NILP (w
->next
))
4027 /* Rather bow out here, this case should be handled on the Elisp
4029 error ("Attempt to delete sole window of parent");
4031 p
= XWINDOW (parent
);
4032 horflag
= NILP (p
->vchild
);
4034 frame
= WINDOW_FRAME (w
);
4037 root
= FRAME_ROOT_WINDOW (f
);
4040 /* Unlink WINDOW from window tree. */
4042 /* Get SIBLING below (on the right of) WINDOW. */
4044 /* before_sibling 1 means WINDOW is the first child of its
4045 parent and thus before the sibling. */
4048 s
= XWINDOW (sibling
);
4049 wset_prev (s
, Qnil
);
4051 wset_hchild (p
, sibling
);
4053 wset_vchild (p
, sibling
);
4056 /* Get SIBLING above (on the left of) WINDOW. */
4059 s
= XWINDOW (sibling
);
4060 wset_next (s
, w
->next
);
4061 if (!NILP (s
->next
))
4062 wset_prev (XWINDOW (s
->next
), sibling
);
4065 if (window_resize_check (r
, horflag
)
4066 && EQ (r
->new_total
,
4067 (horflag
? r
->total_cols
: r
->total_lines
)))
4068 /* We can delete WINDOW now. */
4073 #ifdef HAVE_XWIDGETS
4074 xwidget_view_delete_all_in_window(w
);
4076 window_resize_apply (p
, horflag
);
4078 /* If this window is referred to by the dpyinfo's mouse
4079 highlight, invalidate that slot to be safe (Bug#9904). */
4080 if (!FRAME_INITIAL_P (f
))
4082 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4084 if (EQ (hlinfo
->mouse_face_window
, window
))
4085 hlinfo
->mouse_face_window
= Qnil
;
4088 windows_or_buffers_changed
++;
4089 Vwindow_list
= Qnil
;
4090 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4092 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4093 free_window_matrices (w
);
4095 if (!NILP (w
->vchild
))
4097 delete_all_child_windows (w
->vchild
);
4098 wset_vchild (w
, Qnil
);
4100 else if (!NILP (w
->hchild
))
4102 delete_all_child_windows (w
->hchild
);
4103 wset_hchild (w
, Qnil
);
4105 else if (!NILP (w
->buffer
))
4108 unchain_marker (XMARKER (w
->pointm
));
4109 unchain_marker (XMARKER (w
->start
));
4110 wset_buffer (w
, Qnil
);
4113 if (NILP (s
->prev
) && NILP (s
->next
))
4114 /* A matrjoshka where SIBLING has become the only child of
4117 /* Put SIBLING into PARENT's place. */
4118 replace_window (parent
, sibling
, 0);
4119 /* Have SIBLING inherit the following three slot values from
4120 PARENT (the combination_limit slot is not inherited). */
4121 wset_normal_cols (s
, p
->normal_cols
);
4122 wset_normal_lines (s
, p
->normal_lines
);
4123 /* Mark PARENT as deleted. */
4124 wset_vchild (p
, Qnil
);
4125 wset_hchild (p
, Qnil
);
4126 /* Try to merge SIBLING into its new parent. */
4127 recombine_windows (sibling
);
4132 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4133 /* We deleted the frame's selected window. */
4135 /* Use the frame's first window as fallback ... */
4136 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4137 /* ... but preferably use its most recently used window. */
4138 Lisp_Object mru_window
;
4140 /* `get-mru-window' might fail for some reason so play it safe
4141 - promote the first window _without recording it_ first. */
4142 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4143 Fselect_window (new_selected_window
, Qt
);
4145 fset_selected_window (f
, new_selected_window
);
4149 /* Now look whether `get-mru-window' gets us something. */
4150 mru_window
= call1 (Qget_mru_window
, frame
);
4151 if (WINDOW_LIVE_P (mru_window
)
4152 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4153 new_selected_window
= mru_window
;
4155 /* If all ended up well, we now promote the mru window. */
4156 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4157 Fselect_window (new_selected_window
, Qnil
);
4159 fset_selected_window (f
, new_selected_window
);
4164 /* Must be run by the caller:
4165 run_window_configuration_change_hook (f); */
4168 /* We failed: Relink WINDOW into window tree. */
4172 wset_prev (s
, window
);
4174 wset_hchild (p
, window
);
4176 wset_vchild (p
, window
);
4180 wset_next (s
, window
);
4181 if (!NILP (w
->next
))
4182 wset_prev (XWINDOW (w
->next
), window
);
4184 error ("Deletion failed");
4190 /***********************************************************************
4191 Resizing Mini-Windows
4192 ***********************************************************************/
4194 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4197 grow_mini_window (struct window
*w
, int delta
)
4199 struct frame
*f
= XFRAME (w
->frame
);
4201 Lisp_Object root
, value
;
4203 eassert (MINI_WINDOW_P (w
));
4204 eassert (delta
>= 0);
4206 root
= FRAME_ROOT_WINDOW (f
);
4208 value
= call2 (Qwindow_resize_root_window_vertically
,
4209 root
, make_number (- delta
));
4210 if (INTEGERP (value
) && window_resize_check (r
, 0))
4213 window_resize_apply (r
, 0);
4215 /* Grow the mini-window. */
4217 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4219 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4220 w
->last_modified
= 0;
4221 w
->last_overlay_modified
= 0;
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;
4263 /* If the above failed for whatever strange reason we must make a
4264 one window frame here. The same routine will be needed when
4265 shrinking the frame (and probably when making the initial
4266 *scratch* window). For the moment leave things as they are. */
4270 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4271 doc
: /* Resize minibuffer window WINDOW. */)
4272 (Lisp_Object window
)
4274 struct window
*w
= XWINDOW (window
);
4279 CHECK_WINDOW (window
);
4280 f
= XFRAME (w
->frame
);
4282 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4283 error ("Not a valid minibuffer window");
4284 else if (FRAME_MINIBUF_ONLY_P (f
))
4285 error ("Cannot resize a minibuffer-only frame");
4287 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4288 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4289 if (window_resize_check (r
, 0)
4290 && XINT (w
->new_total
) > 0
4291 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4294 window_resize_apply (r
, 0);
4296 wset_total_lines (w
, w
->new_total
);
4297 wset_top_line (w
, make_number (XINT (r
->top_line
)
4298 + XINT (r
->total_lines
)));
4300 windows_or_buffers_changed
++;
4301 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4305 run_window_configuration_change_hook (f
);
4308 else error ("Failed to resize minibuffer window");
4311 /* Mark window cursors off for all windows in the window tree rooted
4312 at W by setting their phys_cursor_on_p flag to zero. Called from
4313 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4314 the frame are cleared. */
4317 mark_window_cursors_off (struct window
*w
)
4321 if (!NILP (w
->hchild
))
4322 mark_window_cursors_off (XWINDOW (w
->hchild
));
4323 else if (!NILP (w
->vchild
))
4324 mark_window_cursors_off (XWINDOW (w
->vchild
));
4326 w
->phys_cursor_on_p
= 0;
4328 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4333 /* Return number of lines of text (not counting mode lines) in W. */
4336 window_internal_height (struct window
*w
)
4338 int ht
= XFASTINT (w
->total_lines
);
4340 if (!MINI_WINDOW_P (w
))
4342 if (!NILP (w
->parent
)
4343 || !NILP (w
->vchild
)
4344 || !NILP (w
->hchild
)
4347 || WINDOW_WANTS_MODELINE_P (w
))
4350 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4357 /************************************************************************
4359 ***********************************************************************/
4361 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4362 N screen-fulls, which is defined as the height of the window minus
4363 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4364 instead. Negative values of N mean scroll down. NOERROR non-zero
4365 means don't signal an error if we try to move over BEGV or ZV,
4369 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4372 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4374 /* If we must, use the pixel-based version which is much slower than
4375 the line-based one but can handle varying line heights. */
4376 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4377 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4379 window_scroll_line_based (window
, n
, whole
, noerror
);
4385 /* Implementation of window_scroll that works based on pixel line
4386 heights. See the comment of window_scroll for parameter
4390 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4393 struct window
*w
= XWINDOW (window
);
4394 struct text_pos start
;
4395 int this_scroll_margin
;
4396 /* True if we fiddled the window vscroll field without really scrolling. */
4398 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4399 void *itdata
= NULL
;
4401 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4402 /* Scrolling a minibuffer window via scroll bar when the echo area
4403 shows long text sometimes resets the minibuffer contents behind
4405 if (CHARPOS (start
) > ZV
)
4406 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4408 /* If PT is not visible in WINDOW, move back one half of
4409 the screen. Allow PT to be partially visible, otherwise
4410 something like (scroll-down 1) with PT in the line before
4411 the partially visible one would recenter. */
4413 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4415 itdata
= bidi_shelve_cache ();
4416 /* Move backward half the height of the window. Performance note:
4417 vmotion used here is about 10% faster, but would give wrong
4418 results for variable height lines. */
4419 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4420 it
.current_y
= it
.last_visible_y
;
4421 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4423 /* The function move_iterator_vertically may move over more than
4424 the specified y-distance. If it->w is small, e.g. a
4425 mini-buffer window, we may end up in front of the window's
4426 display area. This is the case when Start displaying at the
4427 start of the line containing PT in this case. */
4428 if (it
.current_y
<= 0)
4430 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4431 move_it_vertically_backward (&it
, 0);
4435 start
= it
.current
.pos
;
4436 bidi_unshelve_cache (itdata
, 0);
4438 else if (auto_window_vscroll_p
)
4440 if (rtop
|| rbot
) /* partially visible */
4443 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4445 dy
= max ((window_box_height (w
)
4446 - next_screen_context_lines
* dy
),
4452 /* Only vscroll backwards if already vscrolled forwards. */
4453 if (w
->vscroll
< 0 && rtop
> 0)
4455 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4456 Fset_window_vscroll (window
, make_number (px
), Qt
);
4462 /* Do vscroll if already vscrolled or only display line. */
4463 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4465 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4466 Fset_window_vscroll (window
, make_number (px
), Qt
);
4470 /* Maybe modify window start instead of scrolling. */
4471 if (rbot
> 0 || w
->vscroll
< 0)
4475 Fset_window_vscroll (window
, make_number (0), Qt
);
4476 /* If there are other text lines above the current row,
4477 move window start to current row. Else to next row. */
4479 spos
= XINT (Fline_beginning_position (Qnil
));
4481 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4482 set_marker_restricted (w
->start
, make_number (spos
),
4484 w
->start_at_line_beg
= 1;
4485 w
->update_mode_line
= 1;
4486 w
->last_modified
= 0;
4487 w
->last_overlay_modified
= 0;
4488 /* Set force_start so that redisplay_window will run the
4489 window-scroll-functions. */
4495 /* Cancel previous vscroll. */
4496 Fset_window_vscroll (window
, make_number (0), Qt
);
4499 itdata
= bidi_shelve_cache ();
4500 /* If scroll_preserve_screen_position is non-nil, we try to set
4501 point in the same window line as it is now, so get that line. */
4502 if (!NILP (Vscroll_preserve_screen_position
))
4504 /* We preserve the goal pixel coordinate across consecutive
4505 calls to scroll-up, scroll-down and other commands that
4506 have the `scroll-command' property. This avoids the
4507 possibility of point becoming "stuck" on a tall line when
4508 scrolling by one line. */
4509 if (window_scroll_pixel_based_preserve_y
< 0
4510 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4511 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4513 start_display (&it
, w
, start
);
4514 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4515 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4516 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4520 window_scroll_pixel_based_preserve_y
4521 = window_scroll_pixel_based_preserve_x
= -1;
4523 /* Move iterator it from start the specified distance forward or
4524 backward. The result is the new window start. */
4525 start_display (&it
, w
, start
);
4528 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4529 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4530 dy
= max ((window_box_height (w
)
4531 - next_screen_context_lines
* dy
),
4534 /* Note that move_it_vertically always moves the iterator to the
4535 start of a line. So, if the last line doesn't have a newline,
4536 we would end up at the start of the line ending at ZV. */
4539 move_it_vertically_backward (&it
, -dy
);
4540 /* Ensure we actually do move, e.g. in case we are currently
4541 looking at an image that is taller that the window height. */
4542 while (start_pos
== IT_CHARPOS (it
)
4543 && start_pos
> BEGV
)
4544 move_it_by_lines (&it
, -1);
4548 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4549 MOVE_TO_POS
| MOVE_TO_Y
);
4550 /* Ensure we actually do move, e.g. in case we are currently
4551 looking at an image that is taller that the window height. */
4552 while (start_pos
== IT_CHARPOS (it
)
4554 move_it_by_lines (&it
, 1);
4558 move_it_by_lines (&it
, n
);
4560 /* We failed if we find ZV is already on the screen (scrolling up,
4561 means there's nothing past the end), or if we can't start any
4562 earlier (scrolling down, means there's nothing past the top). */
4563 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4564 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4566 if (IT_CHARPOS (it
) == ZV
)
4568 if (it
.current_y
< it
.last_visible_y
4569 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4570 > it
.last_visible_y
))
4572 /* The last line was only partially visible, make it fully
4574 w
->vscroll
= (it
.last_visible_y
4575 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4576 adjust_glyphs (it
.f
);
4580 bidi_unshelve_cache (itdata
, 0);
4583 else if (n
< 0) /* could happen with empty buffers */
4584 xsignal0 (Qbeginning_of_buffer
);
4586 xsignal0 (Qend_of_buffer
);
4591 if (w
->vscroll
!= 0)
4592 /* The first line was only partially visible, make it fully
4597 bidi_unshelve_cache (itdata
, 0);
4601 xsignal0 (Qbeginning_of_buffer
);
4605 /* If control gets here, then we vscrolled. */
4607 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4609 /* Don't try to change the window start below. */
4615 ptrdiff_t pos
= IT_CHARPOS (it
);
4618 /* If in the middle of a multi-glyph character move forward to
4619 the next character. */
4620 if (in_display_vector_p (&it
))
4623 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4626 /* Set the window start, and set up the window for redisplay. */
4627 set_marker_restricted (w
->start
, make_number (pos
),
4629 bytepos
= XMARKER (w
->start
)->bytepos
;
4630 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4631 w
->update_mode_line
= 1;
4632 w
->last_modified
= 0;
4633 w
->last_overlay_modified
= 0;
4634 /* Set force_start so that redisplay_window will run the
4635 window-scroll-functions. */
4639 /* The rest of this function uses current_y in a nonstandard way,
4640 not including the height of the header line if any. */
4641 it
.current_y
= it
.vpos
= 0;
4643 /* Move PT out of scroll margins.
4644 This code wants current_y to be zero at the window start position
4645 even if there is a header line. */
4646 this_scroll_margin
= max (0, scroll_margin
);
4648 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4649 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4653 /* We moved the window start towards ZV, so PT may be now
4654 in the scroll margin at the top. */
4655 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4656 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4657 && (NILP (Vscroll_preserve_screen_position
)
4658 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4659 /* We found PT at a legitimate height. Leave it alone. */
4661 else if (window_scroll_pixel_based_preserve_y
>= 0)
4663 /* If we have a header line, take account of it.
4664 This is necessary because we set it.current_y to 0, above. */
4665 move_it_to (&it
, -1,
4666 window_scroll_pixel_based_preserve_x
,
4667 window_scroll_pixel_based_preserve_y
4668 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4669 -1, MOVE_TO_Y
| MOVE_TO_X
);
4670 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4674 while (it
.current_y
< this_scroll_margin
)
4676 int prev
= it
.current_y
;
4677 move_it_by_lines (&it
, 1);
4678 if (prev
== it
.current_y
)
4681 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4686 ptrdiff_t charpos
, bytepos
;
4689 /* Save our position, for the
4690 window_scroll_pixel_based_preserve_y case. */
4691 charpos
= IT_CHARPOS (it
);
4692 bytepos
= IT_BYTEPOS (it
);
4694 /* We moved the window start towards BEGV, so PT may be now
4695 in the scroll margin at the bottom. */
4696 move_it_to (&it
, PT
, -1,
4697 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4698 - this_scroll_margin
- 1),
4700 MOVE_TO_POS
| MOVE_TO_Y
);
4702 /* Save our position, in case it's correct. */
4703 charpos
= IT_CHARPOS (it
);
4704 bytepos
= IT_BYTEPOS (it
);
4706 /* See if point is on a partially visible line at the end. */
4707 if (it
.what
== IT_EOB
)
4708 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4711 move_it_by_lines (&it
, 1);
4712 partial_p
= it
.current_y
> it
.last_visible_y
;
4715 if (charpos
== PT
&& !partial_p
4716 && (NILP (Vscroll_preserve_screen_position
)
4717 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4718 /* We found PT before we found the display margin, so PT is ok. */
4720 else if (window_scroll_pixel_based_preserve_y
>= 0)
4722 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4723 start_display (&it
, w
, start
);
4724 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4725 here because we called start_display again and did not
4726 alter it.current_y this time. */
4727 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4728 window_scroll_pixel_based_preserve_y
, -1,
4729 MOVE_TO_Y
| MOVE_TO_X
);
4730 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4735 /* The last line was only partially visible, so back up two
4736 lines to make sure we're on a fully visible line. */
4738 move_it_by_lines (&it
, -2);
4739 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4742 /* No, the position we saved is OK, so use it. */
4743 SET_PT_BOTH (charpos
, bytepos
);
4746 bidi_unshelve_cache (itdata
, 0);
4750 /* Implementation of window_scroll that works based on screen lines.
4751 See the comment of window_scroll for parameter descriptions. */
4754 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4756 register struct window
*w
= XWINDOW (window
);
4757 /* Fvertical_motion enters redisplay, which can trigger
4758 fontification, which in turn can modify buffer text (e.g., if the
4759 fontification functions replace escape sequences with faces, as
4760 in `grep-mode-font-lock-keywords'). So we use a marker to record
4761 the old point position, to prevent crashes in SET_PT_BOTH. */
4762 Lisp_Object opoint_marker
= Fpoint_marker ();
4763 register ptrdiff_t pos
, pos_byte
;
4764 register int ht
= window_internal_height (w
);
4765 register Lisp_Object tem
;
4769 Lisp_Object original_pos
= Qnil
;
4771 /* If scrolling screen-fulls, compute the number of lines to
4772 scroll from the window's height. */
4774 n
*= max (1, ht
- next_screen_context_lines
);
4776 startpos
= marker_position (w
->start
);
4778 if (!NILP (Vscroll_preserve_screen_position
))
4780 if (window_scroll_preserve_vpos
<= 0
4781 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4782 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4784 struct position posit
4785 = *compute_motion (startpos
, 0, 0, 0,
4789 window_scroll_preserve_vpos
= posit
.vpos
;
4790 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4793 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4794 make_number (window_scroll_preserve_vpos
));
4797 XSETFASTINT (tem
, PT
);
4798 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4802 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4807 lose
= n
< 0 && PT
== BEGV
;
4808 Fvertical_motion (make_number (n
), window
);
4812 SET_PT_BOTH (marker_position (opoint_marker
),
4813 marker_byte_position (opoint_marker
));
4820 xsignal0 (Qbeginning_of_buffer
);
4825 /* Don't use a scroll margin that is negative or too large. */
4826 int this_scroll_margin
=
4827 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4829 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4830 w
->start_at_line_beg
= !NILP (bolp
);
4831 w
->update_mode_line
= 1;
4832 w
->last_modified
= 0;
4833 w
->last_overlay_modified
= 0;
4834 /* Set force_start so that redisplay_window will run
4835 the window-scroll-functions. */
4838 if (!NILP (Vscroll_preserve_screen_position
)
4839 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4841 SET_PT_BOTH (pos
, pos_byte
);
4842 Fvertical_motion (original_pos
, window
);
4844 /* If we scrolled forward, put point enough lines down
4845 that it is outside the scroll margin. */
4850 if (this_scroll_margin
> 0)
4852 SET_PT_BOTH (pos
, pos_byte
);
4853 Fvertical_motion (make_number (this_scroll_margin
), window
);
4859 if (top_margin
<= marker_position (opoint_marker
))
4860 SET_PT_BOTH (marker_position (opoint_marker
),
4861 marker_byte_position (opoint_marker
));
4862 else if (!NILP (Vscroll_preserve_screen_position
))
4864 SET_PT_BOTH (pos
, pos_byte
);
4865 Fvertical_motion (original_pos
, window
);
4868 SET_PT (top_margin
);
4874 /* If we scrolled backward, put point near the end of the window
4875 but not within the scroll margin. */
4876 SET_PT_BOTH (pos
, pos_byte
);
4877 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4878 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4881 bottom_margin
= PT
+ 1;
4883 if (bottom_margin
> marker_position (opoint_marker
))
4884 SET_PT_BOTH (marker_position (opoint_marker
),
4885 marker_byte_position (opoint_marker
));
4888 if (!NILP (Vscroll_preserve_screen_position
))
4890 SET_PT_BOTH (pos
, pos_byte
);
4891 Fvertical_motion (original_pos
, window
);
4894 Fvertical_motion (make_number (-1), window
);
4903 xsignal0 (Qend_of_buffer
);
4908 /* Scroll selected_window up or down. If N is nil, scroll a
4909 screen-full which is defined as the height of the window minus
4910 next_screen_context_lines. If N is the symbol `-', scroll.
4911 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4912 up. This is the guts of Fscroll_up and Fscroll_down. */
4915 scroll_command (Lisp_Object n
, int direction
)
4917 ptrdiff_t count
= SPECPDL_INDEX ();
4919 eassert (eabs (direction
) == 1);
4921 /* If selected window's buffer isn't current, make it current for
4922 the moment. But don't screw up if window_scroll gets an error. */
4923 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4925 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4926 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4928 /* Make redisplay consider other windows than just selected_window. */
4929 ++windows_or_buffers_changed
;
4933 window_scroll (selected_window
, direction
, 1, 0);
4934 else if (EQ (n
, Qminus
))
4935 window_scroll (selected_window
, -direction
, 1, 0);
4938 n
= Fprefix_numeric_value (n
);
4939 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4942 unbind_to (count
, Qnil
);
4945 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4946 doc
: /* Scroll text of selected window upward ARG lines.
4947 If ARG is omitted or nil, scroll upward by a near full screen.
4948 A near full screen is `next-screen-context-lines' less than a full screen.
4949 Negative ARG means scroll downward.
4950 If ARG is the atom `-', scroll downward by nearly full screen.
4951 When calling from a program, supply as argument a number, nil, or `-'. */)
4954 scroll_command (arg
, 1);
4958 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4959 doc
: /* Scroll text of selected window down ARG lines.
4960 If ARG is omitted or nil, scroll down by a near full screen.
4961 A near full screen is `next-screen-context-lines' less than a full screen.
4962 Negative ARG means scroll upward.
4963 If ARG is the atom `-', scroll upward by nearly full screen.
4964 When calling from a program, supply as argument a number, nil, or `-'. */)
4967 scroll_command (arg
, -1);
4971 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4972 doc
: /* Return the other window for \"other window scroll\" commands.
4973 If `other-window-scroll-buffer' is non-nil, a window
4974 showing that buffer is used.
4975 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4976 specifies the window. This takes precedence over
4977 `other-window-scroll-buffer'. */)
4982 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4983 && !NILP (Vminibuf_scroll_window
))
4984 window
= Vminibuf_scroll_window
;
4985 /* If buffer is specified, scroll that buffer. */
4986 else if (!NILP (Vother_window_scroll_buffer
))
4988 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4990 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4994 /* Nothing specified; look for a neighboring window on the same
4996 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4998 if (EQ (window
, selected_window
))
4999 /* That didn't get us anywhere; look for a window on another
5002 window
= Fnext_window (window
, Qnil
, Qt
);
5003 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5004 && ! EQ (window
, selected_window
));
5007 CHECK_LIVE_WINDOW (window
);
5009 if (EQ (window
, selected_window
))
5010 error ("There is no other window");
5015 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5016 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5017 A near full screen is `next-screen-context-lines' less than a full screen.
5018 The next window is the one below the current one; or the one at the top
5019 if the current one is at the bottom. Negative ARG means scroll downward.
5020 If ARG is the atom `-', scroll downward by nearly full screen.
5021 When calling from a program, supply as argument a number, nil, or `-'.
5023 If `other-window-scroll-buffer' is non-nil, scroll the window
5024 showing that buffer, popping the buffer up if necessary.
5025 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5026 specifies the window to scroll. This takes precedence over
5027 `other-window-scroll-buffer'. */)
5032 ptrdiff_t count
= SPECPDL_INDEX ();
5034 window
= Fother_window_for_scrolling ();
5035 w
= XWINDOW (window
);
5037 /* Don't screw up if window_scroll gets an error. */
5038 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5039 ++windows_or_buffers_changed
;
5041 Fset_buffer (w
->buffer
);
5042 SET_PT (marker_position (w
->pointm
));
5045 window_scroll (window
, 1, 1, 1);
5046 else if (EQ (arg
, Qminus
))
5047 window_scroll (window
, -1, 1, 1);
5053 window_scroll (window
, XINT (arg
), 0, 1);
5056 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5057 unbind_to (count
, Qnil
);
5062 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5063 doc
: /* Scroll selected window display ARG columns left.
5064 Default for ARG is window width minus 2.
5065 Value is the total amount of leftward horizontal scrolling in
5066 effect after the change.
5067 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5068 lower bound for automatic scrolling, i.e. automatic scrolling
5069 will not scroll a window to a column less than the value returned
5070 by this function. This happens in an interactive call. */)
5071 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5073 struct window
*w
= XWINDOW (selected_window
);
5074 EMACS_INT requested_arg
= (NILP (arg
)
5075 ? window_body_cols (w
) - 2
5076 : XINT (Fprefix_numeric_value (arg
)));
5077 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5079 if (!NILP (set_minimum
))
5080 w
->min_hscroll
= w
->hscroll
;
5085 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5086 doc
: /* Scroll selected window display ARG columns right.
5087 Default for ARG is window width minus 2.
5088 Value is the total amount of leftward horizontal scrolling in
5089 effect after the change.
5090 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5091 lower bound for automatic scrolling, i.e. automatic scrolling
5092 will not scroll a window to a column less than the value returned
5093 by this function. This happens in an interactive call. */)
5094 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5096 struct window
*w
= XWINDOW (selected_window
);
5097 EMACS_INT requested_arg
= (NILP (arg
)
5098 ? window_body_cols (w
) - 2
5099 : XINT (Fprefix_numeric_value (arg
)));
5100 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5102 if (!NILP (set_minimum
))
5103 w
->min_hscroll
= w
->hscroll
;
5108 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5109 doc
: /* Return the window which was selected when entering the minibuffer.
5110 Returns nil, if selected window is not a minibuffer window. */)
5113 if (minibuf_level
> 0
5114 && MINI_WINDOW_P (XWINDOW (selected_window
))
5115 && WINDOW_LIVE_P (minibuf_selected_window
))
5116 return minibuf_selected_window
;
5121 /* Value is the number of lines actually displayed in window W,
5122 as opposed to its height. */
5125 displayed_window_lines (struct window
*w
)
5128 struct text_pos start
;
5129 int height
= window_box_height (w
);
5130 struct buffer
*old_buffer
;
5132 void *itdata
= NULL
;
5134 if (XBUFFER (w
->buffer
) != current_buffer
)
5136 old_buffer
= current_buffer
;
5137 set_buffer_internal (XBUFFER (w
->buffer
));
5142 /* In case W->start is out of the accessible range, do something
5143 reasonable. This happens in Info mode when Info-scroll-down
5144 calls (recenter -1) while W->start is 1. */
5145 if (XMARKER (w
->start
)->charpos
< BEGV
)
5146 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5147 else if (XMARKER (w
->start
)->charpos
> ZV
)
5148 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5150 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5152 itdata
= bidi_shelve_cache ();
5153 start_display (&it
, w
, start
);
5154 move_it_vertically (&it
, height
);
5155 bottom_y
= line_bottom_y (&it
);
5156 bidi_unshelve_cache (itdata
, 0);
5158 /* rms: On a non-window display,
5159 the value of it.vpos at the bottom of the screen
5160 seems to be 1 larger than window_box_height (w).
5161 This kludge fixes a bug whereby (move-to-window-line -1)
5162 when ZV is on the last screen line
5163 moves to the previous screen line instead of the last one. */
5164 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5167 /* Add in empty lines at the bottom of the window. */
5168 if (bottom_y
< height
)
5170 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5171 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5175 set_buffer_internal (old_buffer
);
5181 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5182 doc
: /* Center point in selected window and maybe redisplay frame.
5183 With prefix argument ARG, recenter putting point on screen line ARG
5184 relative to the selected window. If ARG is negative, it counts up from the
5185 bottom of the window. (ARG should be less than the height of the window.)
5187 If ARG is omitted or nil, then recenter with point on the middle line of
5188 the selected window; if the variable `recenter-redisplay' is non-nil,
5189 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5190 is set to `grow-only', this resets the tool-bar's height to the minimum
5191 height needed); if `recenter-redisplay' has the special value `tty',
5192 then only tty frames are redrawn.
5194 Just C-u as prefix means put point in the center of the window
5195 and redisplay normally--don't erase and redraw the frame. */)
5196 (register Lisp_Object arg
)
5198 struct window
*w
= XWINDOW (selected_window
);
5199 struct buffer
*buf
= XBUFFER (w
->buffer
);
5200 struct buffer
*obuf
= current_buffer
;
5202 ptrdiff_t charpos
, bytepos
;
5203 EMACS_INT iarg
IF_LINT (= 0);
5204 int this_scroll_margin
;
5206 /* If redisplay is suppressed due to an error, try again. */
5207 obuf
->display_error_modiff
= 0;
5211 if (!NILP (Vrecenter_redisplay
)
5212 && (!EQ (Vrecenter_redisplay
, Qtty
)
5213 || !NILP (Ftty_type (selected_frame
))))
5217 /* Invalidate pixel data calculated for all compositions. */
5218 for (i
= 0; i
< n_compositions
; i
++)
5219 composition_table
[i
]->font
= NULL
;
5221 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5223 Fredraw_frame (WINDOW_FRAME (w
));
5224 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5229 else if (CONSP (arg
)) /* Just C-u. */
5233 arg
= Fprefix_numeric_value (arg
);
5238 set_buffer_internal (buf
);
5240 /* Do this after making BUF current
5241 in case scroll_margin is buffer-local. */
5242 this_scroll_margin
=
5243 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5245 /* Handle centering on a graphical frame specially. Such frames can
5246 have variable-height lines and centering point on the basis of
5247 line counts would lead to strange effects. */
5248 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5254 void *itdata
= bidi_shelve_cache ();
5256 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5257 start_display (&it
, w
, pt
);
5258 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5259 charpos
= IT_CHARPOS (it
);
5260 bytepos
= IT_BYTEPOS (it
);
5261 bidi_unshelve_cache (itdata
, 0);
5267 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5268 int extra_line_spacing
;
5269 int h
= window_box_height (w
);
5270 void *itdata
= bidi_shelve_cache ();
5272 iarg
= - max (-iarg
, this_scroll_margin
);
5274 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5275 start_display (&it
, w
, pt
);
5277 /* Be sure we have the exact height of the full line containing PT. */
5278 move_it_by_lines (&it
, 0);
5280 /* The amount of pixels we have to move back is the window
5281 height minus what's displayed in the line containing PT,
5282 and the lines below. */
5285 move_it_by_lines (&it
, nlines
);
5287 if (it
.vpos
== nlines
)
5291 /* Last line has no newline */
5292 h
-= line_bottom_y (&it
);
5296 /* Don't reserve space for extra line spacing of last line. */
5297 extra_line_spacing
= it
.max_extra_line_spacing
;
5299 /* If we can't move down NLINES lines because we hit
5300 the end of the buffer, count in some empty lines. */
5301 if (it
.vpos
< nlines
)
5304 extra_line_spacing
= it
.extra_line_spacing
;
5305 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5309 bidi_unshelve_cache (itdata
, 0);
5313 /* Now find the new top line (starting position) of the window. */
5314 start_display (&it
, w
, pt
);
5316 move_it_vertically_backward (&it
, h
);
5318 /* If extra line spacing is present, we may move too far
5319 back. This causes the last line to be only partially
5320 visible (which triggers redisplay to recenter that line
5321 in the middle), so move forward.
5322 But ignore extra line spacing on last line, as it is not
5323 considered to be part of the visible height of the line.
5325 h
+= extra_line_spacing
;
5326 while (-it
.current_y
> h
)
5327 move_it_by_lines (&it
, 1);
5329 charpos
= IT_CHARPOS (it
);
5330 bytepos
= IT_BYTEPOS (it
);
5332 bidi_unshelve_cache (itdata
, 0);
5336 struct position pos
;
5338 iarg
= max (iarg
, this_scroll_margin
);
5340 pos
= *vmotion (PT
, -iarg
, w
);
5341 charpos
= pos
.bufpos
;
5342 bytepos
= pos
.bytepos
;
5347 struct position pos
;
5348 int ht
= window_internal_height (w
);
5355 /* Don't let it get into the margin at either top or bottom. */
5356 iarg
= max (iarg
, this_scroll_margin
);
5357 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5359 pos
= *vmotion (PT
, - iarg
, w
);
5360 charpos
= pos
.bufpos
;
5361 bytepos
= pos
.bytepos
;
5364 /* Set the new window start. */
5365 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5366 wset_window_end_valid (w
, Qnil
);
5368 w
->optional_new_start
= 1;
5370 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5371 FETCH_BYTE (bytepos
- 1) == '\n');
5373 set_buffer_internal (obuf
);
5377 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5379 doc
: /* Return the height in lines of the text display area of WINDOW.
5380 WINDOW must be a live window and defaults to the selected one.
5382 The returned height does not include the mode line, any header line,
5383 nor any partial-height lines at the bottom of the text area. */)
5384 (Lisp_Object window
)
5386 struct window
*w
= decode_live_window (window
);
5387 int pixel_height
= window_box_height (w
);
5388 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5389 return make_number (line_height
);
5394 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5396 doc
: /* Position point relative to window.
5397 ARG nil means position point at center of window.
5398 Else, ARG specifies vertical position within the window;
5399 zero means top of window, negative means relative to bottom of window. */)
5402 struct window
*w
= XWINDOW (selected_window
);
5406 int this_scroll_margin
;
5409 if (!(BUFFERP (w
->buffer
)
5410 && XBUFFER (w
->buffer
) == current_buffer
))
5411 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5412 when passed below to set_marker_both. */
5413 error ("move-to-window-line called from unrelated buffer");
5415 window
= selected_window
;
5416 start
= marker_position (w
->start
);
5417 if (start
< BEGV
|| start
> ZV
)
5419 int height
= window_internal_height (w
);
5420 Fvertical_motion (make_number (- (height
/ 2)), window
);
5421 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5422 w
->start_at_line_beg
= !NILP (Fbolp ());
5426 Fgoto_char (w
->start
);
5428 lines
= displayed_window_lines (w
);
5431 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5435 XSETFASTINT (arg
, lines
/ 2);
5438 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5441 iarg
= iarg
+ lines
;
5443 #if 0 /* This code would prevent move-to-window-line from moving point
5444 to a place inside the scroll margins (which would cause the
5445 next redisplay to scroll). I wrote this code, but then concluded
5446 it is probably better not to install it. However, it is here
5447 inside #if 0 so as not to lose it. -- rms. */
5449 /* Don't let it get into the margin at either top or bottom. */
5450 iarg
= max (iarg
, this_scroll_margin
);
5451 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5454 arg
= make_number (iarg
);
5457 /* Skip past a partially visible first line. */
5459 XSETINT (arg
, XINT (arg
) + 1);
5461 return Fvertical_motion (arg
, window
);
5466 /***********************************************************************
5467 Window Configuration
5468 ***********************************************************************/
5470 struct save_window_data
5472 struct vectorlike_header header
;
5473 Lisp_Object selected_frame
;
5474 Lisp_Object current_window
;
5475 Lisp_Object current_buffer
;
5476 Lisp_Object minibuf_scroll_window
;
5477 Lisp_Object minibuf_selected_window
;
5478 Lisp_Object root_window
;
5479 Lisp_Object focus_frame
;
5480 /* A vector, each of whose elements is a struct saved_window
5482 Lisp_Object saved_windows
;
5484 /* All fields above are traced by the GC.
5485 From `fame-cols' down, the fields are ignored by the GC. */
5487 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5488 int frame_tool_bar_lines
;
5491 /* This is saved as a Lisp_Vector */
5494 struct vectorlike_header header
;
5496 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5497 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5498 Lisp_Object normal_cols
, normal_lines
;
5499 Lisp_Object hscroll
, min_hscroll
;
5500 Lisp_Object parent
, prev
;
5501 Lisp_Object start_at_line_beg
;
5502 Lisp_Object display_table
;
5503 Lisp_Object left_margin_cols
, right_margin_cols
;
5504 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5505 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5506 Lisp_Object combination_limit
, window_parameters
;
5509 #define SAVED_WINDOW_N(swv,n) \
5510 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5512 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5513 doc
: /* Return t if OBJECT is a window-configuration object. */)
5514 (Lisp_Object object
)
5516 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5519 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5520 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5521 (Lisp_Object config
)
5523 register struct save_window_data
*data
;
5524 struct Lisp_Vector
*saved_windows
;
5526 CHECK_WINDOW_CONFIGURATION (config
);
5528 data
= (struct save_window_data
*) XVECTOR (config
);
5529 saved_windows
= XVECTOR (data
->saved_windows
);
5530 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5533 DEFUN ("set-window-configuration", Fset_window_configuration
,
5534 Sset_window_configuration
, 1, 1, 0,
5535 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5536 CONFIGURATION must be a value previously returned
5537 by `current-window-configuration' (which see).
5538 If CONFIGURATION was made from a frame that is now deleted,
5539 only frame-independent values can be restored. In this case,
5540 the return value is nil. Otherwise the value is t. */)
5541 (Lisp_Object configuration
)
5543 register struct save_window_data
*data
;
5544 struct Lisp_Vector
*saved_windows
;
5545 Lisp_Object new_current_buffer
;
5548 ptrdiff_t old_point
= -1;
5550 CHECK_WINDOW_CONFIGURATION (configuration
);
5552 data
= (struct save_window_data
*) XVECTOR (configuration
);
5553 saved_windows
= XVECTOR (data
->saved_windows
);
5555 new_current_buffer
= data
->current_buffer
;
5556 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5557 new_current_buffer
= Qnil
;
5560 if (XBUFFER (new_current_buffer
) == current_buffer
)
5561 /* The code further down "preserves point" by saving here PT in
5562 old_point and then setting it later back into PT. When the
5563 current-selected-window and the final-selected-window both show
5564 the current buffer, this suffers from the problem that the
5565 current PT is the window-point of the current-selected-window,
5566 while the final PT is the point of the final-selected-window, so
5567 this copy from one PT to the other would end up moving the
5568 window-point of the final-selected-window to the window-point of
5569 the current-selected-window. So we have to be careful which
5570 point of the current-buffer we copy into old_point. */
5571 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5572 && WINDOWP (selected_window
)
5573 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5574 && !EQ (selected_window
, data
->current_window
))
5575 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5579 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5580 point in new_current_buffer as of the last time this buffer was
5581 used. This can be non-deterministic since it can be changed by
5582 things like jit-lock by mere temporary selection of some random
5583 window that happens to show this buffer.
5584 So if possible we want this arbitrary choice of "which point" to
5585 be the one from the to-be-selected-window so as to prevent this
5586 window's cursor from being copied from another window. */
5587 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5588 /* If current_window = selected_window, its point is in BUF_PT. */
5589 && !EQ (selected_window
, data
->current_window
))
5590 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5592 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5595 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5598 /* If f is a dead frame, don't bother rebuilding its window tree.
5599 However, there is other stuff we should still try to do below. */
5600 if (FRAME_LIVE_P (f
))
5603 Lisp_Object dead_windows
= Qnil
;
5604 register Lisp_Object tem
, par
, pers
;
5605 register struct window
*w
;
5606 register struct saved_window
*p
;
5607 struct window
*root_window
;
5608 struct window
**leaf_windows
;
5613 /* If the frame has been resized since this window configuration was
5614 made, we change the frame to the size specified in the
5615 configuration, restore the configuration, and then resize it
5616 back. We keep track of the prevailing height in these variables. */
5617 int previous_frame_lines
= FRAME_LINES (f
);
5618 int previous_frame_cols
= FRAME_COLS (f
);
5619 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5620 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5622 /* Don't do this within the main loop below: This may call Lisp
5623 code and is thus potentially unsafe while input is blocked. */
5624 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5626 p
= SAVED_WINDOW_N (saved_windows
, k
);
5628 w
= XWINDOW (window
);
5629 if (!NILP (w
->buffer
)
5630 && !EQ (w
->buffer
, p
->buffer
)
5631 && !NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5632 /* If a window we restore gets another buffer, record the
5633 window's old buffer. */
5634 call1 (Qrecord_window_buffer
, window
);
5637 /* The mouse highlighting code could get screwed up
5638 if it runs during this. */
5641 if (data
->frame_lines
!= previous_frame_lines
5642 || data
->frame_cols
!= previous_frame_cols
)
5643 change_frame_size (f
, data
->frame_lines
,
5644 data
->frame_cols
, 0, 0, 0);
5645 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5646 if (data
->frame_menu_bar_lines
5647 != previous_frame_menu_bar_lines
)
5648 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5650 #ifdef HAVE_WINDOW_SYSTEM
5651 if (data
->frame_tool_bar_lines
5652 != previous_frame_tool_bar_lines
)
5653 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5658 /* "Swap out" point from the selected window's buffer
5659 into the window itself. (Normally the pointm of the selected
5660 window holds garbage.) We do this now, before
5661 restoring the window contents, and prevent it from
5662 being done later on when we select a new window. */
5663 if (! NILP (XWINDOW (selected_window
)->buffer
))
5665 w
= XWINDOW (selected_window
);
5666 set_marker_both (w
->pointm
,
5668 BUF_PT (XBUFFER (w
->buffer
)),
5669 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5672 windows_or_buffers_changed
++;
5673 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5675 /* Problem: Freeing all matrices and later allocating them again
5676 is a serious redisplay flickering problem. What we would
5677 really like to do is to free only those matrices not reused
5679 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5680 leaf_windows
= alloca (count_windows (root_window
)
5681 * sizeof *leaf_windows
);
5682 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5685 Mark all windows now on frame as "deleted".
5686 Restoring the new configuration "undeletes" any that are in it.
5688 Save their current buffers in their height fields, since we may
5689 need it later, if a buffer saved in the configuration is now
5691 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5693 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5695 p
= SAVED_WINDOW_N (saved_windows
, k
);
5697 w
= XWINDOW (window
);
5698 wset_next (w
, Qnil
);
5700 if (!NILP (p
->parent
))
5702 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5704 wset_parent (w
, Qnil
);
5706 if (!NILP (p
->prev
))
5709 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5710 wset_next (XWINDOW (w
->prev
), p
->window
);
5714 wset_prev (w
, Qnil
);
5715 if (!NILP (w
->parent
))
5717 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5719 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5720 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5724 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5725 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5730 /* If we squirreled away the buffer in the window's height,
5732 if (BUFFERP (w
->total_lines
))
5733 wset_buffer (w
, w
->total_lines
);
5734 wset_left_col (w
, p
->left_col
);
5735 wset_top_line (w
, p
->top_line
);
5736 wset_total_cols (w
, p
->total_cols
);
5737 wset_total_lines (w
, p
->total_lines
);
5738 wset_normal_cols (w
, p
->normal_cols
);
5739 wset_normal_lines (w
, p
->normal_lines
);
5740 w
->hscroll
= XFASTINT (p
->hscroll
);
5741 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5742 wset_display_table (w
, p
->display_table
);
5743 wset_left_margin_cols (w
, p
->left_margin_cols
);
5744 wset_right_margin_cols (w
, p
->right_margin_cols
);
5745 wset_left_fringe_width (w
, p
->left_fringe_width
);
5746 wset_right_fringe_width (w
, p
->right_fringe_width
);
5747 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5748 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5749 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5750 wset_dedicated (w
, p
->dedicated
);
5751 wset_combination_limit (w
, p
->combination_limit
);
5752 /* Restore any window parameters that have been saved.
5753 Parameters that have not been saved are left alone. */
5754 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5759 if (NILP (XCDR (pers
)))
5761 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5762 if (CONSP (par
) && !NILP (XCDR (par
)))
5763 /* Reset a parameter to nil if and only if it
5764 has a non-nil association. Don't make new
5766 Fsetcdr (par
, Qnil
);
5769 /* Always restore a non-nil value. */
5770 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5774 w
->last_modified
= 0;
5775 w
->last_overlay_modified
= 0;
5777 /* Reinstall the saved buffer and pointers into it. */
5778 if (NILP (p
->buffer
))
5779 /* An internal window. */
5780 wset_buffer (w
, p
->buffer
);
5781 else if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5782 /* If saved buffer is alive, install it. */
5784 wset_buffer (w
, p
->buffer
);
5785 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5786 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5787 set_marker_restricted (w
->pointm
, p
->pointm
,
5789 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5790 p
->mark
, w
->buffer
);
5792 /* As documented in Fcurrent_window_configuration, don't
5793 restore the location of point in the buffer which was
5794 current when the window configuration was recorded. */
5795 if (!EQ (p
->buffer
, new_current_buffer
)
5796 && XBUFFER (p
->buffer
) == current_buffer
)
5797 Fgoto_char (w
->pointm
);
5799 else if (!NILP (w
->buffer
)
5800 && !NILP (BVAR (XBUFFER (w
->buffer
), name
)))
5801 /* Keep window's old buffer; make sure the markers are
5804 /* Set window markers at start of visible range. */
5805 if (XMARKER (w
->start
)->buffer
== 0)
5806 set_marker_restricted (w
->start
, make_number (0),
5808 if (XMARKER (w
->pointm
)->buffer
== 0)
5809 set_marker_restricted_both
5810 (w
->pointm
, w
->buffer
,
5811 BUF_PT (XBUFFER (w
->buffer
)),
5812 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5813 w
->start_at_line_beg
= 1;
5816 /* Window has no live buffer, get one. */
5818 /* Get the buffer via other_buffer_safely in order to
5819 avoid showing an unimportant buffer and, if necessary, to
5820 recreate *scratch* in the course (part of Juanma's bs-show
5821 scenario from March 2011). */
5822 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5823 /* This will set the markers to beginning of visible
5825 set_marker_restricted (w
->start
,
5826 make_number (0), w
->buffer
);
5827 set_marker_restricted (w
->pointm
,
5828 make_number (0), w
->buffer
);
5829 w
->start_at_line_beg
= 1;
5830 if (!NILP (w
->dedicated
))
5831 /* Record this window as dead. */
5832 dead_windows
= Fcons (window
, dead_windows
);
5833 /* Make sure window is no more dedicated. */
5834 wset_dedicated (w
, Qnil
);
5838 fset_root_window (f
, data
->root_window
);
5839 /* Arrange *not* to restore point in the buffer that was
5840 current when the window configuration was saved. */
5841 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5842 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5843 make_number (old_point
),
5844 XWINDOW (data
->current_window
)->buffer
);
5846 /* In the following call to `select-window', prevent "swapping out
5847 point" in the old selected window using the buffer that has
5848 been restored into it. We already swapped out that point from
5849 that window's old buffer. */
5850 select_window (data
->current_window
, Qnil
, 1);
5851 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5854 if (NILP (data
->focus_frame
)
5855 || (FRAMEP (data
->focus_frame
)
5856 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5857 Fredirect_frame_focus (frame
, data
->focus_frame
);
5859 /* Set the screen height to the value it had before this function. */
5860 if (previous_frame_lines
!= FRAME_LINES (f
)
5861 || previous_frame_cols
!= FRAME_COLS (f
))
5862 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5864 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5865 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5866 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5868 #ifdef HAVE_WINDOW_SYSTEM
5869 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5870 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5875 /* Now, free glyph matrices in windows that were not reused. */
5876 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5878 if (NILP (leaf_windows
[i
]->buffer
))
5880 /* Assert it's not reused as a combination. */
5881 eassert (NILP (leaf_windows
[i
]->hchild
)
5882 && NILP (leaf_windows
[i
]->vchild
));
5883 free_window_matrices (leaf_windows
[i
]);
5885 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5892 /* Scan dead buffer windows. */
5893 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5895 window
= XCAR (dead_windows
);
5896 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5897 delete_deletable_window (window
);
5900 /* Fselect_window will have made f the selected frame, so we
5901 reselect the proper frame here. Fhandle_switch_frame will change the
5902 selected window too, but that doesn't make the call to
5903 Fselect_window above totally superfluous; it still sets f's
5905 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5906 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5908 run_window_configuration_change_hook (f
);
5911 if (!NILP (new_current_buffer
))
5913 Fset_buffer (new_current_buffer
);
5914 /* If the new current buffer doesn't appear in the selected
5915 window, go to its old point (see bug#12208). */
5916 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5917 Fgoto_char (make_number (old_point
));
5920 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5921 minibuf_selected_window
= data
->minibuf_selected_window
;
5923 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5927 /* Recursively delete all child windows reachable via the next, vchild,
5928 and hchild slots of WINDOW. */
5930 delete_all_child_windows (Lisp_Object window
)
5932 register struct window
*w
;
5934 w
= XWINDOW (window
);
5936 if (!NILP (w
->next
))
5937 /* Delete WINDOW's siblings (we traverse postorderly). */
5938 delete_all_child_windows (w
->next
);
5940 /* See Fset_window_configuration for excuse. */
5941 wset_total_lines (w
, w
->buffer
);
5943 if (!NILP (w
->vchild
))
5945 delete_all_child_windows (w
->vchild
);
5946 wset_vchild (w
, Qnil
);
5948 else if (!NILP (w
->hchild
))
5950 delete_all_child_windows (w
->hchild
);
5951 wset_hchild (w
, Qnil
);
5953 else if (!NILP (w
->buffer
))
5956 unchain_marker (XMARKER (w
->pointm
));
5957 unchain_marker (XMARKER (w
->start
));
5958 wset_buffer (w
, Qnil
);
5961 Vwindow_list
= Qnil
;
5965 count_windows (register struct window
*window
)
5967 register int count
= 1;
5968 if (!NILP (window
->next
))
5969 count
+= count_windows (XWINDOW (window
->next
));
5970 if (!NILP (window
->vchild
))
5971 count
+= count_windows (XWINDOW (window
->vchild
));
5972 if (!NILP (window
->hchild
))
5973 count
+= count_windows (XWINDOW (window
->hchild
));
5978 /* Fill vector FLAT with leaf windows under W, starting at index I.
5979 Value is last index + 1. */
5981 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5985 if (!NILP (w
->hchild
))
5986 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5987 else if (!NILP (w
->vchild
))
5988 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5992 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5999 /* Return a pointer to the glyph W's physical cursor is on. Value is
6000 null if W's current matrix is invalid, so that no meaningful glyph
6003 get_phys_cursor_glyph (struct window
*w
)
6005 struct glyph_row
*row
;
6006 struct glyph
*glyph
;
6007 int hpos
= w
->phys_cursor
.hpos
;
6009 if (!(w
->phys_cursor
.vpos
>= 0
6010 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
6013 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
6014 if (!row
->enabled_p
)
6019 /* When the window is hscrolled, cursor hpos can legitimately be
6020 out of bounds, but we draw the cursor at the corresponding
6021 window margin in that case. */
6022 if (!row
->reversed_p
&& hpos
< 0)
6024 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
6025 hpos
= row
->used
[TEXT_AREA
] - 1;
6028 if (row
->used
[TEXT_AREA
] > hpos
6030 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
6039 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6041 register struct saved_window
*p
;
6042 register struct window
*w
;
6043 register Lisp_Object tem
, pers
, par
;
6045 for (;!NILP (window
); window
= w
->next
)
6047 p
= SAVED_WINDOW_N (vector
, i
);
6048 w
= XWINDOW (window
);
6050 wset_temslot (w
, make_number (i
)); i
++;
6052 p
->buffer
= w
->buffer
;
6053 p
->left_col
= w
->left_col
;
6054 p
->top_line
= w
->top_line
;
6055 p
->total_cols
= w
->total_cols
;
6056 p
->total_lines
= w
->total_lines
;
6057 p
->normal_cols
= w
->normal_cols
;
6058 p
->normal_lines
= w
->normal_lines
;
6059 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6060 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6061 p
->display_table
= w
->display_table
;
6062 p
->left_margin_cols
= w
->left_margin_cols
;
6063 p
->right_margin_cols
= w
->right_margin_cols
;
6064 p
->left_fringe_width
= w
->left_fringe_width
;
6065 p
->right_fringe_width
= w
->right_fringe_width
;
6066 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6067 p
->scroll_bar_width
= w
->scroll_bar_width
;
6068 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6069 p
->dedicated
= w
->dedicated
;
6070 p
->combination_limit
= w
->combination_limit
;
6071 p
->window_parameters
= Qnil
;
6073 if (!NILP (Vwindow_persistent_parameters
))
6075 /* Run cycle detection on Vwindow_persistent_parameters. */
6076 Lisp_Object tortoise
, hare
;
6078 hare
= tortoise
= Vwindow_persistent_parameters
;
6079 while (CONSP (hare
))
6086 tortoise
= XCDR (tortoise
);
6088 if (EQ (hare
, tortoise
))
6089 /* Reset Vwindow_persistent_parameters to Qnil. */
6091 Vwindow_persistent_parameters
= Qnil
;
6096 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6100 /* Save values for persistent window parameters. */
6101 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6103 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6105 /* If the window has no value for the parameter,
6107 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6108 p
->window_parameters
);
6110 /* If the window has a value for the parameter,
6112 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6114 p
->window_parameters
);
6119 if (!NILP (w
->buffer
))
6121 /* Save w's value of point in the window configuration. If w
6122 is the selected window, then get the value of point from
6123 the buffer; pointm is garbage in the selected window. */
6124 if (EQ (window
, selected_window
))
6125 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6126 BUF_PT (XBUFFER (w
->buffer
)),
6127 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6129 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6130 XMARKER (p
->pointm
)->insertion_type
6131 = !NILP (Vwindow_point_insertion_type
);
6133 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6134 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6136 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6137 p
->mark
= Fcopy_marker (tem
, Qnil
);
6144 p
->start_at_line_beg
= Qnil
;
6147 if (NILP (w
->parent
))
6150 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6155 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6157 if (!NILP (w
->vchild
))
6158 i
= save_window_save (w
->vchild
, vector
, i
);
6159 if (!NILP (w
->hchild
))
6160 i
= save_window_save (w
->hchild
, vector
, i
);
6166 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6167 Scurrent_window_configuration
, 0, 1, 0,
6168 doc
: /* Return an object representing the current window configuration of FRAME.
6169 If FRAME is nil or omitted, use the selected frame.
6170 This describes the number of windows, their sizes and current buffers,
6171 and for each displayed buffer, where display starts, and the positions of
6172 point and mark. An exception is made for point in the current buffer:
6173 its value is -not- saved.
6174 This also records the currently selected frame, and FRAME's focus
6175 redirection (see `redirect-frame-focus'). The variable
6176 `window-persistent-parameters' specifies which window parameters are
6177 saved by this function. */)
6180 register Lisp_Object tem
;
6181 register int n_windows
;
6182 register struct save_window_data
*data
;
6187 frame
= selected_frame
;
6188 CHECK_LIVE_FRAME (frame
);
6191 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6192 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6193 PVEC_WINDOW_CONFIGURATION
);
6195 data
->frame_cols
= FRAME_COLS (f
);
6196 data
->frame_lines
= FRAME_LINES (f
);
6197 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6198 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6199 data
->selected_frame
= selected_frame
;
6200 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6201 XSETBUFFER (data
->current_buffer
, current_buffer
);
6202 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6203 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6204 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6205 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6206 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6207 data
->saved_windows
= tem
;
6208 for (i
= 0; i
< n_windows
; i
++)
6210 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6211 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6212 XSETWINDOW_CONFIGURATION (tem
, data
);
6216 /***********************************************************************
6218 ***********************************************************************/
6220 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6222 doc
: /* Set width of marginal areas of window WINDOW.
6223 WINDOW must be a live window and defaults to the selected one.
6225 Second arg LEFT-WIDTH specifies the number of character cells to
6226 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6227 does the same for the right marginal area. A nil width parameter
6228 means no margin. */)
6229 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6231 struct window
*w
= decode_live_window (window
);
6233 /* Translate negative or zero widths to nil.
6234 Margins that are too wide have to be checked elsewhere. */
6236 if (!NILP (left_width
))
6238 CHECK_NUMBER (left_width
);
6239 if (XINT (left_width
) <= 0)
6243 if (!NILP (right_width
))
6245 CHECK_NUMBER (right_width
);
6246 if (XINT (right_width
) <= 0)
6250 if (!EQ (w
->left_margin_cols
, left_width
)
6251 || !EQ (w
->right_margin_cols
, right_width
))
6253 wset_left_margin_cols (w
, left_width
);
6254 wset_right_margin_cols (w
, right_width
);
6256 adjust_window_margins (w
);
6258 ++windows_or_buffers_changed
;
6259 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6266 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6268 doc
: /* Get width of marginal areas of window WINDOW.
6269 WINDOW must be a live window and defaults to the selected one.
6271 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6272 If a marginal area does not exist, its width will be returned
6274 (Lisp_Object window
)
6276 struct window
*w
= decode_live_window (window
);
6277 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6282 /***********************************************************************
6284 ***********************************************************************/
6286 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6288 doc
: /* Set the fringe widths of window WINDOW.
6289 WINDOW must be a live window and defaults to the selected one.
6291 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6292 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6293 fringe width. If a fringe width arg is nil, that means to use the
6294 frame's default fringe width. Default fringe widths can be set with
6295 the command `set-fringe-style'.
6296 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6297 outside of the display margins. By default, fringes are drawn between
6298 display marginal areas and the text area. */)
6299 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6301 struct window
*w
= decode_live_window (window
);
6302 int outside
= !NILP (outside_margins
);
6304 if (!NILP (left_width
))
6305 CHECK_NATNUM (left_width
);
6306 if (!NILP (right_width
))
6307 CHECK_NATNUM (right_width
);
6309 /* Do nothing on a tty. */
6310 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6311 && (!EQ (w
->left_fringe_width
, left_width
)
6312 || !EQ (w
->right_fringe_width
, right_width
)
6313 || w
->fringes_outside_margins
!= outside
))
6315 wset_left_fringe_width (w
, left_width
);
6316 wset_right_fringe_width (w
, right_width
);
6317 w
->fringes_outside_margins
= outside
;
6319 adjust_window_margins (w
);
6321 clear_glyph_matrix (w
->current_matrix
);
6322 wset_window_end_valid (w
, Qnil
);
6324 ++windows_or_buffers_changed
;
6325 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6332 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6334 doc
: /* Get width of fringes of window WINDOW.
6335 WINDOW must be a live window and defaults to the selected one.
6337 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6338 (Lisp_Object window
)
6340 struct window
*w
= decode_live_window (window
);
6342 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6343 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6344 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6345 ? Qt
: Qnil
), Qnil
)));
6350 /***********************************************************************
6352 ***********************************************************************/
6354 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6355 Sset_window_scroll_bars
, 2, 4, 0,
6356 doc
: /* Set width and type of scroll bars of window WINDOW.
6357 WINDOW must be a live window and defaults to the selected one.
6359 Second parameter WIDTH specifies the pixel width for the scroll bar;
6360 this is automatically adjusted to a multiple of the frame column width.
6361 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6362 bar: left, right, or nil.
6363 If WIDTH is nil, use the frame's scroll-bar width.
6364 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6365 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6366 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6368 struct window
*w
= decode_live_window (window
);
6372 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6374 if (XINT (width
) == 0)
6375 vertical_type
= Qnil
;
6378 if (!(NILP (vertical_type
)
6379 || EQ (vertical_type
, Qleft
)
6380 || EQ (vertical_type
, Qright
)
6381 || EQ (vertical_type
, Qt
)))
6382 error ("Invalid type of vertical scroll bar");
6384 if (!EQ (w
->scroll_bar_width
, width
)
6385 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6387 wset_scroll_bar_width (w
, width
);
6388 wset_vertical_scroll_bar_type (w
, vertical_type
);
6390 adjust_window_margins (w
);
6392 clear_glyph_matrix (w
->current_matrix
);
6393 wset_window_end_valid (w
, Qnil
);
6395 ++windows_or_buffers_changed
;
6396 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6403 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6405 doc
: /* Get width and type of scroll bars of window WINDOW.
6406 WINDOW must be a live window and defaults to the selected one.
6408 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6409 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6411 (Lisp_Object window
)
6413 struct window
*w
= decode_live_window (window
);
6414 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6415 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6416 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6417 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6418 Fcons (w
->vertical_scroll_bar_type
,
6419 Fcons (Qnil
, Qnil
))));
6424 /***********************************************************************
6426 ***********************************************************************/
6428 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6429 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6430 If WINDOW is omitted or nil, it defaults to the selected window.
6431 Normally, value is a multiple of the canonical character height of WINDOW;
6432 optional second arg PIXELS-P means value is measured in pixels. */)
6433 (Lisp_Object window
, Lisp_Object pixels_p
)
6440 window
= selected_window
;
6442 CHECK_WINDOW (window
);
6443 w
= XWINDOW (window
);
6444 f
= XFRAME (w
->frame
);
6446 if (FRAME_WINDOW_P (f
))
6447 result
= (NILP (pixels_p
)
6448 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6449 : make_number (-w
->vscroll
));
6451 result
= make_number (0);
6456 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6458 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6459 WINDOW nil means use the selected window. Normally, VSCROLL is a
6460 non-negative multiple of the canonical character height of WINDOW;
6461 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6462 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6463 corresponds to an integral number of pixels. The return value is the
6464 result of this rounding.
6465 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6466 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6472 window
= selected_window
;
6474 CHECK_WINDOW (window
);
6475 CHECK_NUMBER_OR_FLOAT (vscroll
);
6477 w
= XWINDOW (window
);
6478 f
= XFRAME (w
->frame
);
6480 if (FRAME_WINDOW_P (f
))
6482 int old_dy
= w
->vscroll
;
6484 w
->vscroll
= - (NILP (pixels_p
)
6485 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6486 : XFLOATINT (vscroll
));
6487 w
->vscroll
= min (w
->vscroll
, 0);
6489 if (w
->vscroll
!= old_dy
)
6491 /* Adjust glyph matrix of the frame if the virtual display
6492 area becomes larger than before. */
6493 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6496 /* Prevent redisplay shortcuts. */
6497 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6501 return Fwindow_vscroll (window
, pixels_p
);
6505 /* Call FN for all leaf windows on frame F. FN is called with the
6506 first argument being a pointer to the leaf window, and with
6507 additional argument USER_DATA. Stops when FN returns 0. */
6510 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6513 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6514 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6515 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6519 /* Helper function for foreach_window. Call FN for all leaf windows
6520 reachable from W. FN is called with the first argument being a
6521 pointer to the leaf window, and with additional argument USER_DATA.
6522 Stop when FN returns 0. Value is 0 if stopped by FN. */
6525 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6529 for (cont
= 1; w
&& cont
;)
6531 if (!NILP (w
->hchild
))
6532 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6533 else if (!NILP (w
->vchild
))
6534 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6536 cont
= fn (w
, user_data
);
6538 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6545 /* Freeze or unfreeze the window start of W unless it is a
6546 mini-window or the selected window. FREEZE_P non-null means freeze
6547 the window start. */
6550 freeze_window_start (struct window
*w
, void *freeze_p
)
6552 if (MINI_WINDOW_P (w
)
6553 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6554 && (w
== XWINDOW (selected_window
)
6555 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6556 && ! NILP (Vminibuf_scroll_window
)
6557 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6560 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6565 /* Freeze or unfreeze the window starts of all leaf windows on frame
6566 F, except the selected window and a mini-window. FREEZE_P non-zero
6567 means freeze the window start. */
6570 freeze_window_starts (struct frame
*f
, int freeze_p
)
6572 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6576 /***********************************************************************
6578 ***********************************************************************/
6580 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6581 describe the same state of affairs. This is used by Fequal.
6583 ignore_positions non-zero means ignore non-matching scroll positions
6586 This ignores a couple of things like the dedication status of
6587 window, combination_limit and the like. This might have to be
6591 compare_window_configurations (Lisp_Object configuration1
, Lisp_Object configuration2
, int ignore_positions
)
6593 register struct save_window_data
*d1
, *d2
;
6594 struct Lisp_Vector
*sws1
, *sws2
;
6597 CHECK_WINDOW_CONFIGURATION (configuration1
);
6598 CHECK_WINDOW_CONFIGURATION (configuration2
);
6600 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6601 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6602 sws1
= XVECTOR (d1
->saved_windows
);
6603 sws2
= XVECTOR (d2
->saved_windows
);
6605 /* Frame settings must match. */
6606 if (d1
->frame_cols
!= d2
->frame_cols
6607 || d1
->frame_lines
!= d2
->frame_lines
6608 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6609 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6610 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6611 || (!ignore_positions
6612 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6613 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6614 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6615 /* Verify that the two configurations have the same number of windows. */
6616 || sws1
->header
.size
!= sws2
->header
.size
)
6619 for (i
= 0; i
< sws1
->header
.size
; i
++)
6621 struct saved_window
*sw1
, *sw2
;
6623 sw1
= SAVED_WINDOW_N (sws1
, i
);
6624 sw2
= SAVED_WINDOW_N (sws2
, i
);
6627 /* The "current" windows in the two configurations must
6628 correspond to each other. */
6629 EQ (d1
->current_window
, sw1
->window
)
6630 != EQ (d2
->current_window
, sw2
->window
)
6631 /* Windows' buffers must match. */
6632 || !EQ (sw1
->buffer
, sw2
->buffer
)
6633 || !EQ (sw1
->left_col
, sw2
->left_col
)
6634 || !EQ (sw1
->top_line
, sw2
->top_line
)
6635 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6636 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6637 || !EQ (sw1
->display_table
, sw2
->display_table
)
6638 /* The next two disjuncts check the window structure for
6640 || !EQ (sw1
->parent
, sw2
->parent
)
6641 || !EQ (sw1
->prev
, sw2
->prev
)
6642 || (!ignore_positions
6643 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6644 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6645 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6646 || NILP (Fequal (sw1
->start
, sw2
->start
))
6647 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6648 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6649 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6650 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6651 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6652 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6653 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6654 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6655 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6662 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6663 Scompare_window_configurations
, 2, 2, 0,
6664 doc
: /* Compare two window configurations as regards the structure of windows.
6665 This function ignores details such as the values of point and mark
6666 and scrolling positions. */)
6667 (Lisp_Object x
, Lisp_Object y
)
6669 if (compare_window_configurations (x
, y
, 1))
6675 init_window_once (void)
6677 struct frame
*f
= make_initial_frame ();
6678 XSETFRAME (selected_frame
, f
);
6679 Vterminal_frame
= selected_frame
;
6680 minibuf_window
= f
->minibuffer_window
;
6681 selected_window
= f
->selected_window
;
6682 last_nonminibuf_frame
= f
;
6684 window_initialized
= 1;
6690 Vwindow_list
= Qnil
;
6694 syms_of_window (void)
6696 DEFSYM (Qscroll_up
, "scroll-up");
6697 DEFSYM (Qscroll_down
, "scroll-down");
6698 DEFSYM (Qscroll_command
, "scroll-command");
6700 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6701 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6703 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6704 DEFSYM (Qwindowp
, "windowp");
6705 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6706 DEFSYM (Qwindow_live_p
, "window-live-p");
6707 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6708 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6709 DEFSYM (Qdelete_window
, "delete-window");
6710 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6711 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6712 DEFSYM (Qsafe
, "safe");
6713 DEFSYM (Qdisplay_buffer
, "display-buffer");
6714 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6715 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6716 DEFSYM (Qget_mru_window
, "get-mru-window");
6717 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6718 DEFSYM (Qabove
, "above");
6719 DEFSYM (Qbelow
, "below");
6720 DEFSYM (Qclone_of
, "clone-of");
6722 staticpro (&Vwindow_list
);
6724 minibuf_selected_window
= Qnil
;
6725 staticpro (&minibuf_selected_window
);
6727 window_scroll_pixel_based_preserve_x
= -1;
6728 window_scroll_pixel_based_preserve_y
= -1;
6729 window_scroll_preserve_hpos
= -1;
6730 window_scroll_preserve_vpos
= -1;
6732 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6733 doc
: /* Non-nil means call as function to display a help buffer.
6734 The function is called with one argument, the buffer to be displayed.
6735 Used by `with-output-to-temp-buffer'.
6736 If this function is used, then it must do the entire job of showing
6737 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6738 Vtemp_buffer_show_function
= Qnil
;
6740 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6741 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6742 Vminibuf_scroll_window
= Qnil
;
6744 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6745 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6746 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6747 is displayed in the `mode-line' face. */);
6748 mode_line_in_non_selected_windows
= 1;
6750 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6751 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6752 Vother_window_scroll_buffer
= Qnil
;
6754 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6755 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6756 auto_window_vscroll_p
= 1;
6758 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6759 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6760 next_screen_context_lines
= 2;
6762 DEFVAR_LISP ("scroll-preserve-screen-position",
6763 Vscroll_preserve_screen_position
,
6764 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6765 A value of nil means point does not keep its screen position except
6766 at the scroll margin or window boundary respectively.
6767 A value of t means point keeps its screen position if the scroll
6768 command moved it vertically out of the window, e.g. when scrolling
6770 Any other value means point always keeps its screen position.
6771 Scroll commands should have the `scroll-command' property
6772 on their symbols to be controlled by this variable. */);
6773 Vscroll_preserve_screen_position
= Qnil
;
6775 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6776 doc
: /* Type of marker to use for `window-point'. */);
6777 Vwindow_point_insertion_type
= Qnil
;
6779 DEFVAR_LISP ("window-configuration-change-hook",
6780 Vwindow_configuration_change_hook
,
6781 doc
: /* Functions to call when window configuration changes.
6782 The buffer-local part is run once per window, with the relevant window
6783 selected; while the global part is run only once for the modified frame,
6784 with the relevant frame selected. */);
6785 Vwindow_configuration_change_hook
= Qnil
;
6787 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6788 doc
: /* Non-nil means `recenter' redraws entire frame.
6789 If this option is non-nil, then the `recenter' command with a nil
6790 argument will redraw the entire frame; the special value `tty' causes
6791 the frame to be redrawn only if it is a tty frame. */);
6792 Vrecenter_redisplay
= Qtty
;
6794 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6795 doc
: /* If t, resize window combinations proportionally.
6796 If this variable is nil, splitting a window gets the entire screen space
6797 for displaying the new window from the window to split. Deleting and
6798 resizing a window preferably resizes one adjacent window only.
6800 If this variable is t, splitting a window tries to get the space
6801 proportionally from all windows in the same combination. This also
6802 allows to split a window that is otherwise too small or of fixed size.
6803 Resizing and deleting a window proportionally resize all windows in the
6806 Other values are reserved for future use.
6808 This variable takes no effect if `window-combination-limit' is non-nil. */);
6809 Vwindow_combination_resize
= Qnil
;
6811 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6812 doc
: /* If t, splitting a window makes a new parent window.
6813 If this variable is nil, splitting a window will create a new parent
6814 window only if the window has no parent window or the window shall
6815 become a combination orthogonal to the one it is part of.
6817 If this variable is t, splitting a window always creates a new parent
6818 window. If all splits behave this way, each frame's window tree is a
6819 binary tree and every window but the frame's root window has exactly one
6822 Other values are reserved for future use.
6824 The value of this variable is also assigned to the combination limit of
6825 the new parent window. The combination limit of a window can be
6826 retrieved via the function `window-combination-limit' and altered by the
6827 function `set-window-combination-limit'. */);
6828 Vwindow_combination_limit
= Qnil
;
6830 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6831 doc
: /* Alist of persistent window parameters.
6832 This alist specifies which window parameters shall get saved by
6833 `current-window-configuration' and `window-state-get' and subsequently
6834 restored to their previous values by `set-window-configuration' and
6837 The car of each entry of this alist is the symbol specifying the
6838 parameter. The cdr is one of the following:
6840 nil means the parameter is neither saved by `window-state-get' nor by
6841 `current-window-configuration'.
6843 t means the parameter is saved by `current-window-configuration' and,
6844 provided its WRITABLE argument is nil, by `window-state-get'.
6846 The symbol `writable' means the parameter is saved unconditionally by
6847 both `current-window-configuration' and `window-state-get'. Do not use
6848 this value for parameters without read syntax (like windows or frames).
6850 Parameters not saved by `current-window-configuration' or
6851 `window-state-get' are left alone by `set-window-configuration'
6852 respectively are not installed by `window-state-put'. */);
6853 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6855 defsubr (&Sselected_window
);
6856 defsubr (&Sminibuffer_window
);
6857 defsubr (&Swindow_minibuffer_p
);
6858 defsubr (&Swindowp
);
6859 defsubr (&Swindow_valid_p
);
6860 defsubr (&Swindow_live_p
);
6861 defsubr (&Swindow_frame
);
6862 defsubr (&Sframe_root_window
);
6863 defsubr (&Sframe_first_window
);
6864 defsubr (&Sframe_selected_window
);
6865 defsubr (&Sset_frame_selected_window
);
6866 defsubr (&Spos_visible_in_window_p
);
6867 defsubr (&Swindow_line_height
);
6868 defsubr (&Swindow_buffer
);
6869 defsubr (&Swindow_parent
);
6870 defsubr (&Swindow_top_child
);
6871 defsubr (&Swindow_left_child
);
6872 defsubr (&Swindow_next_sibling
);
6873 defsubr (&Swindow_prev_sibling
);
6874 defsubr (&Swindow_combination_limit
);
6875 defsubr (&Sset_window_combination_limit
);
6876 defsubr (&Swindow_use_time
);
6877 defsubr (&Swindow_top_line
);
6878 defsubr (&Swindow_left_column
);
6879 defsubr (&Swindow_total_height
);
6880 defsubr (&Swindow_total_width
);
6881 defsubr (&Swindow_normal_size
);
6882 defsubr (&Swindow_new_total
);
6883 defsubr (&Swindow_new_normal
);
6884 defsubr (&Sset_window_new_total
);
6885 defsubr (&Sset_window_new_normal
);
6886 defsubr (&Swindow_resize_apply
);
6887 defsubr (&Swindow_body_height
);
6888 defsubr (&Swindow_body_width
);
6889 defsubr (&Swindow_hscroll
);
6890 defsubr (&Sset_window_hscroll
);
6891 defsubr (&Swindow_redisplay_end_trigger
);
6892 defsubr (&Sset_window_redisplay_end_trigger
);
6893 defsubr (&Swindow_edges
);
6894 defsubr (&Swindow_pixel_edges
);
6895 defsubr (&Swindow_absolute_pixel_edges
);
6896 defsubr (&Swindow_inside_edges
);
6897 defsubr (&Swindow_inside_pixel_edges
);
6898 defsubr (&Swindow_inside_absolute_pixel_edges
);
6899 defsubr (&Scoordinates_in_window_p
);
6900 defsubr (&Swindow_at
);
6901 defsubr (&Swindow_point
);
6902 defsubr (&Swindow_start
);
6903 defsubr (&Swindow_end
);
6904 defsubr (&Sset_window_point
);
6905 defsubr (&Sset_window_start
);
6906 defsubr (&Swindow_dedicated_p
);
6907 defsubr (&Sset_window_dedicated_p
);
6908 defsubr (&Swindow_display_table
);
6909 defsubr (&Sset_window_display_table
);
6910 defsubr (&Snext_window
);
6911 defsubr (&Sprevious_window
);
6912 defsubr (&Sget_buffer_window
);
6913 defsubr (&Sdelete_other_windows_internal
);
6914 defsubr (&Sdelete_window_internal
);
6915 defsubr (&Sresize_mini_window_internal
);
6916 defsubr (&Sset_window_buffer
);
6917 defsubr (&Srun_window_configuration_change_hook
);
6918 defsubr (&Sselect_window
);
6919 defsubr (&Sforce_window_update
);
6920 defsubr (&Stemp_output_buffer_show
);
6921 defsubr (&Ssplit_window_internal
);
6922 defsubr (&Sscroll_up
);
6923 defsubr (&Sscroll_down
);
6924 defsubr (&Sscroll_left
);
6925 defsubr (&Sscroll_right
);
6926 defsubr (&Sother_window_for_scrolling
);
6927 defsubr (&Sscroll_other_window
);
6928 defsubr (&Sminibuffer_selected_window
);
6929 defsubr (&Srecenter
);
6930 defsubr (&Swindow_text_height
);
6931 defsubr (&Smove_to_window_line
);
6932 defsubr (&Swindow_configuration_p
);
6933 defsubr (&Swindow_configuration_frame
);
6934 defsubr (&Sset_window_configuration
);
6935 defsubr (&Scurrent_window_configuration
);
6936 defsubr (&Sset_window_margins
);
6937 defsubr (&Swindow_margins
);
6938 defsubr (&Sset_window_fringes
);
6939 defsubr (&Swindow_fringes
);
6940 defsubr (&Sset_window_scroll_bars
);
6941 defsubr (&Swindow_scroll_bars
);
6942 defsubr (&Swindow_vscroll
);
6943 defsubr (&Sset_window_vscroll
);
6944 defsubr (&Scompare_window_configurations
);
6945 defsubr (&Swindow_list
);
6946 defsubr (&Swindow_list_1
);
6947 defsubr (&Swindow_prev_buffers
);
6948 defsubr (&Sset_window_prev_buffers
);
6949 defsubr (&Swindow_next_buffers
);
6950 defsubr (&Sset_window_next_buffers
);
6951 defsubr (&Swindow_parameters
);
6952 defsubr (&Swindow_parameter
);
6953 defsubr (&Sset_window_parameter
);
6957 keys_of_window (void)
6959 initial_define_key (control_x_map
, '<', "scroll-left");
6960 initial_define_key (control_x_map
, '>', "scroll-right");
6962 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6963 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6964 initial_define_key (meta_map
, 'v', "scroll-down-command");