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 */
57 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_valid_p
;
58 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
59 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
60 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
61 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
62 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
63 static Lisp_Object Qsafe
, Qabove
, Qbelow
;
64 static Lisp_Object Qauto_buffer_name
, Qclone_of
;
66 static int displayed_window_lines (struct window
*);
67 static int count_windows (struct window
*);
68 static int get_leaf_windows (struct window
*, struct window
**, int);
69 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
70 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
71 static void window_scroll_line_based (Lisp_Object
, int, int, int);
72 static int freeze_window_start (struct window
*, void *);
73 static Lisp_Object
window_list (void);
74 static int add_window_to_list (struct window
*, void *);
75 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
77 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
79 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
81 static void foreach_window (struct frame
*,
82 int (* fn
) (struct window
*, void *),
84 static int foreach_window_1 (struct window
*,
85 int (* fn
) (struct window
*, void *),
87 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
88 static int window_resize_check (struct window
*, int);
89 static void window_resize_apply (struct window
*, int);
90 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
92 /* This is the window in which the terminal's cursor should
93 be left when nothing is being done with it. This must
94 always be a leaf window, and its buffer is selected by
95 the top level editing loop at the end of each command.
97 This value is always the same as
98 FRAME_SELECTED_WINDOW (selected_frame). */
99 Lisp_Object selected_window
;
101 /* A list of all windows for use by next_window and Fwindow_list.
102 Functions creating or deleting windows should invalidate this cache
103 by setting it to nil. */
104 Lisp_Object Vwindow_list
;
106 /* The mini-buffer window of the selected frame.
107 Note that you cannot test for mini-bufferness of an arbitrary window
108 by comparing against this; but you can test for mini-bufferness of
109 the selected window. */
110 Lisp_Object minibuf_window
;
112 /* Non-nil means it is the window whose mode line should be
113 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Hook run at end of temp_output_buffer_show. */
117 static Lisp_Object Qtemp_buffer_show_hook
;
119 /* Incremented for each window created. */
120 static int sequence_number
;
122 /* Nonzero after init_window_once has finished. */
123 static int window_initialized
;
125 /* Hook to run when window config changes. */
126 static Lisp_Object Qwindow_configuration_change_hook
;
128 /* Used by the function window_scroll_pixel_based */
129 static int window_scroll_pixel_based_preserve_x
;
130 static int window_scroll_pixel_based_preserve_y
;
132 /* Same for window_scroll_line_based. */
133 static EMACS_INT window_scroll_preserve_hpos
;
134 static EMACS_INT window_scroll_preserve_vpos
;
136 /* These setters are used only in this file, so they can be private. */
138 wset_combination_limit (struct window
*w
, Lisp_Object val
)
140 w
->combination_limit
= val
;
143 wset_dedicated (struct window
*w
, Lisp_Object val
)
148 wset_display_table (struct window
*w
, Lisp_Object val
)
150 w
->display_table
= val
;
153 wset_hchild (struct window
*w
, Lisp_Object val
)
158 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
160 w
->left_fringe_width
= val
;
163 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
165 w
->left_margin_cols
= val
;
168 wset_new_normal (struct window
*w
, Lisp_Object val
)
173 wset_new_total (struct window
*w
, Lisp_Object val
)
178 wset_next_buffers (struct window
*w
, Lisp_Object val
)
180 w
->next_buffers
= val
;
183 wset_normal_cols (struct window
*w
, Lisp_Object val
)
185 w
->normal_cols
= val
;
188 wset_normal_lines (struct window
*w
, Lisp_Object val
)
190 w
->normal_lines
= val
;
193 wset_parent (struct window
*w
, Lisp_Object val
)
198 wset_pointm (struct window
*w
, Lisp_Object val
)
203 wset_prev_buffers (struct window
*w
, Lisp_Object val
)
205 w
->prev_buffers
= val
;
208 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
210 w
->right_fringe_width
= val
;
213 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
215 w
->right_margin_cols
= val
;
218 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
220 w
->scroll_bar_width
= val
;
223 wset_start (struct window
*w
, Lisp_Object val
)
228 wset_temslot (struct window
*w
, Lisp_Object val
)
233 wset_vchild (struct window
*w
, Lisp_Object val
)
238 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
240 w
->vertical_scroll_bar_type
= val
;
243 wset_window_parameters (struct window
*w
, Lisp_Object val
)
245 w
->window_parameters
= val
;
249 decode_live_window (register Lisp_Object window
)
252 return XWINDOW (selected_window
);
254 CHECK_LIVE_WINDOW (window
);
255 return XWINDOW (window
);
258 static struct window
*
259 decode_any_window (register Lisp_Object window
)
264 return XWINDOW (selected_window
);
266 CHECK_WINDOW (window
);
267 w
= XWINDOW (window
);
272 decode_valid_window (register Lisp_Object window
)
277 return XWINDOW (selected_window
);
279 CHECK_VALID_WINDOW (window
);
280 w
= XWINDOW (window
);
284 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
285 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
288 return WINDOWP (object
) ? Qt
: Qnil
;
291 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
292 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
293 A valid window is either a window that displays a buffer or an internal
294 window. Deleted windows are not live. */)
297 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
300 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
301 doc
: /* Return t if OBJECT is a live window and nil otherwise.
302 A live window is a window that displays a buffer.
303 Internal windows and deleted windows are not live. */)
306 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
309 /* Frames and windows. */
310 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
311 doc
: /* Return the frame that window WINDOW is on.
312 WINDOW must be a valid window and defaults to the selected one. */)
315 return decode_valid_window (window
)->frame
;
318 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
319 doc
: /* Return the root window of FRAME-OR-WINDOW.
320 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
321 With a frame argument, return that frame's root window.
322 With a window argument, return the root window of that window's frame. */)
323 (Lisp_Object frame_or_window
)
327 if (NILP (frame_or_window
))
328 window
= SELECTED_FRAME ()->root_window
;
329 else if (WINDOW_VALID_P (frame_or_window
))
330 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
333 CHECK_LIVE_FRAME (frame_or_window
);
334 window
= XFRAME (frame_or_window
)->root_window
;
340 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
341 doc
: /* Return the minibuffer window for frame FRAME.
342 If FRAME is omitted or nil, it defaults to the selected frame. */)
346 frame
= selected_frame
;
347 CHECK_LIVE_FRAME (frame
);
348 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
351 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
352 Swindow_minibuffer_p
, 0, 1, 0,
353 doc
: /* Return non-nil if WINDOW is a minibuffer window.
354 WINDOW must be a valid window and defaults to the selected one. */)
357 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
360 /* Don't move this to window.el - this must be a safe routine. */
361 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
362 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
363 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
364 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
365 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
366 the first window of that frame. */)
367 (Lisp_Object frame_or_window
)
371 if (NILP (frame_or_window
))
372 window
= SELECTED_FRAME ()->root_window
;
373 else if (WINDOW_VALID_P (frame_or_window
))
374 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
377 CHECK_LIVE_FRAME (frame_or_window
);
378 window
= XFRAME (frame_or_window
)->root_window
;
381 while (NILP (XWINDOW (window
)->buffer
))
383 if (! NILP (XWINDOW (window
)->hchild
))
384 window
= XWINDOW (window
)->hchild
;
385 else if (! NILP (XWINDOW (window
)->vchild
))
386 window
= XWINDOW (window
)->vchild
;
394 DEFUN ("frame-selected-window", Fframe_selected_window
,
395 Sframe_selected_window
, 0, 1, 0,
396 doc
: /* Return the selected window of FRAME-OR-WINDOW.
397 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
398 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
399 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
400 return the selected window of that frame. */)
401 (Lisp_Object frame_or_window
)
405 if (NILP (frame_or_window
))
406 window
= SELECTED_FRAME ()->selected_window
;
407 else if (WINDOW_VALID_P (frame_or_window
))
408 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
411 CHECK_LIVE_FRAME (frame_or_window
);
412 window
= XFRAME (frame_or_window
)->selected_window
;
418 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
419 Sset_frame_selected_window
, 2, 3, 0,
420 doc
: /* Set selected window of FRAME to WINDOW.
421 FRAME must be a live frame and defaults to the selected one. If FRAME
422 is the selected frame, this makes WINDOW the selected window. Optional
423 argument NORECORD non-nil means to neither change the order of recently
424 selected windows nor the buffer list. WINDOW must denote a live window.
426 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
429 frame
= selected_frame
;
431 CHECK_LIVE_FRAME (frame
);
432 CHECK_LIVE_WINDOW (window
);
434 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
435 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
437 if (EQ (frame
, selected_frame
))
438 return Fselect_window (window
, norecord
);
441 fset_selected_window (XFRAME (frame
), window
);
446 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
447 doc
: /* Return the selected window.
448 The selected window is the window in which the standard cursor for
449 selected windows appears and to which many commands apply. */)
452 return selected_window
;
455 int window_select_count
;
457 /* If select_window is called with inhibit_point_swap non-zero it will
458 not store point of the old selected window's buffer back into that
459 window's pointm slot. This is needed by Fset_window_configuration to
460 avoid that the display routine is called with selected_window set to
461 Qnil causing a subsequent crash. */
463 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
465 register struct window
*w
;
466 register struct window
*ow
;
469 CHECK_LIVE_WINDOW (window
);
471 w
= XWINDOW (window
);
472 w
->frozen_window_start_p
= 0;
476 w
->use_time
= ++window_select_count
;
477 record_buffer (w
->buffer
);
480 /* Make the selected window's buffer current. */
481 Fset_buffer (w
->buffer
);
483 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
486 sf
= SELECTED_FRAME ();
487 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
489 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
490 /* Use this rather than Fhandle_switch_frame
491 so that FRAME_FOCUS_FRAME is moved appropriately as we
492 move around in the state where a minibuffer in a separate
494 Fselect_frame (WINDOW_FRAME (w
), norecord
);
495 /* Fselect_frame called us back so we've done all the work already. */
496 eassert (EQ (window
, selected_window
));
500 fset_selected_window (sf
, window
);
502 /* Store the old selected window's buffer's point in pointm of the old
503 selected window. It belongs to that window, and when the window is
504 not selected, must be in the window. */
505 if (!inhibit_point_swap
)
507 ow
= XWINDOW (selected_window
);
508 if (! NILP (ow
->buffer
))
509 set_marker_both (ow
->pointm
, ow
->buffer
,
510 BUF_PT (XBUFFER (ow
->buffer
)),
511 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
514 selected_window
= window
;
515 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
517 /* Go to the point recorded in the window.
518 This is important when the buffer is in more
519 than one window. It also matters when
520 redisplay_window has altered point after scrolling,
521 because it makes the change only in the window. */
523 register ptrdiff_t new_point
= marker_position (w
->pointm
);
524 if (new_point
< BEGV
)
526 else if (new_point
> ZV
)
532 windows_or_buffers_changed
++;
536 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
537 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
538 Also make WINDOW's buffer current and make WINDOW the frame's selected
539 window. Return WINDOW.
541 Optional second arg NORECORD non-nil means do not put this buffer at the
542 front of the buffer list and do not make this window the most recently
545 Note that the main editor command loop sets the current buffer to the
546 buffer of the selected window before each command. */)
547 (register Lisp_Object window
, Lisp_Object norecord
)
549 return select_window (window
, norecord
, 0);
552 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
553 doc
: /* Return the buffer displayed in window WINDOW.
554 If WINDOW is omitted or nil, it defaults to the selected window.
555 Return nil for an internal window or a deleted window. */)
558 return decode_any_window (window
)->buffer
;
561 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
562 doc
: /* Return the parent window of window WINDOW.
563 WINDOW must be a valid window and defaults to the selected one.
564 Return nil for a window with no parent (e.g. a root window). */)
567 return decode_valid_window (window
)->parent
;
570 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 1, 1, 0,
571 doc
: /* Return the topmost child window of window WINDOW.
572 WINDOW must be a valid window and defaults to the selected one.
573 Return nil if WINDOW is a live window (live windows have no children).
574 Return nil if WINDOW is an internal window whose children form a
575 horizontal combination. */)
578 CHECK_WINDOW (window
);
579 return decode_valid_window (window
)->vchild
;
582 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 1, 1, 0,
583 doc
: /* Return the leftmost child window of window WINDOW.
584 WINDOW must be a valid window and defaults to the selected one.
585 Return nil if WINDOW is a live window (live windows have no children).
586 Return nil if WINDOW is an internal window whose children form a
587 vertical combination. */)
590 CHECK_WINDOW (window
);
591 return decode_valid_window (window
)->hchild
;
594 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
595 doc
: /* Return the next sibling window of window WINDOW.
596 WINDOW must be a valid window and defaults to the selected one.
597 Return nil if WINDOW has no next sibling. */)
600 return decode_valid_window (window
)->next
;
603 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
604 doc
: /* Return the previous sibling window of window WINDOW.
605 WINDOW must be a valid window and defaults to the selected one.
606 Return nil if WINDOW has no previous sibling. */)
609 return decode_valid_window (window
)->prev
;
612 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
613 doc
: /* Return combination limit of window WINDOW.
614 WINDOW must be a valid window and defaults to the selected one.
615 If the return value is nil, child windows of WINDOW can be recombined with
616 WINDOW's siblings. A return value of t means that child windows of
617 WINDOW are never \(re-)combined with WINDOW's siblings. */)
620 return decode_valid_window (window
)->combination_limit
;
623 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
624 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
625 WINDOW must be a valid window and defaults to the selected one.
626 If LIMIT is nil, child windows of WINDOW can be recombined with
627 WINDOW's siblings. LIMIT t means that child windows of WINDOW are
628 never \(re-)combined with WINDOW's siblings. Other values are reserved
630 (Lisp_Object window
, Lisp_Object limit
)
632 wset_combination_limit (decode_valid_window (window
), limit
);
636 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
637 doc
: /* Return the use time of window WINDOW.
638 WINDOW must be a live window and defaults to the selected one.
639 The window with the highest use time is the most recently selected
640 one. The window with the lowest use time is the least recently
644 return make_number (decode_live_window (window
)->use_time
);
647 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
648 doc
: /* Return the total height, in lines, of window WINDOW.
649 WINDOW must be a valid window and defaults to the selected one.
651 The return value includes the mode line and header line, if any.
652 If WINDOW is an internal window, the total height is the height
653 of the screen areas spanned by its children.
655 On a graphical display, this total height is reported as an
656 integer multiple of the default character height. */)
659 return decode_valid_window (window
)->total_lines
;
662 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
663 doc
: /* Return the total width, in columns, of window WINDOW.
664 WINDOW must be a valid window and defaults to the selected one.
666 The return value includes any vertical dividers or scroll bars
667 belonging to WINDOW. If WINDOW is an internal window, the total width
668 is the width of the screen areas spanned by its children.
670 On a graphical display, this total width is reported as an
671 integer multiple of the default character width. */)
674 return decode_valid_window (window
)->total_cols
;
677 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
678 doc
: /* Return the new total size of window WINDOW.
679 WINDOW must be a valid window and defaults to the selected one. */)
682 return decode_valid_window (window
)->new_total
;
685 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
686 doc
: /* Return the normal height of window WINDOW.
687 WINDOW must be a valid window and defaults to the selected one.
688 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
689 (Lisp_Object window
, Lisp_Object horizontal
)
691 struct window
*w
= decode_valid_window (window
);
693 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
696 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
697 doc
: /* Return new normal size of window WINDOW.
698 WINDOW must be a valid window and defaults to the selected one. */)
701 return decode_valid_window (window
)->new_normal
;
704 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
705 doc
: /* Return left column of window WINDOW.
706 This is the distance, in columns, between the left edge of WINDOW and
707 the left edge of the frame's window area. For instance, the return
708 value is 0 if there is no window to the left of WINDOW.
710 WINDOW must be a valid window and defaults to the selected one. */)
713 return decode_valid_window (window
)->left_col
;
716 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
717 doc
: /* Return top line of window WINDOW.
718 This is the distance, in lines, between the top of WINDOW and the top
719 of the frame's window area. For instance, the return value is 0 if
720 there is no window above WINDOW.
722 WINDOW must be a valid window and defaults to the selected one. */)
725 return decode_valid_window (window
)->top_line
;
728 /* Return the number of lines of W's body. Don't count any mode or
732 window_body_lines (struct window
*w
)
734 int height
= XFASTINT (w
->total_lines
);
736 if (!MINI_WINDOW_P (w
))
738 if (WINDOW_WANTS_MODELINE_P (w
))
740 if (WINDOW_WANTS_HEADER_LINE_P (w
))
747 /* Return the number of columns of W's body. Don't count columns
748 occupied by the scroll bar or the vertical bar separating W from its
749 right sibling. On window-systems don't count fringes or display
753 window_body_cols (struct window
*w
)
755 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
756 int width
= XINT (w
->total_cols
);
758 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
759 /* Scroll bars occupy a few columns. */
760 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
761 else if (!FRAME_WINDOW_P (f
)
762 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
763 /* The column of `|' characters separating side-by-side windows
764 occupies one column only. */
767 if (FRAME_WINDOW_P (f
))
768 /* On window-systems, fringes and display margins cannot be
769 used for normal text. */
770 width
-= (WINDOW_FRINGE_COLS (w
)
771 + WINDOW_LEFT_MARGIN_COLS (w
)
772 + WINDOW_RIGHT_MARGIN_COLS (w
));
777 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
778 doc
: /* Return the height, in lines, of WINDOW's text area.
779 WINDOW must be a live window and defaults to the selected one.
781 The returned height does not include the mode line or header line.
782 On a graphical display, the height is expressed as an integer multiple
783 of the default character height. If a line at the bottom of the text
784 area is only partially visible, that counts as a whole line; to
785 exclude partially-visible lines, use `window-text-height'. */)
788 struct window
*w
= decode_live_window (window
);
789 return make_number (window_body_lines (w
));
792 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
793 doc
: /* Return the width, in columns, of WINDOW's text area.
794 WINDOW must be a live window and defaults to the selected one.
796 The return value does not include any vertical dividers, fringe or
797 marginal areas, or scroll bars. On a graphical display, the width is
798 expressed as an integer multiple of the default character width. */)
801 struct window
*w
= decode_live_window (window
);
802 return make_number (window_body_cols (w
));
805 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
806 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
807 WINDOW must be a live window and defaults to the selected one. */)
810 return make_number (decode_live_window (window
)->hscroll
);
813 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
814 range, returning the new amount as a fixnum. */
816 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
818 /* Horizontal scrolling has problems with large scroll amounts.
819 It's too slow with long lines, and even with small lines the
820 display can be messed up. For now, though, impose only the limits
821 required by the internal representation: horizontal scrolling must
822 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
823 (since it's stored in a ptrdiff_t). */
824 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
825 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
827 /* Prevent redisplay shortcuts when changing the hscroll. */
828 if (w
->hscroll
!= new_hscroll
)
829 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
831 w
->hscroll
= new_hscroll
;
832 return make_number (new_hscroll
);
835 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
836 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
837 WINDOW must be a live window and defaults to the selected one.
838 Clip the number to a reasonable value if out of range.
839 Return the new number. NCOL should be zero or positive.
841 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
842 window so that the location of point moves off-window. */)
843 (Lisp_Object window
, Lisp_Object ncol
)
845 struct window
*w
= decode_live_window (window
);
848 return set_window_hscroll (w
, XINT (ncol
));
851 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
852 Swindow_redisplay_end_trigger
, 0, 1, 0,
853 doc
: /* Return WINDOW's redisplay end trigger value.
854 WINDOW must be a live window and defaults to the selected one.
855 See `set-window-redisplay-end-trigger' for more information. */)
858 return decode_live_window (window
)->redisplay_end_trigger
;
861 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
862 Sset_window_redisplay_end_trigger
, 2, 2, 0,
863 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
864 WINDOW must be a live window and defaults to the selected one. VALUE
865 should be a buffer position (typically a marker) or nil. If it is a
866 buffer position, then if redisplay in WINDOW reaches a position beyond
867 VALUE, the functions in `redisplay-end-trigger-functions' are called
868 with two arguments: WINDOW, and the end trigger value. Afterwards the
869 end-trigger value is reset to nil. */)
870 (register Lisp_Object window
, Lisp_Object value
)
872 wset_redisplay_end_trigger (decode_live_window (window
), value
);
876 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
877 doc
: /* Return a list of the edge coordinates of WINDOW.
878 WINDOW must be a valid window and defaults to the selected one.
880 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
881 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
882 0 at top left corner of frame.
884 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
885 is one more than the bottommost row occupied by WINDOW. The edges
886 include the space used by WINDOW's scroll bar, display margins, fringes,
887 header line, and/or mode line. For the edges of just the text area, use
888 `window-inside-edges'. */)
891 register struct window
*w
= decode_valid_window (window
);
893 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
894 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
895 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
896 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
900 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
901 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
902 WINDOW must be a valid window and defaults to the selected one.
904 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
905 0, 0 at the top left corner of the frame.
907 RIGHT is one more than the rightmost x position occupied by WINDOW.
908 BOTTOM is one more than the bottommost y position occupied by WINDOW.
909 The pixel edges include the space used by WINDOW's scroll bar, display
910 margins, fringes, header line, and/or mode line. For the pixel edges
911 of just the text area, use `window-inside-pixel-edges'. */)
914 register struct window
*w
= decode_valid_window (window
);
916 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
917 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
918 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
919 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
924 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
926 struct frame
*f
= XFRAME (w
->frame
);
928 #ifdef FRAME_MENUBAR_HEIGHT
929 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
931 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
932 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
933 #elif FRAME_TOOLBAR_HEIGHT
934 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
936 #ifdef FRAME_NS_TITLEBAR_HEIGHT
937 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
939 *add_x
= f
->left_pos
;
940 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
941 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
945 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
946 Swindow_absolute_pixel_edges
, 0, 1, 0,
947 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
948 WINDOW must be a valid window and defaults to the selected one.
950 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
951 0, 0 at the top left corner of the display.
953 RIGHT is one more than the rightmost x position occupied by WINDOW.
954 BOTTOM is one more than the bottommost y position occupied by WINDOW.
955 The pixel edges include the space used by WINDOW's scroll bar, display
956 margins, fringes, header line, and/or mode line. For the pixel edges
957 of just the text area, use `window-inside-absolute-pixel-edges'. */)
960 register struct window
*w
= decode_valid_window (window
);
962 calc_absolute_offset (w
, &add_x
, &add_y
);
964 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
965 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
966 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
967 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
971 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
972 doc
: /* Return a list of the edge coordinates of WINDOW.
973 WINDOW must be a live window and defaults to the selected one.
975 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
976 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
977 0 at top left corner of frame.
979 RIGHT is one more than the rightmost column of WINDOW's text area.
980 BOTTOM is one more than the bottommost row of WINDOW's text area. The
981 inside edges do not include the space used by the WINDOW's scroll bar,
982 display margins, fringes, header line, and/or mode line. */)
985 register struct window
*w
= decode_live_window (window
);
987 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
988 + WINDOW_LEFT_MARGIN_COLS (w
)
989 + WINDOW_LEFT_FRINGE_COLS (w
)),
990 make_number (WINDOW_TOP_EDGE_LINE (w
)
991 + WINDOW_HEADER_LINE_LINES (w
)),
992 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
993 - WINDOW_RIGHT_MARGIN_COLS (w
)
994 - WINDOW_RIGHT_FRINGE_COLS (w
)),
995 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
996 - WINDOW_MODE_LINE_LINES (w
)));
999 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
1000 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1001 WINDOW must be a live window and defaults to the selected one.
1003 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1004 (0,0) at the top left corner of the frame's window area.
1006 RIGHT is one more than the rightmost x position of WINDOW's text area.
1007 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1008 The inside edges do not include the space used by WINDOW's scroll bar,
1009 display margins, fringes, header line, and/or mode line. */)
1010 (Lisp_Object window
)
1012 register struct window
*w
= decode_live_window (window
);
1014 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
1015 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1016 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1017 make_number (WINDOW_TOP_EDGE_Y (w
)
1018 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1019 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
1020 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1021 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1022 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
1023 - WINDOW_MODE_LINE_HEIGHT (w
)));
1026 DEFUN ("window-inside-absolute-pixel-edges",
1027 Fwindow_inside_absolute_pixel_edges
,
1028 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1029 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1030 WINDOW must be a live window and defaults to the selected one.
1032 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1033 (0,0) at the top left corner of the frame's window area.
1035 RIGHT is one more than the rightmost x position of WINDOW's text area.
1036 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1037 The inside edges do not include the space used by WINDOW's scroll bar,
1038 display margins, fringes, header line, and/or mode line. */)
1039 (Lisp_Object window
)
1041 register struct window
*w
= decode_live_window (window
);
1043 calc_absolute_offset (w
, &add_x
, &add_y
);
1045 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
1046 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1047 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1048 make_number (WINDOW_TOP_EDGE_Y (w
)
1049 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1050 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
1051 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1052 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1053 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
1054 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1057 /* Test if the character at column X, row Y is within window W.
1058 If it is not, return ON_NOTHING;
1059 if it is in the window's text area, return ON_TEXT;
1060 if it is on the window's modeline, return ON_MODE_LINE;
1061 if it is on the border between the window and its right sibling,
1062 return ON_VERTICAL_BORDER.
1063 if it is on a scroll bar, return ON_SCROLL_BAR.
1064 if it is on the window's top line, return ON_HEADER_LINE;
1065 if it is in left or right fringe of the window,
1066 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1067 if it is in the marginal area to the left/right of the window,
1068 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1070 X and Y are frame relative pixel coordinates. */
1072 static enum window_part
1073 coordinates_in_window (register struct window
*w
, int x
, int y
)
1075 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1076 enum window_part part
;
1077 int ux
= FRAME_COLUMN_WIDTH (f
);
1078 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1079 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1080 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1081 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1082 /* The width of the area where the vertical line can be dragged.
1083 (Between mode lines for instance. */
1084 int grabbable_width
= ux
;
1085 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1087 /* Outside any interesting row or column? */
1088 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1091 /* On the mode line or header line? */
1092 if ((WINDOW_WANTS_MODELINE_P (w
)
1093 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1094 && (part
= ON_MODE_LINE
))
1095 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1096 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1097 && (part
= ON_HEADER_LINE
)))
1099 /* If it's under/over the scroll bar portion of the mode/header
1100 line, say it's on the vertical line. That's to be able to
1101 resize windows horizontally in case we're using toolkit scroll
1102 bars. Note: If scrollbars are on the left, the window that
1103 must be eventually resized is that on the left of WINDOW. */
1104 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1105 && !WINDOW_LEFTMOST_P (w
)
1106 && eabs (x
- left_x
) < grabbable_width
)
1107 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1108 && !WINDOW_RIGHTMOST_P (w
)
1109 && eabs (x
- right_x
) < grabbable_width
))
1110 return ON_VERTICAL_BORDER
;
1115 /* In what's below, we subtract 1 when computing right_x because we
1116 want the rightmost pixel, which is given by left_pixel+width-1. */
1117 if (w
->pseudo_window_p
)
1120 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1124 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1125 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1128 /* Outside any interesting column? */
1129 if (x
< left_x
|| x
> right_x
)
1130 return ON_SCROLL_BAR
;
1132 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1133 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1135 text_left
= window_box_left (w
, TEXT_AREA
);
1136 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1138 if (FRAME_WINDOW_P (f
))
1140 if (!w
->pseudo_window_p
1141 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1142 && !WINDOW_RIGHTMOST_P (w
)
1143 && (eabs (x
- right_x
) < grabbable_width
))
1144 return ON_VERTICAL_BORDER
;
1146 /* Need to say "x > right_x" rather than >=, since on character
1147 terminals, the vertical line's x coordinate is right_x. */
1148 else if (!w
->pseudo_window_p
1149 && !WINDOW_RIGHTMOST_P (w
)
1150 && x
> right_x
- ux
)
1151 return ON_VERTICAL_BORDER
;
1155 if (lmargin_width
> 0
1156 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1157 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1158 : (x
< left_x
+ lmargin_width
)))
1159 return ON_LEFT_MARGIN
;
1161 return ON_LEFT_FRINGE
;
1164 if (x
>= text_right
)
1166 if (rmargin_width
> 0
1167 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1168 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1169 : (x
>= right_x
- rmargin_width
)))
1170 return ON_RIGHT_MARGIN
;
1172 return ON_RIGHT_FRINGE
;
1175 /* Everything special ruled out - must be on text area */
1179 /* Take X is the frame-relative pixel x-coordinate, and return the
1180 x-coordinate relative to part PART of window W. */
1182 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1184 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1189 return x
- window_box_left (w
, TEXT_AREA
);
1191 case ON_LEFT_FRINGE
:
1194 case ON_RIGHT_FRINGE
:
1195 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1197 case ON_LEFT_MARGIN
:
1199 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1200 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1202 case ON_RIGHT_MARGIN
:
1204 - ((w
->pseudo_window_p
)
1205 ? WINDOW_TOTAL_WIDTH (w
)
1206 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1207 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1208 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1209 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1212 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1217 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1218 Scoordinates_in_window_p
, 2, 2, 0,
1219 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1220 WINDOW must be a live window and defaults to the selected one.
1221 COORDINATES is a cons of the form (X . Y), X and Y being distances
1222 measured in characters from the upper-left corner of the frame.
1223 \(0 . 0) denotes the character in the upper left corner of the
1225 If COORDINATES are in the text portion of WINDOW,
1226 the coordinates relative to the window are returned.
1227 If they are in the mode line of WINDOW, `mode-line' is returned.
1228 If they are in the top mode line of WINDOW, `header-line' is returned.
1229 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1230 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1231 If they are on the border between WINDOW and its right sibling,
1232 `vertical-line' is returned.
1233 If they are in the windows's left or right marginal areas, `left-margin'\n\
1234 or `right-margin' is returned. */)
1235 (register Lisp_Object coordinates
, Lisp_Object window
)
1242 w
= decode_live_window (window
);
1243 f
= XFRAME (w
->frame
);
1244 CHECK_CONS (coordinates
);
1245 lx
= Fcar (coordinates
);
1246 ly
= Fcdr (coordinates
);
1247 CHECK_NUMBER_OR_FLOAT (lx
);
1248 CHECK_NUMBER_OR_FLOAT (ly
);
1249 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1250 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1252 switch (coordinates_in_window (w
, x
, y
))
1258 /* Convert X and Y to window relative pixel coordinates, and
1259 return the canonical char units. */
1260 x
-= window_box_left (w
, TEXT_AREA
);
1261 y
-= WINDOW_TOP_EDGE_Y (w
);
1262 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1263 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1268 case ON_VERTICAL_BORDER
:
1269 return Qvertical_line
;
1271 case ON_HEADER_LINE
:
1272 return Qheader_line
;
1274 case ON_LEFT_FRINGE
:
1275 return Qleft_fringe
;
1277 case ON_RIGHT_FRINGE
:
1278 return Qright_fringe
;
1280 case ON_LEFT_MARGIN
:
1281 return Qleft_margin
;
1283 case ON_RIGHT_MARGIN
:
1284 return Qright_margin
;
1287 /* Historically we are supposed to return nil in this case. */
1296 /* Callback for foreach_window, used in window_from_coordinates.
1297 Check if window W contains coordinates specified by USER_DATA which
1298 is actually a pointer to a struct check_window_data CW.
1300 Check if window W contains coordinates *CW->x and *CW->y. If it
1301 does, return W in *CW->window, as Lisp_Object, and return in
1302 *CW->part the part of the window under coordinates *X,*Y. Return
1303 zero from this function to stop iterating over windows. */
1305 struct check_window_data
1307 Lisp_Object
*window
;
1309 enum window_part
*part
;
1313 check_window_containing (struct window
*w
, void *user_data
)
1315 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1316 enum window_part found
;
1319 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1320 if (found
!= ON_NOTHING
)
1323 XSETWINDOW (*cw
->window
, w
);
1331 /* Find the window containing frame-relative pixel position X/Y and
1332 return it as a Lisp_Object.
1334 If X, Y is on one of the window's special `window_part' elements,
1335 set *PART to the id of that element.
1337 If there is no window under X, Y return nil and leave *PART
1338 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1340 This function was previously implemented with a loop cycling over
1341 windows with Fnext_window, and starting with the frame's selected
1342 window. It turned out that this doesn't work with an
1343 implementation of next_window using Vwindow_list, because
1344 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1345 tree of F when this function is called asynchronously from
1346 note_mouse_highlight. The original loop didn't terminate in this
1350 window_from_coordinates (struct frame
*f
, int x
, int y
,
1351 enum window_part
*part
, int tool_bar_p
)
1354 struct check_window_data cw
;
1355 enum window_part dummy
;
1361 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1362 foreach_window (f
, check_window_containing
, &cw
);
1364 /* If not found above, see if it's in the tool bar window, if a tool
1368 && WINDOWP (f
->tool_bar_window
)
1369 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1370 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1374 window
= f
->tool_bar_window
;
1380 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1381 doc
: /* Return window containing coordinates X and Y on FRAME.
1382 FRAME must be a live frame and defaults to the selected one.
1383 The top left corner of the frame is considered to be row 0,
1385 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1390 frame
= selected_frame
;
1391 CHECK_LIVE_FRAME (frame
);
1394 /* Check that arguments are integers or floats. */
1395 CHECK_NUMBER_OR_FLOAT (x
);
1396 CHECK_NUMBER_OR_FLOAT (y
);
1398 return window_from_coordinates (f
,
1399 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1400 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1401 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1402 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1406 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1407 doc
: /* Return current value of point in WINDOW.
1408 WINDOW must be a live window and defaults to the selected one.
1410 For a nonselected window, this is the value point would have if that
1411 window were selected.
1413 Note that, when WINDOW is selected, the value returned is the same as
1414 that returned by `point' for WINDOW's buffer. It would be more strictly
1415 correct to return the `top-level' value of `point', outside of any
1416 `save-excursion' forms. But that is hard to define. */)
1417 (Lisp_Object window
)
1419 register struct window
*w
= decode_live_window (window
);
1421 if (w
== XWINDOW (selected_window
))
1422 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1424 return Fmarker_position (w
->pointm
);
1427 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1428 doc
: /* Return position at which display currently starts in WINDOW.
1429 WINDOW must be a live window and defaults to the selected one.
1430 This is updated by redisplay or by calling `set-window-start'. */)
1431 (Lisp_Object window
)
1433 return Fmarker_position (decode_live_window (window
)->start
);
1436 /* This is text temporarily removed from the doc string below.
1438 This function returns nil if the position is not currently known.
1439 That happens when redisplay is preempted and doesn't finish.
1440 If in that case you want to compute where the end of the window would
1441 have been if redisplay had finished, do this:
1443 (goto-char (window-start window))
1444 (vertical-motion (1- (window-height window)) window)
1447 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1448 doc
: /* Return position at which display currently ends in WINDOW.
1449 WINDOW must be a live window and defaults to the selected one.
1450 This is updated by redisplay, when it runs to completion.
1451 Simply changing the buffer text or setting `window-start'
1452 does not update this value.
1453 Return nil if there is no recorded value. (This can happen if the
1454 last redisplay of WINDOW was preempted, and did not finish.)
1455 If UPDATE is non-nil, compute the up-to-date position
1456 if it isn't already recorded. */)
1457 (Lisp_Object window
, Lisp_Object update
)
1460 struct window
*w
= decode_live_window (window
);
1468 #if 0 /* This change broke some things. We should make it later. */
1469 /* If we don't know the end position, return nil.
1470 The user can compute it with vertical-motion if he wants to.
1471 It would be nicer to do it automatically,
1472 but that's so slow that it would probably bother people. */
1473 if (NILP (w
->window_end_valid
))
1478 && ! (! NILP (w
->window_end_valid
)
1479 && w
->last_modified
>= BUF_MODIFF (b
)
1480 && w
->last_overlay_modified
>= BUF_OVERLAY_MODIFF (b
))
1483 struct text_pos startp
;
1485 struct buffer
*old_buffer
= NULL
;
1486 void *itdata
= NULL
;
1488 /* Cannot use Fvertical_motion because that function doesn't
1489 cope with variable-height lines. */
1490 if (b
!= current_buffer
)
1492 old_buffer
= current_buffer
;
1493 set_buffer_internal (b
);
1496 /* In case W->start is out of the range, use something
1497 reasonable. This situation occurred when loading a file with
1498 `-l' containing a call to `rmail' with subsequent other
1499 commands. At the end, W->start happened to be BEG, while
1500 rmail had already narrowed the buffer. */
1501 if (XMARKER (w
->start
)->charpos
< BEGV
)
1502 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1503 else if (XMARKER (w
->start
)->charpos
> ZV
)
1504 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1506 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1508 itdata
= bidi_shelve_cache ();
1509 start_display (&it
, w
, startp
);
1510 move_it_vertically (&it
, window_box_height (w
));
1511 if (it
.current_y
< it
.last_visible_y
)
1512 move_it_past_eol (&it
);
1513 value
= make_number (IT_CHARPOS (it
));
1514 bidi_unshelve_cache (itdata
, 0);
1517 set_buffer_internal (old_buffer
);
1520 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1525 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1526 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1527 WINDOW must be a live window and defaults to the selected one.
1529 (Lisp_Object window
, Lisp_Object pos
)
1531 register struct window
*w
= decode_live_window (window
);
1533 CHECK_NUMBER_COERCE_MARKER (pos
);
1535 if (w
== XWINDOW (selected_window
))
1537 if (XBUFFER (w
->buffer
) == current_buffer
)
1541 struct buffer
*old_buffer
= current_buffer
;
1543 set_buffer_internal (XBUFFER (w
->buffer
));
1545 set_buffer_internal (old_buffer
);
1550 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1551 /* We have to make sure that redisplay updates the window to show
1552 the new value of point. */
1553 ++windows_or_buffers_changed
;
1559 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1560 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1561 WINDOW must be a live window and defaults to the selected one. Return
1562 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1563 overriding motion of point in order to display at this exact start. */)
1564 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1566 register struct window
*w
= decode_live_window (window
);
1568 CHECK_NUMBER_COERCE_MARKER (pos
);
1569 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1570 /* this is not right, but much easier than doing what is right. */
1571 w
->start_at_line_beg
= 0;
1574 w
->update_mode_line
= 1;
1575 w
->last_modified
= 0;
1576 w
->last_overlay_modified
= 0;
1577 if (!EQ (window
, selected_window
))
1578 windows_or_buffers_changed
++;
1583 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1584 Spos_visible_in_window_p
, 0, 3, 0,
1585 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1586 WINDOW must be a live window and defaults to the selected one.
1588 Return nil if that position is scrolled vertically out of view. If a
1589 character is only partially visible, nil is returned, unless the
1590 optional argument PARTIALLY is non-nil. If POS is only out of view
1591 because of horizontal scrolling, return non-nil. If POS is t, it
1592 specifies the position of the last visible glyph in WINDOW. POS
1593 defaults to point in WINDOW; WINDOW defaults to the selected window.
1595 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1596 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1597 where X and Y are the pixel coordinates relative to the top left corner
1598 of the window. The remaining elements are omitted if the character after
1599 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1600 off-window at the top and bottom of the row, ROWH is the height of the
1601 display row, and VPOS is the row number (0-based) containing POS. */)
1602 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1604 register struct window
*w
;
1605 register EMACS_INT posint
;
1606 register struct buffer
*buf
;
1607 struct text_pos top
;
1608 Lisp_Object in_window
= Qnil
;
1609 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1612 w
= decode_live_window (window
);
1613 buf
= XBUFFER (w
->buffer
);
1614 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1618 else if (!NILP (pos
))
1620 CHECK_NUMBER_COERCE_MARKER (pos
);
1621 posint
= XINT (pos
);
1623 else if (w
== XWINDOW (selected_window
))
1626 posint
= XMARKER (w
->pointm
)->charpos
;
1628 /* If position is above window start or outside buffer boundaries,
1629 or if window start is out of range, position is not visible. */
1631 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1632 && CHARPOS (top
) >= BUF_BEGV (buf
)
1633 && CHARPOS (top
) <= BUF_ZV (buf
)
1634 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1635 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1638 if (!NILP (in_window
) && !NILP (partially
))
1640 Lisp_Object part
= Qnil
;
1642 part
= list4 (make_number (rtop
), make_number (rbot
),
1643 make_number (rowh
), make_number (vpos
));
1644 in_window
= Fcons (make_number (x
),
1645 Fcons (make_number (y
), part
));
1651 DEFUN ("window-line-height", Fwindow_line_height
,
1652 Swindow_line_height
, 0, 2, 0,
1653 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1654 WINDOW must be a live window and defaults to the selected one.
1656 Return height of current line if LINE is omitted or nil. Return height of
1657 header or mode line if LINE is `header-line' or `mode-line'.
1658 Otherwise, LINE is a text line number starting from 0. A negative number
1659 counts from the end of the window.
1661 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1662 in pixels of the visible part of the line, VPOS and YPOS are the
1663 vertical position in lines and pixels of the line, relative to the top
1664 of the first text line, and OFFBOT is the number of off-window pixels at
1665 the bottom of the text line. If there are off-window pixels at the top
1666 of the (first) text line, YPOS is negative.
1668 Return nil if window display is not up-to-date. In that case, use
1669 `pos-visible-in-window-p' to obtain the information. */)
1670 (Lisp_Object line
, Lisp_Object window
)
1672 register struct window
*w
;
1673 register struct buffer
*b
;
1674 struct glyph_row
*row
, *end_row
;
1678 w
= decode_live_window (window
);
1680 if (noninteractive
|| w
->pseudo_window_p
)
1683 CHECK_BUFFER (w
->buffer
);
1684 b
= XBUFFER (w
->buffer
);
1686 /* Fail if current matrix is not up-to-date. */
1687 if (NILP (w
->window_end_valid
)
1688 || current_buffer
->clip_changed
1689 || current_buffer
->prevent_redisplay_optimizations_p
1690 || w
->last_modified
< BUF_MODIFF (b
)
1691 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1697 if (i
< 0 || i
>= w
->current_matrix
->nrows
1698 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1700 max_y
= window_text_bottom_y (w
);
1704 if (EQ (line
, Qheader_line
))
1706 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1708 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1709 if (!row
->enabled_p
)
1711 return list4 (make_number (row
->height
),
1712 make_number (0), make_number (0),
1716 if (EQ (line
, Qmode_line
))
1718 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1719 if (!row
->enabled_p
)
1721 return list4 (make_number (row
->height
),
1722 make_number (0), /* not accurate */
1723 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
1724 + window_text_bottom_y (w
)),
1728 CHECK_NUMBER (line
);
1731 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1732 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1733 max_y
= window_text_bottom_y (w
);
1736 while ((n
< 0 || i
< n
)
1737 && row
<= end_row
&& row
->enabled_p
1738 && row
->y
+ row
->height
< max_y
)
1741 if (row
> end_row
|| !row
->enabled_p
)
1753 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1754 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
1756 make_number (row
->y
),
1757 make_number (crop
));
1760 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1762 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1763 More precisely, return the value assigned by the last call of
1764 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1765 never called with WINDOW as its argument, or the value set by that
1766 function was internally reset since its last call. WINDOW must be a
1767 live window and defaults to the selected one.
1769 When a window is dedicated to its buffer, `display-buffer' will refrain
1770 from displaying another buffer in it. `get-lru-window' and
1771 `get-largest-window' treat dedicated windows specially.
1772 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1773 `kill-buffer' can delete a dedicated window and the containing frame.
1775 Functions like `set-window-buffer' may change the buffer displayed by a
1776 window, unless that window is "strongly" dedicated to its buffer, that
1777 is the value returned by `window-dedicated-p' is t. */)
1778 (Lisp_Object window
)
1780 return decode_live_window (window
)->dedicated
;
1783 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1784 Sset_window_dedicated_p
, 2, 2, 0,
1785 doc
: /* Mark WINDOW as dedicated according to FLAG.
1786 WINDOW must be a live window and defaults to the selected one. FLAG
1787 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1788 mark WINDOW as non-dedicated. Return FLAG.
1790 When a window is dedicated to its buffer, `display-buffer' will refrain
1791 from displaying another buffer in it. `get-lru-window' and
1792 `get-largest-window' treat dedicated windows specially.
1793 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1794 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1795 and the containing frame.
1797 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1798 its buffer. Functions like `set-window-buffer' may change the buffer
1799 displayed by a window, unless that window is strongly dedicated to its
1800 buffer. If and when `set-window-buffer' displays another buffer in a
1801 window, it also makes sure that the window is no more dedicated. */)
1802 (Lisp_Object window
, Lisp_Object flag
)
1804 wset_dedicated (decode_live_window (window
), flag
);
1808 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1810 doc
: /* Return buffers previously shown in WINDOW.
1811 WINDOW must be a live window and defaults to the selected one.
1813 The return value is a list of elements (BUFFER WINDOW-START POS),
1814 where BUFFER is a buffer, WINDOW-START is the start position of the
1815 window for that buffer, and POS is a window-specific point value. */)
1816 (Lisp_Object window
)
1818 return decode_live_window (window
)->prev_buffers
;
1821 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1822 Sset_window_prev_buffers
, 2, 2, 0,
1823 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1824 WINDOW must be a live window and defaults to the selected one.
1826 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1827 where BUFFER is a buffer, WINDOW-START is the start position of the
1828 window for that buffer, and POS is a window-specific point value. */)
1829 (Lisp_Object window
, Lisp_Object prev_buffers
)
1831 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1832 return prev_buffers
;
1835 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1837 doc
: /* Return list of buffers recently re-shown in WINDOW.
1838 WINDOW must be a live window and defaults to the selected one. */)
1839 (Lisp_Object window
)
1841 return decode_live_window (window
)->next_buffers
;
1844 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1845 Sset_window_next_buffers
, 2, 2, 0,
1846 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1847 WINDOW must be a live window and defaults to the selected one.
1848 NEXT-BUFFERS should be a list of buffers. */)
1849 (Lisp_Object window
, Lisp_Object next_buffers
)
1851 wset_next_buffers (decode_live_window (window
), next_buffers
);
1852 return next_buffers
;
1855 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1857 doc
: /* Return the parameters of WINDOW and their values.
1858 WINDOW must be a valid window and defaults to the selected one. The
1859 return value is a list of elements of the form (PARAMETER . VALUE). */)
1860 (Lisp_Object window
)
1862 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1865 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1867 doc
: /* Return WINDOW's value for PARAMETER.
1868 WINDOW must be a valid window and defaults to the selected one. */)
1869 (Lisp_Object window
, Lisp_Object parameter
)
1873 result
= Fassq (parameter
, decode_valid_window (window
)->window_parameters
);
1874 return CDR_SAFE (result
);
1877 DEFUN ("set-window-parameter", Fset_window_parameter
,
1878 Sset_window_parameter
, 3, 3, 0,
1879 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1880 WINDOW must be a valid window and defaults to the selected one.
1882 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1884 register struct window
*w
= decode_valid_window (window
);
1885 Lisp_Object old_alist_elt
;
1887 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1888 if (NILP (old_alist_elt
))
1889 wset_window_parameters
1890 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1892 Fsetcdr (old_alist_elt
, value
);
1896 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1898 doc
: /* Return the display-table that WINDOW is using.
1899 WINDOW must be a live window and defaults to the selected one. */)
1900 (Lisp_Object window
)
1902 return decode_live_window (window
)->display_table
;
1905 /* Get the display table for use on window W. This is either W's
1906 display table or W's buffer's display table. Ignore the specified
1907 tables if they are not valid; if no valid table is specified,
1910 struct Lisp_Char_Table
*
1911 window_display_table (struct window
*w
)
1913 struct Lisp_Char_Table
*dp
= NULL
;
1915 if (DISP_TABLE_P (w
->display_table
))
1916 dp
= XCHAR_TABLE (w
->display_table
);
1917 else if (BUFFERP (w
->buffer
))
1919 struct buffer
*b
= XBUFFER (w
->buffer
);
1921 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1922 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1923 else if (DISP_TABLE_P (Vstandard_display_table
))
1924 dp
= XCHAR_TABLE (Vstandard_display_table
);
1930 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1931 doc
: /* Set WINDOW's display-table to TABLE.
1932 WINDOW must be a live window and defaults to the selected one. */)
1933 (register Lisp_Object window
, Lisp_Object table
)
1935 wset_display_table (decode_live_window (window
), table
);
1939 /* Record info on buffer window W is displaying
1940 when it is about to cease to display that buffer. */
1942 unshow_buffer (register struct window
*w
)
1949 if (b
!= XMARKER (w
->pointm
)->buffer
)
1953 if (w
== XWINDOW (selected_window
)
1954 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1955 /* Do this except when the selected window's buffer
1956 is being removed from some other window. */
1958 /* last_window_start records the start position that this buffer
1959 had in the last window to be disconnected from it.
1960 Now that this statement is unconditional,
1961 it is possible for the buffer to be displayed in the
1962 selected window, while last_window_start reflects another
1963 window which was recently showing the same buffer.
1964 Some people might say that might be a good thing. Let's see. */
1965 b
->last_window_start
= marker_position (w
->start
);
1967 /* Point in the selected window's buffer
1968 is actually stored in that buffer, and the window's pointm isn't used.
1969 So don't clobber point in that buffer. */
1970 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1971 /* This line helps to fix Horsley's testbug.el bug. */
1972 && !(WINDOWP (BVAR (b
, last_selected_window
))
1973 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1974 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1975 temp_set_point_both (b
,
1976 clip_to_bounds (BUF_BEGV (b
),
1977 XMARKER (w
->pointm
)->charpos
,
1979 clip_to_bounds (BUF_BEGV_BYTE (b
),
1980 marker_byte_position (w
->pointm
),
1983 if (WINDOWP (BVAR (b
, last_selected_window
))
1984 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1985 bset_last_selected_window (b
, Qnil
);
1988 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1989 means change window structure only. Otherwise store geometry and
1990 other settings as well. */
1992 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1994 register Lisp_Object tem
;
1995 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1997 /* If OLD is its frame's root window, then NEW is the new
1998 root window for that frame. */
1999 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
2000 fset_root_window (XFRAME (o
->frame
), new);
2004 wset_left_col (n
, o
->left_col
);
2005 wset_top_line (n
, o
->top_line
);
2006 wset_total_cols (n
, o
->total_cols
);
2007 wset_total_lines (n
, o
->total_lines
);
2008 wset_normal_cols (n
, o
->normal_cols
);
2009 wset_normal_cols (o
, make_float (1.0));
2010 wset_normal_lines (n
, o
->normal_lines
);
2011 wset_normal_lines (o
, make_float (1.0));
2012 n
->desired_matrix
= n
->current_matrix
= 0;
2014 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
2015 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
2016 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
2017 n
->phys_cursor_type
= -1;
2018 n
->phys_cursor_width
= -1;
2019 n
->must_be_updated_p
= 0;
2020 n
->pseudo_window_p
= 0;
2021 wset_window_end_vpos (n
, make_number (0));
2022 wset_window_end_pos (n
, make_number (0));
2023 wset_window_end_valid (n
, Qnil
);
2024 n
->frozen_window_start_p
= 0;
2030 wset_prev (XWINDOW (tem
), new);
2035 wset_next (XWINDOW (tem
), new);
2038 wset_parent (n
, tem
);
2041 if (EQ (XWINDOW (tem
)->vchild
, old
))
2042 wset_vchild (XWINDOW (tem
), new);
2043 if (EQ (XWINDOW (tem
)->hchild
, old
))
2044 wset_hchild (XWINDOW (tem
), new);
2048 /* If window WINDOW and its parent window are iso-combined, merge
2049 WINDOW's children into those of its parent window and mark WINDOW as
2053 recombine_windows (Lisp_Object window
)
2055 struct window
*w
, *p
, *c
;
2056 Lisp_Object parent
, child
;
2059 w
= XWINDOW (window
);
2061 if (!NILP (parent
) && NILP (w
->combination_limit
))
2063 p
= XWINDOW (parent
);
2064 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2065 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2066 /* WINDOW and PARENT are both either a vertical or a horizontal
2069 horflag
= NILP (w
->vchild
);
2070 child
= horflag
? w
->hchild
: w
->vchild
;
2071 c
= XWINDOW (child
);
2073 /* Splice WINDOW's children into its parent's children and
2074 assign new normal sizes. */
2077 wset_hchild (p
, child
);
2079 wset_vchild (p
, child
);
2082 wset_prev (c
, w
->prev
);
2083 wset_next (XWINDOW (w
->prev
), child
);
2088 wset_parent (c
, parent
);
2091 wset_normal_cols (c
,
2092 make_float (XFLOATINT (c
->total_cols
)
2093 / XFLOATINT (p
->total_cols
)));
2095 wset_normal_lines (c
,
2096 make_float (XFLOATINT (c
->total_lines
)
2097 / XFLOATINT (p
->total_lines
)));
2101 if (!NILP (w
->next
))
2103 wset_next (c
, w
->next
);
2104 wset_prev (XWINDOW (c
->next
), child
);
2112 c
= XWINDOW (child
);
2116 /* WINDOW can be deleted now. */
2117 wset_vchild (w
, Qnil
);
2118 wset_hchild (w
, Qnil
);
2123 /* If WINDOW can be deleted, delete it. */
2125 delete_deletable_window (Lisp_Object window
)
2127 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2128 call1 (Qdelete_window
, window
);
2131 /***********************************************************************
2133 ***********************************************************************/
2135 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2136 pointer. This is a callback function for foreach_window, used in
2137 the window_list function. */
2140 add_window_to_list (struct window
*w
, void *user_data
)
2142 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2144 XSETWINDOW (window
, w
);
2145 *list
= Fcons (window
, *list
);
2150 /* Return a list of all windows, for use by next_window. If
2151 Vwindow_list is a list, return that list. Otherwise, build a new
2152 list, cache it in Vwindow_list, and return that. */
2157 if (!CONSP (Vwindow_list
))
2161 Vwindow_list
= Qnil
;
2162 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
2164 Lisp_Object args
[2];
2166 /* We are visiting windows in canonical order, and add
2167 new windows at the front of args[1], which means we
2168 have to reverse this list at the end. */
2170 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
2171 args
[0] = Vwindow_list
;
2172 args
[1] = Fnreverse (args
[1]);
2173 Vwindow_list
= Fnconc (2, args
);
2177 return Vwindow_list
;
2181 /* Value is non-zero if WINDOW satisfies the constraints given by
2182 OWINDOW, MINIBUF and ALL_FRAMES.
2184 MINIBUF t means WINDOW may be minibuffer windows.
2185 `lambda' means WINDOW may not be a minibuffer window.
2186 a window means a specific minibuffer window
2188 ALL_FRAMES t means search all frames,
2189 nil means search just current frame,
2190 `visible' means search just visible frames on the
2192 0 means search visible and iconified frames on the
2194 a window means search the frame that window belongs to,
2195 a frame means consider windows on that frame, only. */
2198 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2200 struct window
*w
= XWINDOW (window
);
2201 struct frame
*f
= XFRAME (w
->frame
);
2202 int candidate_p
= 1;
2204 if (!BUFFERP (w
->buffer
))
2206 else if (MINI_WINDOW_P (w
)
2207 && (EQ (minibuf
, Qlambda
)
2208 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2210 /* If MINIBUF is `lambda' don't consider any mini-windows.
2211 If it is a window, consider only that one. */
2214 else if (EQ (all_frames
, Qt
))
2216 else if (NILP (all_frames
))
2218 eassert (WINDOWP (owindow
));
2219 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2221 else if (EQ (all_frames
, Qvisible
))
2223 FRAME_SAMPLE_VISIBILITY (f
);
2224 candidate_p
= FRAME_VISIBLE_P (f
)
2225 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2226 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2229 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2231 FRAME_SAMPLE_VISIBILITY (f
);
2232 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2233 #ifdef HAVE_X_WINDOWS
2234 /* Yuck!! If we've just created the frame and the
2235 window-manager requested the user to place it
2236 manually, the window may still not be considered
2237 `visible'. I'd argue it should be at least
2238 something like `iconified', but don't know how to do
2240 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2241 && !f
->output_data
.x
->has_been_visible
)
2244 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2245 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2247 else if (WINDOWP (all_frames
))
2248 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2249 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2250 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2251 else if (FRAMEP (all_frames
))
2252 candidate_p
= EQ (all_frames
, w
->frame
);
2258 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2259 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2260 MINIBUF, and ALL_FRAMES. */
2263 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2266 *window
= selected_window
;
2268 CHECK_LIVE_WINDOW (*window
);
2270 /* MINIBUF nil may or may not include minibuffers. Decide if it
2272 if (NILP (*minibuf
))
2273 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2274 else if (!EQ (*minibuf
, Qt
))
2277 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2278 => count none of them, or a specific minibuffer window (the
2279 active one) to count. */
2281 /* ALL_FRAMES nil doesn't specify which frames to include. */
2282 if (NILP (*all_frames
))
2284 = (!EQ (*minibuf
, Qlambda
)
2285 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
2287 else if (EQ (*all_frames
, Qvisible
))
2289 else if (EQ (*all_frames
, make_number (0)))
2291 else if (FRAMEP (*all_frames
))
2293 else if (!EQ (*all_frames
, Qt
))
2298 /* Return the next or previous window of WINDOW in cyclic ordering
2299 of windows. NEXT_P non-zero means return the next window. See the
2300 documentation string of next-window for the meaning of MINIBUF and
2304 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2306 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2308 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2309 return the first window on the frame. */
2310 if (FRAMEP (all_frames
)
2311 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2312 return Fframe_first_window (all_frames
);
2318 /* Find WINDOW in the list of all windows. */
2319 list
= Fmemq (window
, window_list ());
2321 /* Scan forward from WINDOW to the end of the window list. */
2323 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2324 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2327 /* Scan from the start of the window list up to WINDOW. */
2329 for (list
= Vwindow_list
;
2330 CONSP (list
) && !EQ (XCAR (list
), window
);
2332 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2336 window
= XCAR (list
);
2340 Lisp_Object candidate
, list
;
2342 /* Scan through the list of windows for candidates. If there are
2343 candidate windows in front of WINDOW, the last one of these
2344 is the one we want. If there are candidates following WINDOW
2345 in the list, again the last one of these is the one we want. */
2347 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2349 if (EQ (XCAR (list
), window
))
2351 if (WINDOWP (candidate
))
2354 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2356 candidate
= XCAR (list
);
2359 if (WINDOWP (candidate
))
2367 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2368 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2369 WINDOW must be a live window and defaults to the selected one. The
2370 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2373 MINIBUF nil or omitted means consider the minibuffer window only if the
2374 minibuffer is active. MINIBUF t means consider the minibuffer window
2375 even if the minibuffer is not active. Any other value means do not
2376 consider the minibuffer window even if the minibuffer is active.
2378 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2379 plus the minibuffer window if specified by the MINIBUF argument. If the
2380 minibuffer counts, consider all windows on all frames that share that
2381 minibuffer too. The following non-nil values of ALL-FRAMES have special
2384 - t means consider all windows on all existing frames.
2386 - `visible' means consider all windows on all visible frames.
2388 - 0 (the number zero) means consider all windows on all visible and
2391 - A frame means consider all windows on that frame only.
2393 Anything else means consider all windows on WINDOW's frame and no
2396 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2397 `next-window' to iterate through the entire cycle of acceptable
2398 windows, eventually ending up back at the window you started with.
2399 `previous-window' traverses the same cycle, in the reverse order. */)
2400 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2402 return next_window (window
, minibuf
, all_frames
, 1);
2406 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2407 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2408 WINDOW must be a live window and defaults to the selected one. The
2409 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2412 MINIBUF nil or omitted means consider the minibuffer window only if the
2413 minibuffer is active. MINIBUF t means consider the minibuffer window
2414 even if the minibuffer is not active. Any other value means do not
2415 consider the minibuffer window even if the minibuffer is active.
2417 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2418 plus the minibuffer window if specified by the MINIBUF argument. If the
2419 minibuffer counts, consider all windows on all frames that share that
2420 minibuffer too. The following non-nil values of ALL-FRAMES have special
2423 - t means consider all windows on all existing frames.
2425 - `visible' means consider all windows on all visible frames.
2427 - 0 (the number zero) means consider all windows on all visible and
2430 - A frame means consider all windows on that frame only.
2432 Anything else means consider all windows on WINDOW's frame and no
2435 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2436 use `previous-window' to iterate through the entire cycle of
2437 acceptable windows, eventually ending up back at the window you
2438 started with. `next-window' traverses the same cycle, in the
2440 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2442 return next_window (window
, minibuf
, all_frames
, 0);
2446 /* Return a list of windows in cyclic ordering. Arguments are like
2447 for `next-window'. */
2450 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2452 Lisp_Object tail
, list
, rest
;
2454 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2457 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2458 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2459 list
= Fcons (XCAR (tail
), list
);
2461 /* Rotate the list to start with WINDOW. */
2462 list
= Fnreverse (list
);
2463 rest
= Fmemq (window
, list
);
2464 if (!NILP (rest
) && !EQ (rest
, list
))
2466 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2468 XSETCDR (tail
, Qnil
);
2469 list
= nconc2 (rest
, list
);
2475 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2476 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2477 FRAME nil or omitted means use the selected frame.
2478 WINDOW nil or omitted means use the window selected within FRAME.
2479 MINIBUF t means include the minibuffer window, even if it isn't active.
2480 MINIBUF nil or omitted means include the minibuffer window only
2482 MINIBUF neither nil nor t means never include the minibuffer window. */)
2483 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2486 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2487 CHECK_WINDOW (window
);
2489 frame
= selected_frame
;
2491 if (!EQ (frame
, XWINDOW (window
)->frame
))
2492 error ("Window is on a different frame");
2494 return window_list_1 (window
, minibuf
, frame
);
2498 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2499 doc
: /* Return a list of all live windows.
2500 WINDOW specifies the first window to list and defaults to the selected
2503 Optional argument MINIBUF nil or omitted means consider the minibuffer
2504 window only if the minibuffer is active. MINIBUF t means consider the
2505 minibuffer window even if the minibuffer is not active. Any other value
2506 means do not consider the minibuffer window even if the minibuffer is
2509 Optional argument ALL-FRAMES nil or omitted means consider all windows
2510 on WINDOW's frame, plus the minibuffer window if specified by the
2511 MINIBUF argument. If the minibuffer counts, consider all windows on all
2512 frames that share that minibuffer too. The following non-nil values of
2513 ALL-FRAMES have special meanings:
2515 - t means consider all windows on all existing frames.
2517 - `visible' means consider all windows on all visible frames.
2519 - 0 (the number zero) means consider all windows on all visible and
2522 - A frame means consider all windows on that frame only.
2524 Anything else means consider all windows on WINDOW's frame and no
2527 If WINDOW is not on the list of windows returned, some other window will
2528 be listed first but no error is signaled. */)
2529 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2531 return window_list_1 (window
, minibuf
, all_frames
);
2534 /* Look at all windows, performing an operation specified by TYPE
2536 If FRAMES is Qt, look at all frames;
2537 Qnil, look at just the selected frame;
2538 Qvisible, look at visible frames;
2539 a frame, just look at windows on that frame.
2540 If MINI is non-zero, perform the operation on minibuffer windows too. */
2545 GET_BUFFER_WINDOW
, /* Arg is buffer */
2546 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2547 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2552 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2554 Lisp_Object window
, windows
, best_window
, frame_arg
;
2555 int frame_best_window_flag
= 0;
2557 struct gcpro gcpro1
;
2559 /* If we're only looping through windows on a particular frame,
2560 frame points to that frame. If we're looping through windows
2561 on all frames, frame is 0. */
2562 if (FRAMEP (frames
))
2563 f
= XFRAME (frames
);
2564 else if (NILP (frames
))
2565 f
= SELECTED_FRAME ();
2570 frame_arg
= Qlambda
;
2571 else if (EQ (frames
, make_number (0)))
2573 else if (EQ (frames
, Qvisible
))
2578 /* frame_arg is Qlambda to stick to one frame,
2579 Qvisible to consider all visible frames,
2582 /* Pick a window to start with. */
2586 window
= FRAME_SELECTED_WINDOW (f
);
2588 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2590 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2594 for (; CONSP (windows
); windows
= XCDR (windows
))
2598 window
= XCAR (windows
);
2599 w
= XWINDOW (window
);
2601 /* Note that we do not pay attention here to whether the frame
2602 is visible, since Fwindow_list skips non-visible frames if
2603 that is desired, under the control of frame_arg. */
2604 if (!MINI_WINDOW_P (w
)
2605 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2606 consider all windows. */
2607 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2608 || (mini
&& minibuf_level
> 0))
2611 case GET_BUFFER_WINDOW
:
2612 if (EQ (w
->buffer
, obj
)
2613 /* Don't find any minibuffer window except the one that
2614 is currently in use. */
2615 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2617 if (EQ (window
, selected_window
))
2618 /* Preferably return the selected window. */
2619 RETURN_UNGCPRO (window
);
2620 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2621 && !frame_best_window_flag
)
2622 /* Prefer windows on the current frame (but don't
2623 choose another one if we have one already). */
2625 best_window
= window
;
2626 frame_best_window_flag
= 1;
2628 else if (NILP (best_window
))
2629 best_window
= window
;
2633 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2634 /* We could simply check whether the buffer shown by window
2635 is live, and show another buffer in case it isn't. */
2636 if (EQ (w
->buffer
, obj
))
2638 /* Undedicate WINDOW. */
2639 wset_dedicated (w
, Qnil
);
2640 /* Make WINDOW show the buffer returned by
2641 other_buffer_safely, don't run any hooks. */
2643 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2644 /* If WINDOW is the selected window, make its buffer
2645 current. But do so only if the window shows the
2646 current buffer (Bug#6454). */
2647 if (EQ (window
, selected_window
)
2648 && XBUFFER (w
->buffer
) == current_buffer
)
2649 Fset_buffer (w
->buffer
);
2653 case REDISPLAY_BUFFER_WINDOWS
:
2654 if (EQ (w
->buffer
, obj
))
2656 mark_window_display_accurate (window
, 0);
2657 w
->update_mode_line
= 1;
2658 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2659 ++update_mode_lines
;
2660 best_window
= window
;
2664 /* Check for a window that has a killed buffer. */
2665 case CHECK_ALL_WINDOWS
:
2666 if (! NILP (w
->buffer
)
2667 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2671 case WINDOW_LOOP_UNUSED
:
2680 /* Used for debugging. Abort if any window has a dead buffer. */
2682 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2684 check_all_windows (void)
2686 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2689 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2690 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2691 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2694 The optional argument ALL-FRAMES specifies the frames to consider:
2696 - t means consider all windows on all existing frames.
2698 - `visible' means consider all windows on all visible frames.
2700 - 0 (the number zero) means consider all windows on all visible
2701 and iconified frames.
2703 - A frame means consider all windows on that frame only.
2705 Any other value of ALL-FRAMES means consider all windows on the
2706 selected frame and no others. */)
2707 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2711 if (NILP (buffer_or_name
))
2712 buffer
= Fcurrent_buffer ();
2714 buffer
= Fget_buffer (buffer_or_name
);
2716 if (BUFFERP (buffer
))
2717 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2723 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2725 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2729 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2730 Sdelete_other_windows_internal
, 0, 2, "",
2731 doc
: /* Make WINDOW fill its frame.
2732 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2733 and defaults to the selected one.
2735 Optional argument ROOT, if non-nil, must specify an internal window such
2736 that WINDOW is in its window subtree. If this is the case, replace ROOT
2737 by WINDOW and leave alone any windows not part of ROOT's subtree.
2739 When WINDOW is live try to reduce display jumps by keeping the text
2740 previously visible in WINDOW in the same place on the frame. Doing this
2741 depends on the value of (window-start WINDOW), so if calling this
2742 function in a program gives strange scrolling, make sure the
2743 window-start value is reasonable when this function is called. */)
2744 (Lisp_Object window
, Lisp_Object root
)
2746 struct window
*w
, *r
, *s
;
2748 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2749 ptrdiff_t startpos
IF_LINT (= 0);
2750 int top
IF_LINT (= 0), new_top
, resize_failed
;
2752 w
= decode_valid_window (window
);
2753 XSETWINDOW (window
, w
);
2754 f
= XFRAME (w
->frame
);
2757 /* ROOT is the frame's root window. */
2759 root
= FRAME_ROOT_WINDOW (f
);
2763 /* ROOT must be an ancestor of WINDOW. */
2765 r
= decode_valid_window (root
);
2766 pwindow
= XWINDOW (window
)->parent
;
2767 while (!NILP (pwindow
))
2768 if (EQ (pwindow
, root
))
2771 pwindow
= XWINDOW (pwindow
)->parent
;
2772 if (!EQ (pwindow
, root
))
2773 error ("Specified root is not an ancestor of specified window");
2776 if (EQ (window
, root
))
2779 /* I don't understand the "top > 0" part below. If we deal with a
2780 standalone minibuffer it would have been caught by the preceding
2782 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2783 error ("Can't expand minibuffer to full frame");
2785 if (!NILP (w
->buffer
))
2787 startpos
= marker_position (w
->start
);
2788 top
= WINDOW_TOP_EDGE_LINE (w
)
2789 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2790 /* Make sure WINDOW is the frame's selected window. */
2791 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2793 if (EQ (selected_frame
, w
->frame
))
2794 Fselect_window (window
, Qnil
);
2796 fset_selected_window (f
, window
);
2801 /* See if the frame's selected window is a part of the window
2802 subtree rooted at WINDOW, by finding all the selected window's
2803 parents and comparing each one with WINDOW. If it isn't we
2804 need a new selected window for this frame. */
2805 swindow
= FRAME_SELECTED_WINDOW (f
);
2809 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2810 pwindow
= XWINDOW (pwindow
)->parent
;
2812 if (EQ (window
, pwindow
))
2813 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2814 as the new selected window. */
2817 /* Else try the previous window of SWINDOW. */
2818 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2821 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2823 if (EQ (selected_frame
, w
->frame
))
2824 Fselect_window (swindow
, Qnil
);
2826 fset_selected_window (f
, swindow
);
2831 if (!FRAME_INITIAL_P (f
))
2833 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2835 /* We are going to free the glyph matrices of WINDOW, and with
2836 that we might lose any information about glyph rows that have
2837 some of their glyphs highlighted in mouse face. (These rows
2838 are marked with a non-zero mouse_face_p flag.) If WINDOW
2839 indeed has some glyphs highlighted in mouse face, signal to
2840 frame's up-to-date hook that mouse highlight was overwritten,
2841 so that it will arrange for redisplaying the highlight. */
2842 if (EQ (hlinfo
->mouse_face_window
, window
))
2844 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2845 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2846 hlinfo
->mouse_face_window
= Qnil
;
2849 free_window_matrices (r
);
2851 windows_or_buffers_changed
++;
2852 Vwindow_list
= Qnil
;
2853 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2856 if (NILP (w
->buffer
))
2858 /* Resize child windows vertically. */
2859 XSETINT (delta
, XINT (r
->total_lines
)
2860 - XINT (w
->total_lines
));
2861 wset_top_line (w
, r
->top_line
);
2862 resize_root_window (window
, delta
, Qnil
, Qnil
);
2863 if (window_resize_check (w
, 0))
2864 window_resize_apply (w
, 0);
2867 resize_root_window (window
, delta
, Qnil
, Qt
);
2868 if (window_resize_check (w
, 0))
2869 window_resize_apply (w
, 0);
2874 /* Resize child windows horizontally. */
2877 wset_left_col (w
, r
->left_col
);
2879 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2880 wset_left_col (w
, r
->left_col
);
2881 resize_root_window (window
, delta
, Qt
, Qnil
);
2882 if (window_resize_check (w
, 1))
2883 window_resize_apply (w
, 1);
2886 resize_root_window (window
, delta
, Qt
, Qt
);
2887 if (window_resize_check (w
, 1))
2888 window_resize_apply (w
, 1);
2895 /* Play safe, if we still can ... */
2898 w
= XWINDOW (window
);
2902 /* Cleanly unlink WINDOW from window-tree. */
2903 if (!NILP (w
->prev
))
2904 /* Get SIBLING above (on the left of) WINDOW. */
2907 s
= XWINDOW (sibling
);
2908 wset_next (s
, w
->next
);
2909 if (!NILP (s
->next
))
2910 wset_prev (XWINDOW (s
->next
), sibling
);
2913 /* Get SIBLING below (on the right of) WINDOW. */
2916 s
= XWINDOW (sibling
);
2917 wset_prev (s
, Qnil
);
2918 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2919 wset_vchild (XWINDOW (w
->parent
), sibling
);
2921 wset_hchild (XWINDOW (w
->parent
), sibling
);
2924 /* Delete ROOT and all child windows of ROOT. */
2925 if (!NILP (r
->vchild
))
2927 delete_all_child_windows (r
->vchild
);
2928 wset_vchild (r
, Qnil
);
2930 else if (!NILP (r
->hchild
))
2932 delete_all_child_windows (r
->hchild
);
2933 wset_hchild (r
, Qnil
);
2936 replace_window (root
, window
, 1);
2938 /* This must become SWINDOW anyway ....... */
2939 if (!NILP (w
->buffer
) && !resize_failed
)
2941 /* Try to minimize scrolling, by setting the window start to the
2942 point will cause the text at the old window start to be at the
2943 same place on the frame. But don't try to do this if the
2944 window start is outside the visible portion (as might happen
2945 when the display is not current, due to typeahead). */
2946 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2948 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2949 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2951 struct position pos
;
2952 struct buffer
*obuf
= current_buffer
;
2954 Fset_buffer (w
->buffer
);
2955 /* This computation used to temporarily move point, but that
2956 can have unwanted side effects due to text properties. */
2957 pos
= *vmotion (startpos
, -top
, w
);
2959 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2960 wset_window_end_valid (w
, Qnil
);
2961 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2962 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2963 /* We need to do this, so that the window-scroll-functions
2965 w
->optional_new_start
= 1;
2967 set_buffer_internal (obuf
);
2974 run_window_configuration_change_hook (f
);
2981 replace_buffer_in_windows (Lisp_Object buffer
)
2983 call1 (Qreplace_buffer_in_windows
, buffer
);
2987 /* Safely replace BUFFER with some other buffer in all windows of all
2988 frames, even those on other keyboards. */
2991 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2993 Lisp_Object tail
, frame
;
2995 /* A single call to window_loop won't do the job because it only
2996 considers frames on the current keyboard. So loop manually over
2997 frames, and handle each one. */
2998 FOR_EACH_FRAME (tail
, frame
)
2999 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
3002 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
3003 minimum allowable size. */
3006 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
3008 /* For height, we have to see:
3009 how many windows the frame has at minimum (one or two),
3010 and whether it has a menu bar or other special stuff at the top. */
3012 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
3013 ? MIN_SAFE_WINDOW_HEIGHT
3014 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
3016 if (FRAME_TOP_MARGIN (frame
) > 0)
3017 min_height
+= FRAME_TOP_MARGIN (frame
);
3019 if (*rows
< min_height
)
3021 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
3022 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3025 /* Adjust the margins of window W if text area is too small.
3026 Return 1 if window width is ok after adjustment; 0 if window
3027 is still too narrow. */
3030 adjust_window_margins (struct window
*w
)
3032 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3033 - WINDOW_FRINGE_COLS (w
)
3034 - WINDOW_SCROLL_BAR_COLS (w
));
3035 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3036 + WINDOW_RIGHT_MARGIN_COLS (w
));
3038 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3041 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3044 /* Window's text area is too narrow, but reducing the window
3045 margins will fix that. */
3046 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3047 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3049 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3051 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3052 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3055 wset_right_margin_cols (w
, make_number (margin_cols
));
3058 wset_left_margin_cols (w
, make_number (margin_cols
));
3062 /* The following three routines are needed for running a window's
3063 configuration change hook. */
3065 run_funs (Lisp_Object funs
)
3067 for (; CONSP (funs
); funs
= XCDR (funs
))
3068 if (!EQ (XCAR (funs
), Qt
))
3069 call0 (XCAR (funs
));
3073 select_window_norecord (Lisp_Object window
)
3075 return WINDOW_LIVE_P (window
)
3076 ? Fselect_window (window
, Qt
) : selected_window
;
3080 select_frame_norecord (Lisp_Object frame
)
3082 return FRAME_LIVE_P (XFRAME (frame
))
3083 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3087 run_window_configuration_change_hook (struct frame
*f
)
3089 ptrdiff_t count
= SPECPDL_INDEX ();
3090 Lisp_Object frame
, global_wcch
3091 = Fdefault_value (Qwindow_configuration_change_hook
);
3092 XSETFRAME (frame
, f
);
3094 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3097 /* Use the right buffer. Matters when running the local hooks. */
3098 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3100 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3101 Fset_buffer (Fwindow_buffer (Qnil
));
3104 if (SELECTED_FRAME () != f
)
3106 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3107 select_frame_norecord (frame
);
3110 /* Look for buffer-local values. */
3112 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3113 for (; CONSP (windows
); windows
= XCDR (windows
))
3115 Lisp_Object window
= XCAR (windows
);
3116 Lisp_Object buffer
= Fwindow_buffer (window
);
3117 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3120 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3121 record_unwind_protect (select_window_norecord
, Fselected_window ());
3122 select_window_norecord (window
);
3123 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3125 unbind_to (inner_count
, Qnil
);
3130 run_funs (global_wcch
);
3131 unbind_to (count
, Qnil
);
3134 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3135 Srun_window_configuration_change_hook
, 1, 1, 0,
3136 doc
: /* Run `window-configuration-change-hook' for FRAME. */)
3139 CHECK_LIVE_FRAME (frame
);
3140 run_window_configuration_change_hook (XFRAME (frame
));
3144 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3145 means it's allowed to run hooks. See make_frame for a case where
3146 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3147 margins, fringes, and scroll-bar settings of the window are not
3148 reset from the buffer's local settings. */
3151 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3153 struct window
*w
= XWINDOW (window
);
3154 struct buffer
*b
= XBUFFER (buffer
);
3155 ptrdiff_t count
= SPECPDL_INDEX ();
3156 int samebuf
= EQ (buffer
, w
->buffer
);
3158 wset_buffer (w
, buffer
);
3160 if (EQ (window
, selected_window
))
3161 bset_last_selected_window (b
, window
);
3163 /* Let redisplay errors through. */
3164 b
->display_error_modiff
= 0;
3166 /* Update time stamps of buffer display. */
3167 if (INTEGERP (BVAR (b
, display_count
)))
3168 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3169 bset_display_time (b
, Fcurrent_time ());
3171 wset_window_end_pos (w
, make_number (0));
3172 wset_window_end_vpos (w
, make_number (0));
3173 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3174 wset_window_end_valid (w
, Qnil
);
3175 if (!(keep_margins_p
&& samebuf
))
3176 { /* If we're not actually changing the buffer, don't reset hscroll and
3177 vscroll. This case happens for example when called from
3178 change_frame_size_1, where we use a dummy call to
3179 Fset_window_buffer on the frame's selected window (and no other)
3180 just in order to run window-configuration-change-hook.
3181 Resetting hscroll and vscroll here is problematic for things like
3182 image-mode and doc-view-mode since it resets the image's position
3183 whenever we resize the frame. */
3184 w
->hscroll
= w
->min_hscroll
= 0;
3186 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3187 set_marker_restricted (w
->start
,
3188 make_number (b
->last_window_start
),
3190 w
->start_at_line_beg
= 0;
3192 w
->last_modified
= 0;
3193 w
->last_overlay_modified
= 0;
3195 /* Maybe we could move this into the `if' but it's not obviously safe and
3196 I doubt it's worth the trouble. */
3197 windows_or_buffers_changed
++;
3199 /* We must select BUFFER for running the window-scroll-functions. */
3200 /* We can't check ! NILP (Vwindow_scroll_functions) here
3201 because that might itself be a local variable. */
3202 if (window_initialized
)
3204 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3205 Fset_buffer (buffer
);
3208 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3210 if (!keep_margins_p
)
3212 /* Set left and right marginal area width etc. from buffer. */
3214 /* This may call adjust_window_margins three times, so
3215 temporarily disable window margins. */
3216 Lisp_Object save_left
= w
->left_margin_cols
;
3217 Lisp_Object save_right
= w
->right_margin_cols
;
3219 wset_left_margin_cols (w
, Qnil
);
3220 wset_right_margin_cols (w
, Qnil
);
3222 Fset_window_fringes (window
,
3223 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3224 BVAR (b
, fringes_outside_margins
));
3226 Fset_window_scroll_bars (window
,
3227 BVAR (b
, scroll_bar_width
),
3228 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3230 wset_left_margin_cols (w
, save_left
);
3231 wset_right_margin_cols (w
, save_right
);
3233 Fset_window_margins (window
,
3234 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3239 if (! NILP (Vwindow_scroll_functions
))
3240 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3241 Fmarker_position (w
->start
));
3242 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3245 unbind_to (count
, Qnil
);
3248 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3249 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3250 WINDOW must be a live window and defaults to the selected one.
3251 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3253 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3254 display margins, fringe widths, and scroll bar settings are preserved;
3255 the default is to reset these from the local settings for BUFFER-OR-NAME
3256 or the frame defaults. Return nil.
3258 This function throws an error when WINDOW is strongly dedicated to its
3259 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3260 already display BUFFER-OR-NAME.
3262 This function runs `window-scroll-functions' before running
3263 `window-configuration-change-hook'. */)
3264 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3266 register Lisp_Object tem
, buffer
;
3267 register struct window
*w
= decode_live_window (window
);
3269 XSETWINDOW (window
, w
);
3270 buffer
= Fget_buffer (buffer_or_name
);
3271 CHECK_BUFFER (buffer
);
3272 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3273 error ("Attempt to display deleted buffer");
3277 error ("Window is deleted");
3278 else if (!EQ (tem
, Qt
))
3279 /* w->buffer is t when the window is first being set up. */
3281 if (!EQ (tem
, buffer
))
3283 if (EQ (w
->dedicated
, Qt
))
3284 /* WINDOW is strongly dedicated to its buffer, signal an
3286 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3288 /* WINDOW is weakly dedicated to its buffer, reset
3290 wset_dedicated (w
, Qnil
);
3292 call1 (Qrecord_window_buffer
, window
);
3298 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3304 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3306 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3309 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3311 doc
: /* Force all windows to be updated on next redisplay.
3312 If optional arg OBJECT is a window, force redisplay of that window only.
3313 If OBJECT is a buffer or buffer name, force redisplay of all windows
3314 displaying that buffer. */)
3315 (Lisp_Object object
)
3319 windows_or_buffers_changed
++;
3320 update_mode_lines
++;
3324 if (WINDOWP (object
))
3326 struct window
*w
= XWINDOW (object
);
3327 mark_window_display_accurate (object
, 0);
3328 w
->update_mode_line
= 1;
3329 if (BUFFERP (w
->buffer
))
3330 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3331 ++update_mode_lines
;
3335 if (STRINGP (object
))
3336 object
= Fget_buffer (object
);
3337 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3339 /* Walk all windows looking for buffer, and force update
3340 of each of those windows. */
3342 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3343 return NILP (object
) ? Qnil
: Qt
;
3346 /* If nothing suitable was found, just return.
3347 We could signal an error, but this feature will typically be used
3348 asynchronously in timers or process sentinels, so we don't. */
3354 temp_output_buffer_show (register Lisp_Object buf
)
3356 register struct buffer
*old
= current_buffer
;
3357 register Lisp_Object window
;
3358 register struct window
*w
;
3360 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3363 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3367 set_buffer_internal (old
);
3369 if (!NILP (Vtemp_buffer_show_function
))
3370 call1 (Vtemp_buffer_show_function
, buf
);
3373 window
= display_buffer (buf
, Qnil
, Qnil
);
3375 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3376 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3377 Vminibuf_scroll_window
= window
;
3378 w
= XWINDOW (window
);
3381 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3382 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3384 /* Run temp-buffer-show-hook, with the chosen window selected
3385 and its buffer current. */
3387 ptrdiff_t count
= SPECPDL_INDEX ();
3388 Lisp_Object prev_window
, prev_buffer
;
3389 prev_window
= selected_window
;
3390 XSETBUFFER (prev_buffer
, old
);
3392 /* Select the window that was chosen, for running the hook.
3393 Note: Both Fselect_window and select_window_norecord may
3394 set-buffer to the buffer displayed in the window,
3395 so we need to save the current buffer. --stef */
3396 record_unwind_protect (Fset_buffer
, prev_buffer
);
3397 record_unwind_protect (select_window_norecord
, prev_window
);
3398 Fselect_window (window
, Qt
);
3399 Fset_buffer (w
->buffer
);
3400 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3401 unbind_to (count
, Qnil
);
3406 DEFUN ("internal-temp-output-buffer-show",
3407 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3409 doc
: /* Internal function for `with-output-to-temp-buffer'. */)
3412 temp_output_buffer_show (buf
);
3416 /* Make new window, have it replace WINDOW in window-tree, and make
3417 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3418 horizontal child). */
3420 make_parent_window (Lisp_Object window
, int horflag
)
3423 register struct window
*o
, *p
;
3425 o
= XWINDOW (window
);
3426 p
= allocate_window ();
3427 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3428 (char *) o
+ sizeof (struct vectorlike_header
),
3429 word_size
* VECSIZE (struct window
));
3430 XSETWINDOW (parent
, p
);
3432 p
->sequence_number
= ++sequence_number
;
3434 replace_window (window
, parent
, 1);
3436 wset_next (o
, Qnil
);
3437 wset_prev (o
, Qnil
);
3438 wset_parent (o
, parent
);
3440 wset_hchild (p
, horflag
? window
: Qnil
);
3441 wset_vchild (p
, horflag
? Qnil
: window
);
3442 wset_start (p
, Qnil
);
3443 wset_pointm (p
, Qnil
);
3444 wset_buffer (p
, Qnil
);
3445 wset_combination_limit (p
, Qnil
);
3446 wset_window_parameters (p
, Qnil
);
3449 /* Make new window from scratch. */
3454 register struct window
*w
;
3456 w
= allocate_window ();
3457 /* Initialize Lisp data. Note that allocate_window initializes all
3458 Lisp data to nil, so do it only for slots which should not be nil. */
3459 wset_left_col (w
, make_number (0));
3460 wset_top_line (w
, make_number (0));
3461 wset_total_lines (w
, make_number (0));
3462 wset_total_cols (w
, make_number (0));
3463 wset_normal_lines (w
, make_float (1.0));
3464 wset_normal_cols (w
, make_float (1.0));
3465 wset_new_total (w
, make_number (0));
3466 wset_new_normal (w
, make_number (0));
3467 wset_start (w
, Fmake_marker ());
3468 wset_pointm (w
, Fmake_marker ());
3469 wset_vertical_scroll_bar_type (w
, Qt
);
3470 wset_window_end_pos (w
, make_number (0));
3471 wset_window_end_vpos (w
, make_number (0));
3473 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3474 non-Lisp data, so do it only for slots which should not be zero. */
3475 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3476 w
->phys_cursor_type
= -1;
3477 w
->phys_cursor_width
= -1;
3478 w
->sequence_number
= ++sequence_number
;
3480 /* Reset window_list. */
3481 Vwindow_list
= Qnil
;
3482 /* Return window. */
3483 XSETWINDOW (window
, w
);
3487 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3488 doc
: /* Set new total size of WINDOW to SIZE.
3489 WINDOW must be a valid window and defaults to the selected one.
3492 Optional argument ADD non-nil means add SIZE to the new total size of
3493 WINDOW and return the sum.
3495 Note: This function does not operate on any child windows of WINDOW. */)
3496 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3498 struct window
*w
= decode_valid_window (window
);
3500 CHECK_NUMBER (size
);
3502 wset_new_total (w
, size
);
3504 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3506 return w
->new_total
;
3509 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3510 doc
: /* Set new normal size of WINDOW to SIZE.
3511 WINDOW must be a valid window and defaults to the selected one.
3514 Note: This function does not operate on any child windows of WINDOW. */)
3515 (Lisp_Object window
, Lisp_Object size
)
3517 wset_new_normal (decode_valid_window (window
), size
);
3521 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3522 non-zero) to w->new_total would result in correct heights (widths)
3523 for window W and recursively all child windows of W.
3525 Note: This function does not check any of `window-fixed-size-p',
3526 `window-min-height' or `window-min-width'. It does check that window
3527 sizes do not drop below one line (two columns). */
3529 window_resize_check (struct window
*w
, int horflag
)
3533 if (!NILP (w
->vchild
))
3534 /* W is a vertical combination. */
3536 c
= XWINDOW (w
->vchild
);
3538 /* All child windows of W must have the same width as W. */
3542 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3543 || !window_resize_check (c
, horflag
))
3545 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3550 /* The sum of the heights of the child windows of W must equal
3553 int sum_of_sizes
= 0;
3556 if (!window_resize_check (c
, horflag
))
3558 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3559 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3561 return (sum_of_sizes
== XINT (w
->new_total
));
3564 else if (!NILP (w
->hchild
))
3565 /* W is a horizontal combination. */
3567 c
= XWINDOW (w
->hchild
);
3569 /* The sum of the widths of the child windows of W must equal W's
3572 int sum_of_sizes
= 0;
3575 if (!window_resize_check (c
, horflag
))
3577 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3578 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3580 return (sum_of_sizes
== XINT (w
->new_total
));
3583 /* All child windows of W must have the same height as W. */
3587 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3588 || !window_resize_check (c
, horflag
))
3590 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3596 /* A leaf window. Make sure it's not too small. The following
3597 hardcodes the values of `window-safe-min-width' (2) and
3598 `window-safe-min-height' (1) which are defined in window.el. */
3599 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3602 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3603 w->new_total for window W and recursively all child windows of W.
3604 Also calculate and assign the new vertical (horizontal) start
3605 positions of each of these windows.
3607 This function does not perform any error checks. Make sure you have
3608 run window_resize_check on W before applying this function. */
3610 window_resize_apply (struct window
*w
, int horflag
)
3615 /* Note: Assigning new_normal requires that the new total size of the
3616 parent window has been set *before*. */
3619 wset_total_cols (w
, w
->new_total
);
3620 if (NUMBERP (w
->new_normal
))
3621 wset_normal_cols (w
, w
->new_normal
);
3623 pos
= XINT (w
->left_col
);
3627 wset_total_lines (w
, w
->new_total
);
3628 if (NUMBERP (w
->new_normal
))
3629 wset_normal_lines (w
, w
->new_normal
);
3631 pos
= XINT (w
->top_line
);
3634 if (!NILP (w
->vchild
))
3635 /* W is a vertical combination. */
3637 c
= XWINDOW (w
->vchild
);
3641 wset_left_col (c
, make_number (pos
));
3643 wset_top_line (c
, make_number (pos
));
3644 window_resize_apply (c
, horflag
);
3646 pos
= pos
+ XINT (c
->total_lines
);
3647 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3650 else if (!NILP (w
->hchild
))
3651 /* W is a horizontal combination. */
3653 c
= XWINDOW (w
->hchild
);
3657 wset_left_col (c
, make_number (pos
));
3659 wset_top_line (c
, make_number (pos
));
3660 window_resize_apply (c
, horflag
);
3662 pos
= pos
+ XINT (c
->total_cols
);
3663 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3667 /* Clear out some redisplay caches. */
3668 w
->last_modified
= 0;
3669 w
->last_overlay_modified
= 0;
3673 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 1, 2, 0,
3674 doc
: /* Apply requested size values for window-tree of FRAME.
3675 Optional argument HORIZONTAL omitted or nil means apply requested height
3676 values. HORIZONTAL non-nil means apply requested width values.
3678 This function checks whether the requested values sum up to a valid
3679 window layout, recursively assigns the new sizes of all child windows
3680 and calculates and assigns the new start positions of these windows.
3682 Note: This function does not check any of `window-fixed-size-p',
3683 `window-min-height' or `window-min-width'. All these checks have to
3684 be applied on the Elisp level. */)
3685 (Lisp_Object frame
, Lisp_Object horizontal
)
3689 int horflag
= !NILP (horizontal
);
3692 frame
= selected_frame
;
3693 CHECK_LIVE_FRAME (frame
);
3696 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3698 if (!window_resize_check (r
, horflag
)
3699 || ! EQ (r
->new_total
,
3700 (horflag
? r
->total_cols
: r
->total_lines
)))
3704 window_resize_apply (r
, horflag
);
3706 windows_or_buffers_changed
++;
3707 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3712 run_window_configuration_change_hook (f
);
3718 /* Resize frame F's windows when number of lines of F is set to SIZE.
3719 HORFLAG 1 means resize windows when number of columns of F is set to
3722 This function can delete all windows but the selected one in order to
3723 satisfy the request. The result will be meaningful if and only if
3724 F's windows have meaningful sizes when you call this. */
3726 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3728 Lisp_Object root
= f
->root_window
;
3729 struct window
*r
= XWINDOW (root
);
3730 Lisp_Object mini
= f
->minibuffer_window
;
3732 /* new_size is the new size of the frame's root window. */
3733 int new_size
= (horflag
3736 - FRAME_TOP_MARGIN (f
)
3737 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3740 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3741 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3742 /* For a leaf root window just set the size. */
3744 wset_total_cols (r
, make_number (new_size
));
3746 wset_total_lines (r
, make_number (new_size
));
3749 /* old_size is the old size of the frame's root window. */
3750 int old_size
= XFASTINT (horflag
? r
->total_cols
3754 XSETINT (delta
, new_size
- old_size
);
3755 /* Try a "normal" resize first. */
3756 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3757 if (window_resize_check (r
, horflag
)
3758 && new_size
== XINT (r
->new_total
))
3759 window_resize_apply (r
, horflag
);
3762 /* Try with "reasonable" minimum sizes next. */
3763 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3764 if (window_resize_check (r
, horflag
)
3765 && new_size
== XINT (r
->new_total
))
3766 window_resize_apply (r
, horflag
);
3769 /* Finally, try with "safe" minimum sizes. */
3770 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3771 if (window_resize_check (r
, horflag
)
3772 && new_size
== XINT (r
->new_total
))
3773 window_resize_apply (r
, horflag
);
3776 /* We lost. Delete all windows but the frame's
3778 root
= f
->selected_window
;
3779 Fdelete_other_windows_internal (root
, Qnil
);
3781 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3783 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3789 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3793 wset_total_cols (m
, make_number (size
));
3796 /* Are we sure we always want 1 line here? */
3797 wset_total_lines (m
, make_number (1));
3799 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3805 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3806 doc
: /* Split window OLD.
3807 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3808 new window. In any case TOTAL-SIZE must be a positive integer.
3810 Third argument SIDE nil (or `below') specifies that the new window shall
3811 be located below WINDOW. SIDE `above' means the new window shall be
3812 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3813 lines of the new window including space reserved for the mode and/or
3816 SIDE t (or `right') specifies that the new window shall be located on
3817 the right side of WINDOW. SIDE `left' means the new window shall be
3818 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3819 number of columns of the new window including space reserved for fringes
3820 and the scrollbar or a divider column.
3822 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3823 according to the SIDE argument.
3825 The new total and normal sizes of all involved windows must have been
3826 set correctly. See the code of `split-window' for how this is done. */)
3827 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3829 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3830 parent window or an internal window we have to install as OLD's new
3831 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3832 provided OLD is a leaf window, or to the frame's selected window.
3833 NEW (*n) is the new window created with some parameters taken from
3835 register Lisp_Object
new, frame
, reference
;
3836 register struct window
*o
, *p
, *n
, *r
;
3839 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3840 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3841 int combination_limit
= 0;
3845 frame
= WINDOW_FRAME (o
);
3848 CHECK_NUMBER (total_size
);
3850 /* Set combination_limit to 1 if we have to make a new parent window.
3851 We do that if either `window-combination-limit' is t, or OLD has no
3852 parent, or OLD is ortho-combined. */
3854 !NILP (Vwindow_combination_limit
)
3857 ? (XWINDOW (o
->parent
)->hchild
)
3858 : (XWINDOW (o
->parent
)->vchild
));
3860 /* We need a live reference window to initialize some parameters. */
3861 if (WINDOW_LIVE_P (old
))
3862 /* OLD is live, use it as reference window. */
3865 /* Use the frame's selected window as reference window. */
3866 reference
= FRAME_SELECTED_WINDOW (f
);
3867 r
= XWINDOW (reference
);
3869 /* The following bugs are caught by `split-window'. */
3870 if (MINI_WINDOW_P (o
))
3871 error ("Attempt to split minibuffer window");
3872 else if (XINT (total_size
) < (horflag
? 2 : 1))
3873 error ("Size of new window too small (after split)");
3874 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3875 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3878 p
= XWINDOW (o
->parent
);
3879 /* Temporarily pretend we split the parent window. */
3881 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3882 - XINT (total_size
)));
3883 if (!window_resize_check (p
, horflag
))
3884 error ("Window sizes don't fit");
3886 /* Undo the temporary pretension. */
3887 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3891 if (!window_resize_check (o
, horflag
))
3892 error ("Resizing old window failed");
3893 else if (XINT (total_size
) + XINT (o
->new_total
)
3894 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3895 error ("Sum of sizes of old and new window don't fit");
3898 /* This is our point of no return. */
3899 if (combination_limit
)
3901 /* Save the old value of o->normal_cols/lines. It gets corrupted
3902 by make_parent_window and we need it below for assigning it to
3904 Lisp_Object new_normal
3905 = horflag
? o
->normal_cols
: o
->normal_lines
;
3907 make_parent_window (old
, horflag
);
3908 p
= XWINDOW (o
->parent
);
3909 /* Store value of `window-combination-limit' in new parent's
3910 combination_limit slot. */
3911 wset_combination_limit (p
, Vwindow_combination_limit
);
3912 /* These get applied below. */
3913 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3914 wset_new_normal (p
, new_normal
);
3917 p
= XWINDOW (o
->parent
);
3919 windows_or_buffers_changed
++;
3920 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3921 new = make_window ();
3923 wset_frame (n
, frame
);
3924 wset_parent (n
, o
->parent
);
3925 wset_vchild (n
, Qnil
);
3926 wset_hchild (n
, Qnil
);
3928 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3930 wset_prev (n
, o
->prev
);
3933 wset_hchild (p
, new);
3935 wset_vchild (p
, new);
3937 wset_next (XWINDOW (n
->prev
), new);
3943 wset_next (n
, o
->next
);
3944 if (!NILP (n
->next
))
3945 wset_prev (XWINDOW (n
->next
), new);
3950 wset_buffer (n
, Qt
);
3951 wset_window_end_valid (n
, Qnil
);
3952 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3954 /* Get special geometry settings from reference window. */
3955 wset_left_margin_cols (n
, r
->left_margin_cols
);
3956 wset_right_margin_cols (n
, r
->right_margin_cols
);
3957 wset_left_fringe_width (n
, r
->left_fringe_width
);
3958 wset_right_fringe_width (n
, r
->right_fringe_width
);
3959 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3960 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3961 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3963 /* Directly assign orthogonal coordinates and sizes. */
3966 wset_top_line (n
, o
->top_line
);
3967 wset_total_lines (n
, o
->total_lines
);
3971 wset_left_col (n
, o
->left_col
);
3972 wset_total_cols (n
, o
->total_cols
);
3975 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3976 get them ready here. */
3977 wset_new_total (n
, total_size
);
3978 wset_new_normal (n
, normal_size
);
3981 window_resize_apply (p
, horflag
);
3983 /* Set buffer of NEW to buffer of reference window. Don't run
3985 set_window_buffer (new, r
->buffer
, 0, 1);
3988 /* Maybe we should run the scroll functions in Elisp (which already
3989 runs the configuration change hook). */
3990 if (! NILP (Vwindow_scroll_functions
))
3991 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3992 Fmarker_position (n
->start
));
3998 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3999 doc
: /* Remove WINDOW from its frame.
4000 WINDOW defaults to the selected window. Return nil.
4001 Signal an error when WINDOW is the only window on its frame. */)
4002 (register Lisp_Object window
)
4004 register Lisp_Object parent
, sibling
, frame
, root
;
4005 struct window
*w
, *p
, *s
, *r
;
4008 int before_sibling
= 0;
4010 w
= decode_any_window (window
);
4011 XSETWINDOW (window
, w
);
4012 if (NILP (w
->buffer
)
4013 && NILP (w
->hchild
) && NILP (w
->vchild
))
4014 /* It's a no-op to delete an already deleted window. */
4019 /* Never delete a minibuffer or frame root window. */
4020 error ("Attempt to delete minibuffer or sole ordinary window");
4021 else if (NILP (w
->prev
) && NILP (w
->next
))
4022 /* Rather bow out here, this case should be handled on the Elisp
4024 error ("Attempt to delete sole window of parent");
4026 p
= XWINDOW (parent
);
4027 horflag
= NILP (p
->vchild
);
4029 frame
= WINDOW_FRAME (w
);
4032 root
= FRAME_ROOT_WINDOW (f
);
4035 /* Unlink WINDOW from window tree. */
4037 /* Get SIBLING below (on the right of) WINDOW. */
4039 /* before_sibling 1 means WINDOW is the first child of its
4040 parent and thus before the sibling. */
4043 s
= XWINDOW (sibling
);
4044 wset_prev (s
, Qnil
);
4046 wset_hchild (p
, sibling
);
4048 wset_vchild (p
, sibling
);
4051 /* Get SIBLING above (on the left of) WINDOW. */
4054 s
= XWINDOW (sibling
);
4055 wset_next (s
, w
->next
);
4056 if (!NILP (s
->next
))
4057 wset_prev (XWINDOW (s
->next
), sibling
);
4060 if (window_resize_check (r
, horflag
)
4061 && EQ (r
->new_total
,
4062 (horflag
? r
->total_cols
: r
->total_lines
)))
4063 /* We can delete WINDOW now. */
4068 window_resize_apply (p
, horflag
);
4070 /* If this window is referred to by the dpyinfo's mouse
4071 highlight, invalidate that slot to be safe (Bug#9904). */
4072 if (!FRAME_INITIAL_P (f
))
4074 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4076 if (EQ (hlinfo
->mouse_face_window
, window
))
4077 hlinfo
->mouse_face_window
= Qnil
;
4080 windows_or_buffers_changed
++;
4081 Vwindow_list
= Qnil
;
4082 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4084 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4085 free_window_matrices (w
);
4087 if (!NILP (w
->vchild
))
4089 delete_all_child_windows (w
->vchild
);
4090 wset_vchild (w
, Qnil
);
4092 else if (!NILP (w
->hchild
))
4094 delete_all_child_windows (w
->hchild
);
4095 wset_hchild (w
, Qnil
);
4097 else if (!NILP (w
->buffer
))
4100 unchain_marker (XMARKER (w
->pointm
));
4101 unchain_marker (XMARKER (w
->start
));
4102 wset_buffer (w
, Qnil
);
4105 if (NILP (s
->prev
) && NILP (s
->next
))
4106 /* A matrjoshka where SIBLING has become the only child of
4109 /* Put SIBLING into PARENT's place. */
4110 replace_window (parent
, sibling
, 0);
4111 /* Have SIBLING inherit the following three slot values from
4112 PARENT (the combination_limit slot is not inherited). */
4113 wset_normal_cols (s
, p
->normal_cols
);
4114 wset_normal_lines (s
, p
->normal_lines
);
4115 /* Mark PARENT as deleted. */
4116 wset_vchild (p
, Qnil
);
4117 wset_hchild (p
, Qnil
);
4118 /* Try to merge SIBLING into its new parent. */
4119 recombine_windows (sibling
);
4124 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4125 /* We deleted the frame's selected window. */
4127 /* Use the frame's first window as fallback ... */
4128 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4129 /* ... but preferably use its most recently used window. */
4130 Lisp_Object mru_window
;
4132 /* `get-mru-window' might fail for some reason so play it safe
4133 - promote the first window _without recording it_ first. */
4134 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4135 Fselect_window (new_selected_window
, Qt
);
4137 fset_selected_window (f
, new_selected_window
);
4141 /* Now look whether `get-mru-window' gets us something. */
4142 mru_window
= call1 (Qget_mru_window
, frame
);
4143 if (WINDOW_LIVE_P (mru_window
)
4144 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4145 new_selected_window
= mru_window
;
4147 /* If all ended up well, we now promote the mru window. */
4148 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4149 Fselect_window (new_selected_window
, Qnil
);
4151 fset_selected_window (f
, new_selected_window
);
4156 /* Must be run by the caller:
4157 run_window_configuration_change_hook (f); */
4160 /* We failed: Relink WINDOW into window tree. */
4164 wset_prev (s
, window
);
4166 wset_hchild (p
, window
);
4168 wset_vchild (p
, window
);
4172 wset_next (s
, window
);
4173 if (!NILP (w
->next
))
4174 wset_prev (XWINDOW (w
->next
), window
);
4176 error ("Deletion failed");
4182 /***********************************************************************
4183 Resizing Mini-Windows
4184 ***********************************************************************/
4186 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4189 grow_mini_window (struct window
*w
, int delta
)
4191 struct frame
*f
= XFRAME (w
->frame
);
4193 Lisp_Object root
, value
;
4195 eassert (MINI_WINDOW_P (w
));
4196 eassert (delta
>= 0);
4198 root
= FRAME_ROOT_WINDOW (f
);
4200 value
= call2 (Qwindow_resize_root_window_vertically
,
4201 root
, make_number (- delta
));
4202 if (INTEGERP (value
) && window_resize_check (r
, 0))
4205 window_resize_apply (r
, 0);
4207 /* Grow the mini-window. */
4209 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4211 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4212 w
->last_modified
= 0;
4213 w
->last_overlay_modified
= 0;
4221 /* Shrink mini-window W. */
4223 shrink_mini_window (struct window
*w
)
4225 struct frame
*f
= XFRAME (w
->frame
);
4227 Lisp_Object root
, value
;
4230 eassert (MINI_WINDOW_P (w
));
4232 size
= XINT (w
->total_lines
);
4235 root
= FRAME_ROOT_WINDOW (f
);
4237 value
= call2 (Qwindow_resize_root_window_vertically
,
4238 root
, make_number (size
- 1));
4239 if (INTEGERP (value
) && window_resize_check (r
, 0))
4242 window_resize_apply (r
, 0);
4244 /* Shrink the mini-window. */
4245 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4246 + XFASTINT (r
->total_lines
)));
4247 wset_total_lines (w
, make_number (1));
4249 w
->last_modified
= 0;
4250 w
->last_overlay_modified
= 0;
4255 /* If the above failed for whatever strange reason we must make a
4256 one window frame here. The same routine will be needed when
4257 shrinking the frame (and probably when making the initial
4258 *scratch* window). For the moment leave things as they are. */
4262 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4263 doc
: /* Resize minibuffer window WINDOW. */)
4264 (Lisp_Object window
)
4266 struct window
*w
= XWINDOW (window
);
4271 CHECK_WINDOW (window
);
4272 f
= XFRAME (w
->frame
);
4274 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4275 error ("Not a valid minibuffer window");
4276 else if (FRAME_MINIBUF_ONLY_P (f
))
4277 error ("Cannot resize a minibuffer-only frame");
4279 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4280 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4281 if (window_resize_check (r
, 0)
4282 && XINT (w
->new_total
) > 0
4283 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4286 window_resize_apply (r
, 0);
4288 wset_total_lines (w
, w
->new_total
);
4289 wset_top_line (w
, make_number (XINT (r
->top_line
)
4290 + XINT (r
->total_lines
)));
4292 windows_or_buffers_changed
++;
4293 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4297 run_window_configuration_change_hook (f
);
4300 else error ("Failed to resize minibuffer window");
4303 /* Mark window cursors off for all windows in the window tree rooted
4304 at W by setting their phys_cursor_on_p flag to zero. Called from
4305 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4306 the frame are cleared. */
4309 mark_window_cursors_off (struct window
*w
)
4313 if (!NILP (w
->hchild
))
4314 mark_window_cursors_off (XWINDOW (w
->hchild
));
4315 else if (!NILP (w
->vchild
))
4316 mark_window_cursors_off (XWINDOW (w
->vchild
));
4318 w
->phys_cursor_on_p
= 0;
4320 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4325 /* Return number of lines of text (not counting mode lines) in W. */
4328 window_internal_height (struct window
*w
)
4330 int ht
= XFASTINT (w
->total_lines
);
4332 if (!MINI_WINDOW_P (w
))
4334 if (!NILP (w
->parent
)
4335 || !NILP (w
->vchild
)
4336 || !NILP (w
->hchild
)
4339 || WINDOW_WANTS_MODELINE_P (w
))
4342 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4349 /************************************************************************
4351 ***********************************************************************/
4353 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4354 N screen-fulls, which is defined as the height of the window minus
4355 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4356 instead. Negative values of N mean scroll down. NOERROR non-zero
4357 means don't signal an error if we try to move over BEGV or ZV,
4361 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4364 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4366 /* If we must, use the pixel-based version which is much slower than
4367 the line-based one but can handle varying line heights. */
4368 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4369 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4371 window_scroll_line_based (window
, n
, whole
, noerror
);
4377 /* Implementation of window_scroll that works based on pixel line
4378 heights. See the comment of window_scroll for parameter
4382 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4385 struct window
*w
= XWINDOW (window
);
4386 struct text_pos start
;
4387 int this_scroll_margin
;
4388 /* True if we fiddled the window vscroll field without really scrolling. */
4390 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4391 void *itdata
= NULL
;
4393 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4394 /* Scrolling a minibuffer window via scroll bar when the echo area
4395 shows long text sometimes resets the minibuffer contents behind
4397 if (CHARPOS (start
) > ZV
)
4398 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4400 /* If PT is not visible in WINDOW, move back one half of
4401 the screen. Allow PT to be partially visible, otherwise
4402 something like (scroll-down 1) with PT in the line before
4403 the partially visible one would recenter. */
4405 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4407 itdata
= bidi_shelve_cache ();
4408 /* Move backward half the height of the window. Performance note:
4409 vmotion used here is about 10% faster, but would give wrong
4410 results for variable height lines. */
4411 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4412 it
.current_y
= it
.last_visible_y
;
4413 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4415 /* The function move_iterator_vertically may move over more than
4416 the specified y-distance. If it->w is small, e.g. a
4417 mini-buffer window, we may end up in front of the window's
4418 display area. This is the case when Start displaying at the
4419 start of the line containing PT in this case. */
4420 if (it
.current_y
<= 0)
4422 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4423 move_it_vertically_backward (&it
, 0);
4427 start
= it
.current
.pos
;
4428 bidi_unshelve_cache (itdata
, 0);
4430 else if (auto_window_vscroll_p
)
4432 if (rtop
|| rbot
) /* partially visible */
4435 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4437 dy
= max ((window_box_height (w
)
4438 - next_screen_context_lines
* dy
),
4444 /* Only vscroll backwards if already vscrolled forwards. */
4445 if (w
->vscroll
< 0 && rtop
> 0)
4447 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4448 Fset_window_vscroll (window
, make_number (px
), Qt
);
4454 /* Do vscroll if already vscrolled or only display line. */
4455 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4457 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4458 Fset_window_vscroll (window
, make_number (px
), Qt
);
4462 /* Maybe modify window start instead of scrolling. */
4463 if (rbot
> 0 || w
->vscroll
< 0)
4467 Fset_window_vscroll (window
, make_number (0), Qt
);
4468 /* If there are other text lines above the current row,
4469 move window start to current row. Else to next row. */
4471 spos
= XINT (Fline_beginning_position (Qnil
));
4473 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4474 set_marker_restricted (w
->start
, make_number (spos
),
4476 w
->start_at_line_beg
= 1;
4477 w
->update_mode_line
= 1;
4478 w
->last_modified
= 0;
4479 w
->last_overlay_modified
= 0;
4480 /* Set force_start so that redisplay_window will run the
4481 window-scroll-functions. */
4487 /* Cancel previous vscroll. */
4488 Fset_window_vscroll (window
, make_number (0), Qt
);
4491 itdata
= bidi_shelve_cache ();
4492 /* If scroll_preserve_screen_position is non-nil, we try to set
4493 point in the same window line as it is now, so get that line. */
4494 if (!NILP (Vscroll_preserve_screen_position
))
4496 /* We preserve the goal pixel coordinate across consecutive
4497 calls to scroll-up, scroll-down and other commands that
4498 have the `scroll-command' property. This avoids the
4499 possibility of point becoming "stuck" on a tall line when
4500 scrolling by one line. */
4501 if (window_scroll_pixel_based_preserve_y
< 0
4502 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4503 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4505 start_display (&it
, w
, start
);
4506 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4507 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4508 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4512 window_scroll_pixel_based_preserve_y
4513 = window_scroll_pixel_based_preserve_x
= -1;
4515 /* Move iterator it from start the specified distance forward or
4516 backward. The result is the new window start. */
4517 start_display (&it
, w
, start
);
4520 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4521 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4522 dy
= max ((window_box_height (w
)
4523 - next_screen_context_lines
* dy
),
4526 /* Note that move_it_vertically always moves the iterator to the
4527 start of a line. So, if the last line doesn't have a newline,
4528 we would end up at the start of the line ending at ZV. */
4531 move_it_vertically_backward (&it
, -dy
);
4532 /* Ensure we actually do move, e.g. in case we are currently
4533 looking at an image that is taller that the window height. */
4534 while (start_pos
== IT_CHARPOS (it
)
4535 && start_pos
> BEGV
)
4536 move_it_by_lines (&it
, -1);
4540 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4541 MOVE_TO_POS
| MOVE_TO_Y
);
4542 /* Ensure we actually do move, e.g. in case we are currently
4543 looking at an image that is taller that the window height. */
4544 while (start_pos
== IT_CHARPOS (it
)
4546 move_it_by_lines (&it
, 1);
4550 move_it_by_lines (&it
, n
);
4552 /* We failed if we find ZV is already on the screen (scrolling up,
4553 means there's nothing past the end), or if we can't start any
4554 earlier (scrolling down, means there's nothing past the top). */
4555 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4556 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4558 if (IT_CHARPOS (it
) == ZV
)
4560 if (it
.current_y
< it
.last_visible_y
4561 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4562 > it
.last_visible_y
))
4564 /* The last line was only partially visible, make it fully
4566 w
->vscroll
= (it
.last_visible_y
4567 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4568 adjust_glyphs (it
.f
);
4572 bidi_unshelve_cache (itdata
, 0);
4575 else if (n
< 0) /* could happen with empty buffers */
4576 xsignal0 (Qbeginning_of_buffer
);
4578 xsignal0 (Qend_of_buffer
);
4583 if (w
->vscroll
!= 0)
4584 /* The first line was only partially visible, make it fully
4589 bidi_unshelve_cache (itdata
, 0);
4593 xsignal0 (Qbeginning_of_buffer
);
4597 /* If control gets here, then we vscrolled. */
4599 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4601 /* Don't try to change the window start below. */
4607 ptrdiff_t pos
= IT_CHARPOS (it
);
4610 /* If in the middle of a multi-glyph character move forward to
4611 the next character. */
4612 if (in_display_vector_p (&it
))
4615 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4618 /* Set the window start, and set up the window for redisplay. */
4619 set_marker_restricted (w
->start
, make_number (pos
),
4621 bytepos
= XMARKER (w
->start
)->bytepos
;
4622 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4623 w
->update_mode_line
= 1;
4624 w
->last_modified
= 0;
4625 w
->last_overlay_modified
= 0;
4626 /* Set force_start so that redisplay_window will run the
4627 window-scroll-functions. */
4631 /* The rest of this function uses current_y in a nonstandard way,
4632 not including the height of the header line if any. */
4633 it
.current_y
= it
.vpos
= 0;
4635 /* Move PT out of scroll margins.
4636 This code wants current_y to be zero at the window start position
4637 even if there is a header line. */
4638 this_scroll_margin
= max (0, scroll_margin
);
4640 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4641 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4645 /* We moved the window start towards ZV, so PT may be now
4646 in the scroll margin at the top. */
4647 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4648 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4649 && (NILP (Vscroll_preserve_screen_position
)
4650 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4651 /* We found PT at a legitimate height. Leave it alone. */
4653 else if (window_scroll_pixel_based_preserve_y
>= 0)
4655 /* If we have a header line, take account of it.
4656 This is necessary because we set it.current_y to 0, above. */
4657 move_it_to (&it
, -1,
4658 window_scroll_pixel_based_preserve_x
,
4659 window_scroll_pixel_based_preserve_y
4660 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4661 -1, MOVE_TO_Y
| MOVE_TO_X
);
4662 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4666 while (it
.current_y
< this_scroll_margin
)
4668 int prev
= it
.current_y
;
4669 move_it_by_lines (&it
, 1);
4670 if (prev
== it
.current_y
)
4673 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4678 ptrdiff_t charpos
, bytepos
;
4681 /* Save our position, for the
4682 window_scroll_pixel_based_preserve_y case. */
4683 charpos
= IT_CHARPOS (it
);
4684 bytepos
= IT_BYTEPOS (it
);
4686 /* We moved the window start towards BEGV, so PT may be now
4687 in the scroll margin at the bottom. */
4688 move_it_to (&it
, PT
, -1,
4689 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4690 - this_scroll_margin
- 1),
4692 MOVE_TO_POS
| MOVE_TO_Y
);
4694 /* Save our position, in case it's correct. */
4695 charpos
= IT_CHARPOS (it
);
4696 bytepos
= IT_BYTEPOS (it
);
4698 /* See if point is on a partially visible line at the end. */
4699 if (it
.what
== IT_EOB
)
4700 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4703 move_it_by_lines (&it
, 1);
4704 partial_p
= it
.current_y
> it
.last_visible_y
;
4707 if (charpos
== PT
&& !partial_p
4708 && (NILP (Vscroll_preserve_screen_position
)
4709 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4710 /* We found PT before we found the display margin, so PT is ok. */
4712 else if (window_scroll_pixel_based_preserve_y
>= 0)
4714 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4715 start_display (&it
, w
, start
);
4716 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4717 here because we called start_display again and did not
4718 alter it.current_y this time. */
4719 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4720 window_scroll_pixel_based_preserve_y
, -1,
4721 MOVE_TO_Y
| MOVE_TO_X
);
4722 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4727 /* The last line was only partially visible, so back up two
4728 lines to make sure we're on a fully visible line. */
4730 move_it_by_lines (&it
, -2);
4731 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4734 /* No, the position we saved is OK, so use it. */
4735 SET_PT_BOTH (charpos
, bytepos
);
4738 bidi_unshelve_cache (itdata
, 0);
4742 /* Implementation of window_scroll that works based on screen lines.
4743 See the comment of window_scroll for parameter descriptions. */
4746 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4748 register struct window
*w
= XWINDOW (window
);
4749 /* Fvertical_motion enters redisplay, which can trigger
4750 fontification, which in turn can modify buffer text (e.g., if the
4751 fontification functions replace escape sequences with faces, as
4752 in `grep-mode-font-lock-keywords'). So we use a marker to record
4753 the old point position, to prevent crashes in SET_PT_BOTH. */
4754 Lisp_Object opoint_marker
= Fpoint_marker ();
4755 register ptrdiff_t pos
, pos_byte
;
4756 register int ht
= window_internal_height (w
);
4757 register Lisp_Object tem
;
4761 Lisp_Object original_pos
= Qnil
;
4763 /* If scrolling screen-fulls, compute the number of lines to
4764 scroll from the window's height. */
4766 n
*= max (1, ht
- next_screen_context_lines
);
4768 startpos
= marker_position (w
->start
);
4770 if (!NILP (Vscroll_preserve_screen_position
))
4772 if (window_scroll_preserve_vpos
<= 0
4773 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4774 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4776 struct position posit
4777 = *compute_motion (startpos
, 0, 0, 0,
4781 window_scroll_preserve_vpos
= posit
.vpos
;
4782 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4785 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4786 make_number (window_scroll_preserve_vpos
));
4789 XSETFASTINT (tem
, PT
);
4790 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4794 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4799 lose
= n
< 0 && PT
== BEGV
;
4800 Fvertical_motion (make_number (n
), window
);
4804 SET_PT_BOTH (marker_position (opoint_marker
),
4805 marker_byte_position (opoint_marker
));
4812 xsignal0 (Qbeginning_of_buffer
);
4817 /* Don't use a scroll margin that is negative or too large. */
4818 int this_scroll_margin
=
4819 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4821 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4822 w
->start_at_line_beg
= !NILP (bolp
);
4823 w
->update_mode_line
= 1;
4824 w
->last_modified
= 0;
4825 w
->last_overlay_modified
= 0;
4826 /* Set force_start so that redisplay_window will run
4827 the window-scroll-functions. */
4830 if (!NILP (Vscroll_preserve_screen_position
)
4831 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4833 SET_PT_BOTH (pos
, pos_byte
);
4834 Fvertical_motion (original_pos
, window
);
4836 /* If we scrolled forward, put point enough lines down
4837 that it is outside the scroll margin. */
4842 if (this_scroll_margin
> 0)
4844 SET_PT_BOTH (pos
, pos_byte
);
4845 Fvertical_motion (make_number (this_scroll_margin
), window
);
4851 if (top_margin
<= marker_position (opoint_marker
))
4852 SET_PT_BOTH (marker_position (opoint_marker
),
4853 marker_byte_position (opoint_marker
));
4854 else if (!NILP (Vscroll_preserve_screen_position
))
4856 SET_PT_BOTH (pos
, pos_byte
);
4857 Fvertical_motion (original_pos
, window
);
4860 SET_PT (top_margin
);
4866 /* If we scrolled backward, put point near the end of the window
4867 but not within the scroll margin. */
4868 SET_PT_BOTH (pos
, pos_byte
);
4869 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4870 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4873 bottom_margin
= PT
+ 1;
4875 if (bottom_margin
> marker_position (opoint_marker
))
4876 SET_PT_BOTH (marker_position (opoint_marker
),
4877 marker_byte_position (opoint_marker
));
4880 if (!NILP (Vscroll_preserve_screen_position
))
4882 SET_PT_BOTH (pos
, pos_byte
);
4883 Fvertical_motion (original_pos
, window
);
4886 Fvertical_motion (make_number (-1), window
);
4895 xsignal0 (Qend_of_buffer
);
4900 /* Scroll selected_window up or down. If N is nil, scroll a
4901 screen-full which is defined as the height of the window minus
4902 next_screen_context_lines. If N is the symbol `-', scroll.
4903 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4904 up. This is the guts of Fscroll_up and Fscroll_down. */
4907 scroll_command (Lisp_Object n
, int direction
)
4909 ptrdiff_t count
= SPECPDL_INDEX ();
4911 eassert (eabs (direction
) == 1);
4913 /* If selected window's buffer isn't current, make it current for
4914 the moment. But don't screw up if window_scroll gets an error. */
4915 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4917 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4918 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4920 /* Make redisplay consider other windows than just selected_window. */
4921 ++windows_or_buffers_changed
;
4925 window_scroll (selected_window
, direction
, 1, 0);
4926 else if (EQ (n
, Qminus
))
4927 window_scroll (selected_window
, -direction
, 1, 0);
4930 n
= Fprefix_numeric_value (n
);
4931 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4934 unbind_to (count
, Qnil
);
4937 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4938 doc
: /* Scroll text of selected window upward ARG lines.
4939 If ARG is omitted or nil, scroll upward by a near full screen.
4940 A near full screen is `next-screen-context-lines' less than a full screen.
4941 Negative ARG means scroll downward.
4942 If ARG is the atom `-', scroll downward by nearly full screen.
4943 When calling from a program, supply as argument a number, nil, or `-'. */)
4946 scroll_command (arg
, 1);
4950 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4951 doc
: /* Scroll text of selected window down ARG lines.
4952 If ARG is omitted or nil, scroll down by a near full screen.
4953 A near full screen is `next-screen-context-lines' less than a full screen.
4954 Negative ARG means scroll upward.
4955 If ARG is the atom `-', scroll upward by nearly full screen.
4956 When calling from a program, supply as argument a number, nil, or `-'. */)
4959 scroll_command (arg
, -1);
4963 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4964 doc
: /* Return the other window for \"other window scroll\" commands.
4965 If `other-window-scroll-buffer' is non-nil, a window
4966 showing that buffer is used.
4967 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4968 specifies the window. This takes precedence over
4969 `other-window-scroll-buffer'. */)
4974 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4975 && !NILP (Vminibuf_scroll_window
))
4976 window
= Vminibuf_scroll_window
;
4977 /* If buffer is specified, scroll that buffer. */
4978 else if (!NILP (Vother_window_scroll_buffer
))
4980 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4982 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4986 /* Nothing specified; look for a neighboring window on the same
4988 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4990 if (EQ (window
, selected_window
))
4991 /* That didn't get us anywhere; look for a window on another
4994 window
= Fnext_window (window
, Qnil
, Qt
);
4995 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4996 && ! EQ (window
, selected_window
));
4999 CHECK_LIVE_WINDOW (window
);
5001 if (EQ (window
, selected_window
))
5002 error ("There is no other window");
5007 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5008 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5009 A near full screen is `next-screen-context-lines' less than a full screen.
5010 The next window is the one below the current one; or the one at the top
5011 if the current one is at the bottom. Negative ARG means scroll downward.
5012 If ARG is the atom `-', scroll downward by nearly full screen.
5013 When calling from a program, supply as argument a number, nil, or `-'.
5015 If `other-window-scroll-buffer' is non-nil, scroll the window
5016 showing that buffer, popping the buffer up if necessary.
5017 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5018 specifies the window to scroll. This takes precedence over
5019 `other-window-scroll-buffer'. */)
5024 ptrdiff_t count
= SPECPDL_INDEX ();
5026 window
= Fother_window_for_scrolling ();
5027 w
= XWINDOW (window
);
5029 /* Don't screw up if window_scroll gets an error. */
5030 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5031 ++windows_or_buffers_changed
;
5033 Fset_buffer (w
->buffer
);
5034 SET_PT (marker_position (w
->pointm
));
5037 window_scroll (window
, 1, 1, 1);
5038 else if (EQ (arg
, Qminus
))
5039 window_scroll (window
, -1, 1, 1);
5045 window_scroll (window
, XINT (arg
), 0, 1);
5048 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5049 unbind_to (count
, Qnil
);
5054 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5055 doc
: /* Scroll selected window display ARG columns left.
5056 Default for ARG is window width minus 2.
5057 Value is the total amount of leftward horizontal scrolling in
5058 effect after the change.
5059 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5060 lower bound for automatic scrolling, i.e. automatic scrolling
5061 will not scroll a window to a column less than the value returned
5062 by this function. This happens in an interactive call. */)
5063 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5065 struct window
*w
= XWINDOW (selected_window
);
5066 EMACS_INT requested_arg
= (NILP (arg
)
5067 ? window_body_cols (w
) - 2
5068 : XINT (Fprefix_numeric_value (arg
)));
5069 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5071 if (!NILP (set_minimum
))
5072 w
->min_hscroll
= w
->hscroll
;
5077 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5078 doc
: /* Scroll selected window display ARG columns right.
5079 Default for ARG is window width minus 2.
5080 Value is the total amount of leftward horizontal scrolling in
5081 effect after the change.
5082 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5083 lower bound for automatic scrolling, i.e. automatic scrolling
5084 will not scroll a window to a column less than the value returned
5085 by this function. This happens in an interactive call. */)
5086 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5088 struct window
*w
= XWINDOW (selected_window
);
5089 EMACS_INT requested_arg
= (NILP (arg
)
5090 ? window_body_cols (w
) - 2
5091 : XINT (Fprefix_numeric_value (arg
)));
5092 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5094 if (!NILP (set_minimum
))
5095 w
->min_hscroll
= w
->hscroll
;
5100 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5101 doc
: /* Return the window which was selected when entering the minibuffer.
5102 Returns nil, if selected window is not a minibuffer window. */)
5105 if (minibuf_level
> 0
5106 && MINI_WINDOW_P (XWINDOW (selected_window
))
5107 && WINDOW_LIVE_P (minibuf_selected_window
))
5108 return minibuf_selected_window
;
5113 /* Value is the number of lines actually displayed in window W,
5114 as opposed to its height. */
5117 displayed_window_lines (struct window
*w
)
5120 struct text_pos start
;
5121 int height
= window_box_height (w
);
5122 struct buffer
*old_buffer
;
5124 void *itdata
= NULL
;
5126 if (XBUFFER (w
->buffer
) != current_buffer
)
5128 old_buffer
= current_buffer
;
5129 set_buffer_internal (XBUFFER (w
->buffer
));
5134 /* In case W->start is out of the accessible range, do something
5135 reasonable. This happens in Info mode when Info-scroll-down
5136 calls (recenter -1) while W->start is 1. */
5137 if (XMARKER (w
->start
)->charpos
< BEGV
)
5138 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5139 else if (XMARKER (w
->start
)->charpos
> ZV
)
5140 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5142 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5144 itdata
= bidi_shelve_cache ();
5145 start_display (&it
, w
, start
);
5146 move_it_vertically (&it
, height
);
5147 bottom_y
= line_bottom_y (&it
);
5148 bidi_unshelve_cache (itdata
, 0);
5150 /* rms: On a non-window display,
5151 the value of it.vpos at the bottom of the screen
5152 seems to be 1 larger than window_box_height (w).
5153 This kludge fixes a bug whereby (move-to-window-line -1)
5154 when ZV is on the last screen line
5155 moves to the previous screen line instead of the last one. */
5156 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5159 /* Add in empty lines at the bottom of the window. */
5160 if (bottom_y
< height
)
5162 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5163 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5167 set_buffer_internal (old_buffer
);
5173 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5174 doc
: /* Center point in selected window and maybe redisplay frame.
5175 With prefix argument ARG, recenter putting point on screen line ARG
5176 relative to the selected window. If ARG is negative, it counts up from the
5177 bottom of the window. (ARG should be less than the height of the window.)
5179 If ARG is omitted or nil, then recenter with point on the middle line of
5180 the selected window; if the variable `recenter-redisplay' is non-nil,
5181 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5182 is set to `grow-only', this resets the tool-bar's height to the minimum
5183 height needed); if `recenter-redisplay' has the special value `tty',
5184 then only tty frames are redrawn.
5186 Just C-u as prefix means put point in the center of the window
5187 and redisplay normally--don't erase and redraw the frame. */)
5188 (register Lisp_Object arg
)
5190 struct window
*w
= XWINDOW (selected_window
);
5191 struct buffer
*buf
= XBUFFER (w
->buffer
);
5192 struct buffer
*obuf
= current_buffer
;
5194 ptrdiff_t charpos
, bytepos
;
5195 EMACS_INT iarg
IF_LINT (= 0);
5196 int this_scroll_margin
;
5198 /* If redisplay is suppressed due to an error, try again. */
5199 obuf
->display_error_modiff
= 0;
5203 if (!NILP (Vrecenter_redisplay
)
5204 && (!EQ (Vrecenter_redisplay
, Qtty
)
5205 || !NILP (Ftty_type (selected_frame
))))
5209 /* Invalidate pixel data calculated for all compositions. */
5210 for (i
= 0; i
< n_compositions
; i
++)
5211 composition_table
[i
]->font
= NULL
;
5213 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5215 Fredraw_frame (WINDOW_FRAME (w
));
5216 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5221 else if (CONSP (arg
)) /* Just C-u. */
5225 arg
= Fprefix_numeric_value (arg
);
5230 set_buffer_internal (buf
);
5232 /* Do this after making BUF current
5233 in case scroll_margin is buffer-local. */
5234 this_scroll_margin
=
5235 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5237 /* Handle centering on a graphical frame specially. Such frames can
5238 have variable-height lines and centering point on the basis of
5239 line counts would lead to strange effects. */
5240 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5246 void *itdata
= bidi_shelve_cache ();
5248 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5249 start_display (&it
, w
, pt
);
5250 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5251 charpos
= IT_CHARPOS (it
);
5252 bytepos
= IT_BYTEPOS (it
);
5253 bidi_unshelve_cache (itdata
, 0);
5259 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5260 int extra_line_spacing
;
5261 int h
= window_box_height (w
);
5262 void *itdata
= bidi_shelve_cache ();
5264 iarg
= - max (-iarg
, this_scroll_margin
);
5266 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5267 start_display (&it
, w
, pt
);
5269 /* Be sure we have the exact height of the full line containing PT. */
5270 move_it_by_lines (&it
, 0);
5272 /* The amount of pixels we have to move back is the window
5273 height minus what's displayed in the line containing PT,
5274 and the lines below. */
5277 move_it_by_lines (&it
, nlines
);
5279 if (it
.vpos
== nlines
)
5283 /* Last line has no newline */
5284 h
-= line_bottom_y (&it
);
5288 /* Don't reserve space for extra line spacing of last line. */
5289 extra_line_spacing
= it
.max_extra_line_spacing
;
5291 /* If we can't move down NLINES lines because we hit
5292 the end of the buffer, count in some empty lines. */
5293 if (it
.vpos
< nlines
)
5296 extra_line_spacing
= it
.extra_line_spacing
;
5297 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5301 bidi_unshelve_cache (itdata
, 0);
5305 /* Now find the new top line (starting position) of the window. */
5306 start_display (&it
, w
, pt
);
5308 move_it_vertically_backward (&it
, h
);
5310 /* If extra line spacing is present, we may move too far
5311 back. This causes the last line to be only partially
5312 visible (which triggers redisplay to recenter that line
5313 in the middle), so move forward.
5314 But ignore extra line spacing on last line, as it is not
5315 considered to be part of the visible height of the line.
5317 h
+= extra_line_spacing
;
5318 while (-it
.current_y
> h
)
5319 move_it_by_lines (&it
, 1);
5321 charpos
= IT_CHARPOS (it
);
5322 bytepos
= IT_BYTEPOS (it
);
5324 bidi_unshelve_cache (itdata
, 0);
5328 struct position pos
;
5330 iarg
= max (iarg
, this_scroll_margin
);
5332 pos
= *vmotion (PT
, -iarg
, w
);
5333 charpos
= pos
.bufpos
;
5334 bytepos
= pos
.bytepos
;
5339 struct position pos
;
5340 int ht
= window_internal_height (w
);
5347 /* Don't let it get into the margin at either top or bottom. */
5348 iarg
= max (iarg
, this_scroll_margin
);
5349 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5351 pos
= *vmotion (PT
, - iarg
, w
);
5352 charpos
= pos
.bufpos
;
5353 bytepos
= pos
.bytepos
;
5356 /* Set the new window start. */
5357 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5358 wset_window_end_valid (w
, Qnil
);
5360 w
->optional_new_start
= 1;
5362 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5363 FETCH_BYTE (bytepos
- 1) == '\n');
5365 set_buffer_internal (obuf
);
5369 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5371 doc
: /* Return the height in lines of the text display area of WINDOW.
5372 WINDOW must be a live window and defaults to the selected one.
5374 The returned height does not include the mode line, any header line,
5375 nor any partial-height lines at the bottom of the text area. */)
5376 (Lisp_Object window
)
5378 struct window
*w
= decode_live_window (window
);
5379 int pixel_height
= window_box_height (w
);
5380 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5381 return make_number (line_height
);
5386 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5388 doc
: /* Position point relative to window.
5389 ARG nil means position point at center of window.
5390 Else, ARG specifies vertical position within the window;
5391 zero means top of window, negative means relative to bottom of window. */)
5394 struct window
*w
= XWINDOW (selected_window
);
5398 int this_scroll_margin
;
5401 if (!(BUFFERP (w
->buffer
)
5402 && XBUFFER (w
->buffer
) == current_buffer
))
5403 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5404 when passed below to set_marker_both. */
5405 error ("move-to-window-line called from unrelated buffer");
5407 window
= selected_window
;
5408 start
= marker_position (w
->start
);
5409 if (start
< BEGV
|| start
> ZV
)
5411 int height
= window_internal_height (w
);
5412 Fvertical_motion (make_number (- (height
/ 2)), window
);
5413 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5414 w
->start_at_line_beg
= !NILP (Fbolp ());
5418 Fgoto_char (w
->start
);
5420 lines
= displayed_window_lines (w
);
5423 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5427 XSETFASTINT (arg
, lines
/ 2);
5430 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5433 iarg
= iarg
+ lines
;
5435 #if 0 /* This code would prevent move-to-window-line from moving point
5436 to a place inside the scroll margins (which would cause the
5437 next redisplay to scroll). I wrote this code, but then concluded
5438 it is probably better not to install it. However, it is here
5439 inside #if 0 so as not to lose it. -- rms. */
5441 /* Don't let it get into the margin at either top or bottom. */
5442 iarg
= max (iarg
, this_scroll_margin
);
5443 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5446 arg
= make_number (iarg
);
5449 /* Skip past a partially visible first line. */
5451 XSETINT (arg
, XINT (arg
) + 1);
5453 return Fvertical_motion (arg
, window
);
5458 /***********************************************************************
5459 Window Configuration
5460 ***********************************************************************/
5462 struct save_window_data
5464 struct vectorlike_header header
;
5465 Lisp_Object selected_frame
;
5466 Lisp_Object current_window
;
5467 Lisp_Object current_buffer
;
5468 Lisp_Object minibuf_scroll_window
;
5469 Lisp_Object minibuf_selected_window
;
5470 Lisp_Object root_window
;
5471 Lisp_Object focus_frame
;
5472 /* A vector, each of whose elements is a struct saved_window
5474 Lisp_Object saved_windows
;
5476 /* All fields above are traced by the GC.
5477 From `fame-cols' down, the fields are ignored by the GC. */
5479 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5480 int frame_tool_bar_lines
;
5483 /* This is saved as a Lisp_Vector */
5486 struct vectorlike_header header
;
5488 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5489 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5490 Lisp_Object normal_cols
, normal_lines
;
5491 Lisp_Object hscroll
, min_hscroll
;
5492 Lisp_Object parent
, prev
;
5493 Lisp_Object start_at_line_beg
;
5494 Lisp_Object display_table
;
5495 Lisp_Object left_margin_cols
, right_margin_cols
;
5496 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5497 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5498 Lisp_Object combination_limit
, window_parameters
;
5501 #define SAVED_WINDOW_N(swv,n) \
5502 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5504 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5505 doc
: /* Return t if OBJECT is a window-configuration object. */)
5506 (Lisp_Object object
)
5508 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5511 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5512 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5513 (Lisp_Object config
)
5515 register struct save_window_data
*data
;
5516 struct Lisp_Vector
*saved_windows
;
5518 CHECK_WINDOW_CONFIGURATION (config
);
5520 data
= (struct save_window_data
*) XVECTOR (config
);
5521 saved_windows
= XVECTOR (data
->saved_windows
);
5522 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5525 DEFUN ("set-window-configuration", Fset_window_configuration
,
5526 Sset_window_configuration
, 1, 1, 0,
5527 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5528 CONFIGURATION must be a value previously returned
5529 by `current-window-configuration' (which see).
5530 If CONFIGURATION was made from a frame that is now deleted,
5531 only frame-independent values can be restored. In this case,
5532 the return value is nil. Otherwise the value is t. */)
5533 (Lisp_Object configuration
)
5535 register struct save_window_data
*data
;
5536 struct Lisp_Vector
*saved_windows
;
5537 Lisp_Object new_current_buffer
;
5539 Lisp_Object auto_buffer_name
;
5541 ptrdiff_t old_point
= -1;
5543 CHECK_WINDOW_CONFIGURATION (configuration
);
5545 data
= (struct save_window_data
*) XVECTOR (configuration
);
5546 saved_windows
= XVECTOR (data
->saved_windows
);
5548 new_current_buffer
= data
->current_buffer
;
5549 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5550 new_current_buffer
= Qnil
;
5553 if (XBUFFER (new_current_buffer
) == current_buffer
)
5554 /* The code further down "preserves point" by saving here PT in
5555 old_point and then setting it later back into PT. When the
5556 current-selected-window and the final-selected-window both show
5557 the current buffer, this suffers from the problem that the
5558 current PT is the window-point of the current-selected-window,
5559 while the final PT is the point of the final-selected-window, so
5560 this copy from one PT to the other would end up moving the
5561 window-point of the final-selected-window to the window-point of
5562 the current-selected-window. So we have to be careful which
5563 point of the current-buffer we copy into old_point. */
5564 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5565 && WINDOWP (selected_window
)
5566 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5567 && !EQ (selected_window
, data
->current_window
))
5568 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5572 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5573 point in new_current_buffer as of the last time this buffer was
5574 used. This can be non-deterministic since it can be changed by
5575 things like jit-lock by mere temporary selection of some random
5576 window that happens to show this buffer.
5577 So if possible we want this arbitrary choice of "which point" to
5578 be the one from the to-be-selected-window so as to prevent this
5579 window's cursor from being copied from another window. */
5580 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5581 /* If current_window = selected_window, its point is in BUF_PT. */
5582 && !EQ (selected_window
, data
->current_window
))
5583 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5585 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5588 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5591 /* If f is a dead frame, don't bother rebuilding its window tree.
5592 However, there is other stuff we should still try to do below. */
5593 if (FRAME_LIVE_P (f
))
5596 Lisp_Object dead_windows
= Qnil
;
5597 register Lisp_Object tem
, par
, pers
;
5598 register struct window
*w
;
5599 register struct saved_window
*p
;
5600 struct window
*root_window
;
5601 struct window
**leaf_windows
;
5606 /* If the frame has been resized since this window configuration was
5607 made, we change the frame to the size specified in the
5608 configuration, restore the configuration, and then resize it
5609 back. We keep track of the prevailing height in these variables. */
5610 int previous_frame_lines
= FRAME_LINES (f
);
5611 int previous_frame_cols
= FRAME_COLS (f
);
5612 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5613 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5615 /* The mouse highlighting code could get screwed up
5616 if it runs during this. */
5619 if (data
->frame_lines
!= previous_frame_lines
5620 || data
->frame_cols
!= previous_frame_cols
)
5621 change_frame_size (f
, data
->frame_lines
,
5622 data
->frame_cols
, 0, 0, 0);
5623 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5624 if (data
->frame_menu_bar_lines
5625 != previous_frame_menu_bar_lines
)
5626 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5628 #ifdef HAVE_WINDOW_SYSTEM
5629 if (data
->frame_tool_bar_lines
5630 != previous_frame_tool_bar_lines
)
5631 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5636 /* "Swap out" point from the selected window's buffer
5637 into the window itself. (Normally the pointm of the selected
5638 window holds garbage.) We do this now, before
5639 restoring the window contents, and prevent it from
5640 being done later on when we select a new window. */
5641 if (! NILP (XWINDOW (selected_window
)->buffer
))
5643 w
= XWINDOW (selected_window
);
5644 set_marker_both (w
->pointm
,
5646 BUF_PT (XBUFFER (w
->buffer
)),
5647 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5650 windows_or_buffers_changed
++;
5651 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5653 /* Problem: Freeing all matrices and later allocating them again
5654 is a serious redisplay flickering problem. What we would
5655 really like to do is to free only those matrices not reused
5657 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5658 leaf_windows
= alloca (count_windows (root_window
)
5659 * sizeof *leaf_windows
);
5660 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5663 Mark all windows now on frame as "deleted".
5664 Restoring the new configuration "undeletes" any that are in it.
5666 Save their current buffers in their height fields, since we may
5667 need it later, if a buffer saved in the configuration is now
5669 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5671 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5673 p
= SAVED_WINDOW_N (saved_windows
, k
);
5675 w
= XWINDOW (window
);
5676 wset_next (w
, Qnil
);
5678 if (!NILP (p
->parent
))
5680 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5682 wset_parent (w
, Qnil
);
5684 if (!NILP (p
->prev
))
5687 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5688 wset_next (XWINDOW (w
->prev
), p
->window
);
5692 wset_prev (w
, Qnil
);
5693 if (!NILP (w
->parent
))
5695 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5697 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5698 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5702 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5703 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5708 /* If we squirreled away the buffer in the window's height,
5710 if (BUFFERP (w
->total_lines
))
5711 wset_buffer (w
, w
->total_lines
);
5712 wset_left_col (w
, p
->left_col
);
5713 wset_top_line (w
, p
->top_line
);
5714 wset_total_cols (w
, p
->total_cols
);
5715 wset_total_lines (w
, p
->total_lines
);
5716 wset_normal_cols (w
, p
->normal_cols
);
5717 wset_normal_lines (w
, p
->normal_lines
);
5718 w
->hscroll
= XFASTINT (p
->hscroll
);
5719 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5720 wset_display_table (w
, p
->display_table
);
5721 wset_left_margin_cols (w
, p
->left_margin_cols
);
5722 wset_right_margin_cols (w
, p
->right_margin_cols
);
5723 wset_left_fringe_width (w
, p
->left_fringe_width
);
5724 wset_right_fringe_width (w
, p
->right_fringe_width
);
5725 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5726 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5727 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5728 wset_dedicated (w
, p
->dedicated
);
5729 wset_combination_limit (w
, p
->combination_limit
);
5730 /* Restore any window parameters that have been saved.
5731 Parameters that have not been saved are left alone. */
5732 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5737 if (NILP (XCDR (pers
)))
5739 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5740 if (CONSP (par
) && !NILP (XCDR (par
)))
5741 /* Reset a parameter to nil if and only if it
5742 has a non-nil association. Don't make new
5744 Fsetcdr (par
, Qnil
);
5747 /* Always restore a non-nil value. */
5748 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5752 w
->last_modified
= 0;
5753 w
->last_overlay_modified
= 0;
5755 /* Reinstall the saved buffer and pointers into it. */
5756 if (NILP (p
->buffer
))
5757 /* An internal window. */
5758 wset_buffer (w
, p
->buffer
);
5759 else if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5760 /* If saved buffer is alive, install it. */
5762 wset_buffer (w
, p
->buffer
);
5763 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5764 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5765 set_marker_restricted (w
->pointm
, p
->pointm
,
5767 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5768 p
->mark
, w
->buffer
);
5770 /* As documented in Fcurrent_window_configuration, don't
5771 restore the location of point in the buffer which was
5772 current when the window configuration was recorded. */
5773 if (!EQ (p
->buffer
, new_current_buffer
)
5774 && XBUFFER (p
->buffer
) == current_buffer
)
5775 Fgoto_char (w
->pointm
);
5777 else if (!NILP (w
->buffer
)
5778 && !NILP (BVAR (XBUFFER (w
->buffer
), name
)))
5779 /* Keep window's old buffer; make sure the markers are
5782 /* Set window markers at start of visible range. */
5783 if (XMARKER (w
->start
)->buffer
== 0)
5784 set_marker_restricted (w
->start
, make_number (0),
5786 if (XMARKER (w
->pointm
)->buffer
== 0)
5787 set_marker_restricted_both
5788 (w
->pointm
, w
->buffer
,
5789 BUF_PT (XBUFFER (w
->buffer
)),
5790 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5791 w
->start_at_line_beg
= 1;
5793 else if (STRINGP (auto_buffer_name
=
5794 Fwindow_parameter (window
, Qauto_buffer_name
))
5795 && SCHARS (auto_buffer_name
) != 0
5796 && (wset_buffer (w
, Fget_buffer_create (auto_buffer_name
)),
5799 set_marker_restricted (w
->start
,
5800 make_number (0), w
->buffer
);
5801 set_marker_restricted (w
->pointm
,
5802 make_number (0), w
->buffer
);
5803 w
->start_at_line_beg
= 1;
5806 /* Window has no live buffer, get one. */
5808 /* Get the buffer via other_buffer_safely in order to
5809 avoid showing an unimportant buffer and, if necessary, to
5810 recreate *scratch* in the course (part of Juanma's bs-show
5811 scenario from March 2011). */
5812 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5813 /* This will set the markers to beginning of visible
5815 set_marker_restricted (w
->start
,
5816 make_number (0), w
->buffer
);
5817 set_marker_restricted (w
->pointm
,
5818 make_number (0), w
->buffer
);
5819 w
->start_at_line_beg
= 1;
5820 if (!NILP (w
->dedicated
))
5821 /* Record this window as dead. */
5822 dead_windows
= Fcons (window
, dead_windows
);
5823 /* Make sure window is no more dedicated. */
5824 wset_dedicated (w
, Qnil
);
5828 fset_root_window (f
, data
->root_window
);
5829 /* Arrange *not* to restore point in the buffer that was
5830 current when the window configuration was saved. */
5831 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5832 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5833 make_number (old_point
),
5834 XWINDOW (data
->current_window
)->buffer
);
5836 /* In the following call to `select-window', prevent "swapping out
5837 point" in the old selected window using the buffer that has
5838 been restored into it. We already swapped out that point from
5839 that window's old buffer. */
5840 select_window (data
->current_window
, Qnil
, 1);
5841 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5844 if (NILP (data
->focus_frame
)
5845 || (FRAMEP (data
->focus_frame
)
5846 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5847 Fredirect_frame_focus (frame
, data
->focus_frame
);
5849 /* Set the screen height to the value it had before this function. */
5850 if (previous_frame_lines
!= FRAME_LINES (f
)
5851 || previous_frame_cols
!= FRAME_COLS (f
))
5852 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5854 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5855 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5856 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5858 #ifdef HAVE_WINDOW_SYSTEM
5859 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5860 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5865 /* Now, free glyph matrices in windows that were not reused. */
5866 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5868 if (NILP (leaf_windows
[i
]->buffer
))
5870 /* Assert it's not reused as a combination. */
5871 eassert (NILP (leaf_windows
[i
]->hchild
)
5872 && NILP (leaf_windows
[i
]->vchild
));
5873 free_window_matrices (leaf_windows
[i
]);
5875 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5882 /* Scan dead buffer windows. */
5883 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5885 window
= XCAR (dead_windows
);
5886 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5887 delete_deletable_window (window
);
5890 /* Fselect_window will have made f the selected frame, so we
5891 reselect the proper frame here. Fhandle_switch_frame will change the
5892 selected window too, but that doesn't make the call to
5893 Fselect_window above totally superfluous; it still sets f's
5895 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5896 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5898 run_window_configuration_change_hook (f
);
5901 if (!NILP (new_current_buffer
))
5902 Fset_buffer (new_current_buffer
);
5904 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5905 minibuf_selected_window
= data
->minibuf_selected_window
;
5907 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5911 /* Recursively delete all child windows reachable via the next, vchild,
5912 and hchild slots of WINDOW. */
5914 delete_all_child_windows (Lisp_Object window
)
5916 register struct window
*w
;
5918 w
= XWINDOW (window
);
5920 if (!NILP (w
->next
))
5921 /* Delete WINDOW's siblings (we traverse postorderly). */
5922 delete_all_child_windows (w
->next
);
5924 /* See Fset_window_configuration for excuse. */
5925 wset_total_lines (w
, w
->buffer
);
5927 if (!NILP (w
->vchild
))
5929 delete_all_child_windows (w
->vchild
);
5930 wset_vchild (w
, Qnil
);
5932 else if (!NILP (w
->hchild
))
5934 delete_all_child_windows (w
->hchild
);
5935 wset_hchild (w
, Qnil
);
5937 else if (!NILP (w
->buffer
))
5940 unchain_marker (XMARKER (w
->pointm
));
5941 unchain_marker (XMARKER (w
->start
));
5942 wset_buffer (w
, Qnil
);
5945 Vwindow_list
= Qnil
;
5949 count_windows (register struct window
*window
)
5951 register int count
= 1;
5952 if (!NILP (window
->next
))
5953 count
+= count_windows (XWINDOW (window
->next
));
5954 if (!NILP (window
->vchild
))
5955 count
+= count_windows (XWINDOW (window
->vchild
));
5956 if (!NILP (window
->hchild
))
5957 count
+= count_windows (XWINDOW (window
->hchild
));
5962 /* Fill vector FLAT with leaf windows under W, starting at index I.
5963 Value is last index + 1. */
5965 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5969 if (!NILP (w
->hchild
))
5970 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5971 else if (!NILP (w
->vchild
))
5972 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5976 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5983 /* Return a pointer to the glyph W's physical cursor is on. Value is
5984 null if W's current matrix is invalid, so that no meaningful glyph
5987 get_phys_cursor_glyph (struct window
*w
)
5989 struct glyph_row
*row
;
5990 struct glyph
*glyph
;
5991 int hpos
= w
->phys_cursor
.hpos
;
5993 if (!(w
->phys_cursor
.vpos
>= 0
5994 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5997 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5998 if (!row
->enabled_p
)
6003 /* When the window is hscrolled, cursor hpos can legitimately be
6004 out of bounds, but we draw the cursor at the corresponding
6005 window margin in that case. */
6006 if (!row
->reversed_p
&& hpos
< 0)
6008 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
6009 hpos
= row
->used
[TEXT_AREA
] - 1;
6012 if (row
->used
[TEXT_AREA
] > hpos
6014 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
6023 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6025 register struct saved_window
*p
;
6026 register struct window
*w
;
6027 register Lisp_Object tem
, pers
, par
;
6029 for (;!NILP (window
); window
= w
->next
)
6031 p
= SAVED_WINDOW_N (vector
, i
);
6032 w
= XWINDOW (window
);
6034 wset_temslot (w
, make_number (i
)); i
++;
6036 p
->buffer
= w
->buffer
;
6037 p
->left_col
= w
->left_col
;
6038 p
->top_line
= w
->top_line
;
6039 p
->total_cols
= w
->total_cols
;
6040 p
->total_lines
= w
->total_lines
;
6041 p
->normal_cols
= w
->normal_cols
;
6042 p
->normal_lines
= w
->normal_lines
;
6043 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6044 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6045 p
->display_table
= w
->display_table
;
6046 p
->left_margin_cols
= w
->left_margin_cols
;
6047 p
->right_margin_cols
= w
->right_margin_cols
;
6048 p
->left_fringe_width
= w
->left_fringe_width
;
6049 p
->right_fringe_width
= w
->right_fringe_width
;
6050 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6051 p
->scroll_bar_width
= w
->scroll_bar_width
;
6052 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6053 p
->dedicated
= w
->dedicated
;
6054 p
->combination_limit
= w
->combination_limit
;
6055 p
->window_parameters
= Qnil
;
6057 if (!NILP (Vwindow_persistent_parameters
))
6059 /* Run cycle detection on Vwindow_persistent_parameters. */
6060 Lisp_Object tortoise
, hare
;
6062 hare
= tortoise
= Vwindow_persistent_parameters
;
6063 while (CONSP (hare
))
6070 tortoise
= XCDR (tortoise
);
6072 if (EQ (hare
, tortoise
))
6073 /* Reset Vwindow_persistent_parameters to Qnil. */
6075 Vwindow_persistent_parameters
= Qnil
;
6080 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6084 /* Save values for persistent window parameters. */
6085 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6087 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6089 /* If the window has no value for the parameter,
6091 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6092 p
->window_parameters
);
6094 /* If the window has a value for the parameter,
6096 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6098 p
->window_parameters
);
6103 if (!NILP (w
->buffer
))
6105 /* Save w's value of point in the window configuration. If w
6106 is the selected window, then get the value of point from
6107 the buffer; pointm is garbage in the selected window. */
6108 if (EQ (window
, selected_window
))
6109 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6110 BUF_PT (XBUFFER (w
->buffer
)),
6111 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6113 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6114 XMARKER (p
->pointm
)->insertion_type
6115 = !NILP (Vwindow_point_insertion_type
);
6117 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6118 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6120 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6121 p
->mark
= Fcopy_marker (tem
, Qnil
);
6128 p
->start_at_line_beg
= Qnil
;
6131 if (NILP (w
->parent
))
6134 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6139 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6141 if (!NILP (w
->vchild
))
6142 i
= save_window_save (w
->vchild
, vector
, i
);
6143 if (!NILP (w
->hchild
))
6144 i
= save_window_save (w
->hchild
, vector
, i
);
6150 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6151 Scurrent_window_configuration
, 0, 1, 0,
6152 doc
: /* Return an object representing the current window configuration of FRAME.
6153 If FRAME is nil or omitted, use the selected frame.
6154 This describes the number of windows, their sizes and current buffers,
6155 and for each displayed buffer, where display starts, and the positions of
6156 point and mark. An exception is made for point in the current buffer:
6157 its value is -not- saved.
6158 This also records the currently selected frame, and FRAME's focus
6159 redirection (see `redirect-frame-focus'). The variable
6160 `window-persistent-parameters' specifies which window parameters are
6161 saved by this function. */)
6164 register Lisp_Object tem
;
6165 register int n_windows
;
6166 register struct save_window_data
*data
;
6171 frame
= selected_frame
;
6172 CHECK_LIVE_FRAME (frame
);
6175 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6176 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6177 PVEC_WINDOW_CONFIGURATION
);
6179 data
->frame_cols
= FRAME_COLS (f
);
6180 data
->frame_lines
= FRAME_LINES (f
);
6181 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6182 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6183 data
->selected_frame
= selected_frame
;
6184 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6185 XSETBUFFER (data
->current_buffer
, current_buffer
);
6186 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6187 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6188 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6189 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6190 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6191 data
->saved_windows
= tem
;
6192 for (i
= 0; i
< n_windows
; i
++)
6194 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6195 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6196 XSETWINDOW_CONFIGURATION (tem
, data
);
6200 /***********************************************************************
6202 ***********************************************************************/
6204 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6206 doc
: /* Set width of marginal areas of window WINDOW.
6207 WINDOW must be a live window and defaults to the selected one.
6209 Second arg LEFT-WIDTH specifies the number of character cells to
6210 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6211 does the same for the right marginal area. A nil width parameter
6212 means no margin. */)
6213 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6215 struct window
*w
= decode_live_window (window
);
6217 /* Translate negative or zero widths to nil.
6218 Margins that are too wide have to be checked elsewhere. */
6220 if (!NILP (left_width
))
6222 CHECK_NUMBER (left_width
);
6223 if (XINT (left_width
) <= 0)
6227 if (!NILP (right_width
))
6229 CHECK_NUMBER (right_width
);
6230 if (XINT (right_width
) <= 0)
6234 if (!EQ (w
->left_margin_cols
, left_width
)
6235 || !EQ (w
->right_margin_cols
, right_width
))
6237 wset_left_margin_cols (w
, left_width
);
6238 wset_right_margin_cols (w
, right_width
);
6240 adjust_window_margins (w
);
6242 ++windows_or_buffers_changed
;
6243 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6250 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6252 doc
: /* Get width of marginal areas of window WINDOW.
6253 WINDOW must be a live window and defaults to the selected one.
6255 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6256 If a marginal area does not exist, its width will be returned
6258 (Lisp_Object window
)
6260 struct window
*w
= decode_live_window (window
);
6261 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6266 /***********************************************************************
6268 ***********************************************************************/
6270 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6272 doc
: /* Set the fringe widths of window WINDOW.
6273 WINDOW must be a live window and defaults to the selected one.
6275 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6276 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6277 fringe width. If a fringe width arg is nil, that means to use the
6278 frame's default fringe width. Default fringe widths can be set with
6279 the command `set-fringe-style'.
6280 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6281 outside of the display margins. By default, fringes are drawn between
6282 display marginal areas and the text area. */)
6283 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6285 struct window
*w
= decode_live_window (window
);
6286 int outside
= !NILP (outside_margins
);
6288 if (!NILP (left_width
))
6289 CHECK_NATNUM (left_width
);
6290 if (!NILP (right_width
))
6291 CHECK_NATNUM (right_width
);
6293 /* Do nothing on a tty. */
6294 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6295 && (!EQ (w
->left_fringe_width
, left_width
)
6296 || !EQ (w
->right_fringe_width
, right_width
)
6297 || w
->fringes_outside_margins
!= outside
))
6299 wset_left_fringe_width (w
, left_width
);
6300 wset_right_fringe_width (w
, right_width
);
6301 w
->fringes_outside_margins
= outside
;
6303 adjust_window_margins (w
);
6305 clear_glyph_matrix (w
->current_matrix
);
6306 wset_window_end_valid (w
, Qnil
);
6308 ++windows_or_buffers_changed
;
6309 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6316 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6318 doc
: /* Get width of fringes of window WINDOW.
6319 WINDOW must be a live window and defaults to the selected one.
6321 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6322 (Lisp_Object window
)
6324 struct window
*w
= decode_live_window (window
);
6326 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6327 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6328 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6329 ? Qt
: Qnil
), Qnil
)));
6334 /***********************************************************************
6336 ***********************************************************************/
6338 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6339 Sset_window_scroll_bars
, 2, 4, 0,
6340 doc
: /* Set width and type of scroll bars of window WINDOW.
6341 WINDOW must be a live window and defaults to the selected one.
6343 Second parameter WIDTH specifies the pixel width for the scroll bar;
6344 this is automatically adjusted to a multiple of the frame column width.
6345 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6346 bar: left, right, or nil.
6347 If WIDTH is nil, use the frame's scroll-bar width.
6348 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6349 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6350 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6352 struct window
*w
= decode_live_window (window
);
6356 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6358 if (XINT (width
) == 0)
6359 vertical_type
= Qnil
;
6362 if (!(NILP (vertical_type
)
6363 || EQ (vertical_type
, Qleft
)
6364 || EQ (vertical_type
, Qright
)
6365 || EQ (vertical_type
, Qt
)))
6366 error ("Invalid type of vertical scroll bar");
6368 if (!EQ (w
->scroll_bar_width
, width
)
6369 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6371 wset_scroll_bar_width (w
, width
);
6372 wset_vertical_scroll_bar_type (w
, vertical_type
);
6374 adjust_window_margins (w
);
6376 clear_glyph_matrix (w
->current_matrix
);
6377 wset_window_end_valid (w
, Qnil
);
6379 ++windows_or_buffers_changed
;
6380 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6387 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6389 doc
: /* Get width and type of scroll bars of window WINDOW.
6390 WINDOW must be a live window and defaults to the selected one.
6392 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6393 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6395 (Lisp_Object window
)
6397 struct window
*w
= decode_live_window (window
);
6398 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6399 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6400 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6401 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6402 Fcons (w
->vertical_scroll_bar_type
,
6403 Fcons (Qnil
, Qnil
))));
6408 /***********************************************************************
6410 ***********************************************************************/
6412 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6413 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6414 If WINDOW is omitted or nil, it defaults to the selected window.
6415 Normally, value is a multiple of the canonical character height of WINDOW;
6416 optional second arg PIXELS-P means value is measured in pixels. */)
6417 (Lisp_Object window
, Lisp_Object pixels_p
)
6424 window
= selected_window
;
6426 CHECK_WINDOW (window
);
6427 w
= XWINDOW (window
);
6428 f
= XFRAME (w
->frame
);
6430 if (FRAME_WINDOW_P (f
))
6431 result
= (NILP (pixels_p
)
6432 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6433 : make_number (-w
->vscroll
));
6435 result
= make_number (0);
6440 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6442 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6443 WINDOW nil means use the selected window. Normally, VSCROLL is a
6444 non-negative multiple of the canonical character height of WINDOW;
6445 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6446 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6447 corresponds to an integral number of pixels. The return value is the
6448 result of this rounding.
6449 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6450 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6456 window
= selected_window
;
6458 CHECK_WINDOW (window
);
6459 CHECK_NUMBER_OR_FLOAT (vscroll
);
6461 w
= XWINDOW (window
);
6462 f
= XFRAME (w
->frame
);
6464 if (FRAME_WINDOW_P (f
))
6466 int old_dy
= w
->vscroll
;
6468 w
->vscroll
= - (NILP (pixels_p
)
6469 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6470 : XFLOATINT (vscroll
));
6471 w
->vscroll
= min (w
->vscroll
, 0);
6473 if (w
->vscroll
!= old_dy
)
6475 /* Adjust glyph matrix of the frame if the virtual display
6476 area becomes larger than before. */
6477 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6480 /* Prevent redisplay shortcuts. */
6481 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6485 return Fwindow_vscroll (window
, pixels_p
);
6489 /* Call FN for all leaf windows on frame F. FN is called with the
6490 first argument being a pointer to the leaf window, and with
6491 additional argument USER_DATA. Stops when FN returns 0. */
6494 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6497 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6498 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6499 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6503 /* Helper function for foreach_window. Call FN for all leaf windows
6504 reachable from W. FN is called with the first argument being a
6505 pointer to the leaf window, and with additional argument USER_DATA.
6506 Stop when FN returns 0. Value is 0 if stopped by FN. */
6509 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6513 for (cont
= 1; w
&& cont
;)
6515 if (!NILP (w
->hchild
))
6516 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6517 else if (!NILP (w
->vchild
))
6518 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6520 cont
= fn (w
, user_data
);
6522 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6529 /* Freeze or unfreeze the window start of W unless it is a
6530 mini-window or the selected window. FREEZE_P non-null means freeze
6531 the window start. */
6534 freeze_window_start (struct window
*w
, void *freeze_p
)
6536 if (MINI_WINDOW_P (w
)
6537 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6538 && (w
== XWINDOW (selected_window
)
6539 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6540 && ! NILP (Vminibuf_scroll_window
)
6541 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6544 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6549 /* Freeze or unfreeze the window starts of all leaf windows on frame
6550 F, except the selected window and a mini-window. FREEZE_P non-zero
6551 means freeze the window start. */
6554 freeze_window_starts (struct frame
*f
, int freeze_p
)
6556 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6560 /***********************************************************************
6562 ***********************************************************************/
6564 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6565 describe the same state of affairs. This is used by Fequal.
6567 ignore_positions non-zero means ignore non-matching scroll positions
6570 This ignores a couple of things like the dedication status of
6571 window, combination_limit and the like. This might have to be
6575 compare_window_configurations (Lisp_Object configuration1
, Lisp_Object configuration2
, int ignore_positions
)
6577 register struct save_window_data
*d1
, *d2
;
6578 struct Lisp_Vector
*sws1
, *sws2
;
6581 CHECK_WINDOW_CONFIGURATION (configuration1
);
6582 CHECK_WINDOW_CONFIGURATION (configuration2
);
6584 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6585 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6586 sws1
= XVECTOR (d1
->saved_windows
);
6587 sws2
= XVECTOR (d2
->saved_windows
);
6589 /* Frame settings must match. */
6590 if (d1
->frame_cols
!= d2
->frame_cols
6591 || d1
->frame_lines
!= d2
->frame_lines
6592 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6593 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6594 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6595 || (!ignore_positions
6596 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6597 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6598 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6599 /* Verify that the two configurations have the same number of windows. */
6600 || sws1
->header
.size
!= sws2
->header
.size
)
6603 for (i
= 0; i
< sws1
->header
.size
; i
++)
6605 struct saved_window
*sw1
, *sw2
;
6607 sw1
= SAVED_WINDOW_N (sws1
, i
);
6608 sw2
= SAVED_WINDOW_N (sws2
, i
);
6611 /* The "current" windows in the two configurations must
6612 correspond to each other. */
6613 EQ (d1
->current_window
, sw1
->window
)
6614 != EQ (d2
->current_window
, sw2
->window
)
6615 /* Windows' buffers must match. */
6616 || !EQ (sw1
->buffer
, sw2
->buffer
)
6617 || !EQ (sw1
->left_col
, sw2
->left_col
)
6618 || !EQ (sw1
->top_line
, sw2
->top_line
)
6619 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6620 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6621 || !EQ (sw1
->display_table
, sw2
->display_table
)
6622 /* The next two disjuncts check the window structure for
6624 || !EQ (sw1
->parent
, sw2
->parent
)
6625 || !EQ (sw1
->prev
, sw2
->prev
)
6626 || (!ignore_positions
6627 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6628 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6629 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6630 || NILP (Fequal (sw1
->start
, sw2
->start
))
6631 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6632 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6633 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6634 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6635 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6636 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6637 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6638 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6639 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6646 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6647 Scompare_window_configurations
, 2, 2, 0,
6648 doc
: /* Compare two window configurations as regards the structure of windows.
6649 This function ignores details such as the values of point and mark
6650 and scrolling positions. */)
6651 (Lisp_Object x
, Lisp_Object y
)
6653 if (compare_window_configurations (x
, y
, 1))
6659 init_window_once (void)
6661 struct frame
*f
= make_initial_frame ();
6662 XSETFRAME (selected_frame
, f
);
6663 Vterminal_frame
= selected_frame
;
6664 minibuf_window
= f
->minibuffer_window
;
6665 selected_window
= f
->selected_window
;
6666 last_nonminibuf_frame
= f
;
6668 window_initialized
= 1;
6674 Vwindow_list
= Qnil
;
6678 syms_of_window (void)
6680 DEFSYM (Qscroll_up
, "scroll-up");
6681 DEFSYM (Qscroll_down
, "scroll-down");
6682 DEFSYM (Qscroll_command
, "scroll-command");
6684 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6685 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6687 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6688 DEFSYM (Qwindowp
, "windowp");
6689 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6690 DEFSYM (Qwindow_live_p
, "window-live-p");
6691 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6692 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6693 DEFSYM (Qdelete_window
, "delete-window");
6694 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6695 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6696 DEFSYM (Qsafe
, "safe");
6697 DEFSYM (Qdisplay_buffer
, "display-buffer");
6698 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6699 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6700 DEFSYM (Qget_mru_window
, "get-mru-window");
6701 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6702 DEFSYM (Qabove
, "above");
6703 DEFSYM (Qbelow
, "below");
6704 DEFSYM (Qauto_buffer_name
, "auto-buffer-name");
6705 DEFSYM (Qclone_of
, "clone-of");
6707 staticpro (&Vwindow_list
);
6709 minibuf_selected_window
= Qnil
;
6710 staticpro (&minibuf_selected_window
);
6712 window_scroll_pixel_based_preserve_x
= -1;
6713 window_scroll_pixel_based_preserve_y
= -1;
6714 window_scroll_preserve_hpos
= -1;
6715 window_scroll_preserve_vpos
= -1;
6717 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6718 doc
: /* Non-nil means call as function to display a help buffer.
6719 The function is called with one argument, the buffer to be displayed.
6720 Used by `with-output-to-temp-buffer'.
6721 If this function is used, then it must do the entire job of showing
6722 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6723 Vtemp_buffer_show_function
= Qnil
;
6725 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6726 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6727 Vminibuf_scroll_window
= Qnil
;
6729 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6730 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6731 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6732 is displayed in the `mode-line' face. */);
6733 mode_line_in_non_selected_windows
= 1;
6735 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6736 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6737 Vother_window_scroll_buffer
= Qnil
;
6739 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6740 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6741 auto_window_vscroll_p
= 1;
6743 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6744 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6745 next_screen_context_lines
= 2;
6747 DEFVAR_LISP ("scroll-preserve-screen-position",
6748 Vscroll_preserve_screen_position
,
6749 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6750 A value of nil means point does not keep its screen position except
6751 at the scroll margin or window boundary respectively.
6752 A value of t means point keeps its screen position if the scroll
6753 command moved it vertically out of the window, e.g. when scrolling
6755 Any other value means point always keeps its screen position.
6756 Scroll commands should have the `scroll-command' property
6757 on their symbols to be controlled by this variable. */);
6758 Vscroll_preserve_screen_position
= Qnil
;
6760 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6761 doc
: /* Type of marker to use for `window-point'. */);
6762 Vwindow_point_insertion_type
= Qnil
;
6764 DEFVAR_LISP ("window-configuration-change-hook",
6765 Vwindow_configuration_change_hook
,
6766 doc
: /* Functions to call when window configuration changes.
6767 The buffer-local part is run once per window, with the relevant window
6768 selected; while the global part is run only once for the modified frame,
6769 with the relevant frame selected. */);
6770 Vwindow_configuration_change_hook
= Qnil
;
6772 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6773 doc
: /* Non-nil means `recenter' redraws entire frame.
6774 If this option is non-nil, then the `recenter' command with a nil
6775 argument will redraw the entire frame; the special value `tty' causes
6776 the frame to be redrawn only if it is a tty frame. */);
6777 Vrecenter_redisplay
= Qtty
;
6779 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6780 doc
: /* If t, resize window combinations proportionally.
6781 If this variable is nil, splitting a window gets the entire screen space
6782 for displaying the new window from the window to split. Deleting and
6783 resizing a window preferably resizes one adjacent window only.
6785 If this variable is t, splitting a window tries to get the space
6786 proportionally from all windows in the same combination. This also
6787 allows to split a window that is otherwise too small or of fixed size.
6788 Resizing and deleting a window proportionally resize all windows in the
6791 Other values are reserved for future use.
6793 This variable takes no effect if `window-combination-limit' is non-nil. */);
6794 Vwindow_combination_resize
= Qnil
;
6796 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6797 doc
: /* If t, splitting a window makes a new parent window.
6798 If this variable is nil, splitting a window will create a new parent
6799 window only if the window has no parent window or the window shall
6800 become a combination orthogonal to the one it is part of.
6802 If this variable is t, splitting a window always creates a new parent
6803 window. If all splits behave this way, each frame's window tree is a
6804 binary tree and every window but the frame's root window has exactly one
6807 Other values are reserved for future use.
6809 The value of this variable is also assigned to the combination limit of
6810 the new parent window. The combination limit of a window can be
6811 retrieved via the function `window-combination-limit' and altered by the
6812 function `set-window-combination-limit'. */);
6813 Vwindow_combination_limit
= Qnil
;
6815 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6816 doc
: /* Alist of persistent window parameters.
6817 This alist specifies which window parameters shall get saved by
6818 `current-window-configuration' and `window-state-get' and subsequently
6819 restored to their previous values by `set-window-configuration' and
6822 The car of each entry of this alist is the symbol specifying the
6823 parameter. The cdr is one of the following:
6825 nil means the parameter is neither saved by `window-state-get' nor by
6826 `current-window-configuration'.
6828 t means the parameter is saved by `current-window-configuration' and,
6829 provided its WRITABLE argument is nil, by `window-state-get'.
6831 The symbol `writable' means the parameter is saved unconditionally by
6832 both `current-window-configuration' and `window-state-get'. Do not use
6833 this value for parameters without read syntax (like windows or frames).
6835 Parameters not saved by `current-window-configuration' or
6836 `window-state-get' are left alone by `set-window-configuration'
6837 respectively are not installed by `window-state-put'. */);
6838 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6840 defsubr (&Sselected_window
);
6841 defsubr (&Sminibuffer_window
);
6842 defsubr (&Swindow_minibuffer_p
);
6843 defsubr (&Swindowp
);
6844 defsubr (&Swindow_valid_p
);
6845 defsubr (&Swindow_live_p
);
6846 defsubr (&Swindow_frame
);
6847 defsubr (&Sframe_root_window
);
6848 defsubr (&Sframe_first_window
);
6849 defsubr (&Sframe_selected_window
);
6850 defsubr (&Sset_frame_selected_window
);
6851 defsubr (&Spos_visible_in_window_p
);
6852 defsubr (&Swindow_line_height
);
6853 defsubr (&Swindow_buffer
);
6854 defsubr (&Swindow_parent
);
6855 defsubr (&Swindow_top_child
);
6856 defsubr (&Swindow_left_child
);
6857 defsubr (&Swindow_next_sibling
);
6858 defsubr (&Swindow_prev_sibling
);
6859 defsubr (&Swindow_combination_limit
);
6860 defsubr (&Sset_window_combination_limit
);
6861 defsubr (&Swindow_use_time
);
6862 defsubr (&Swindow_top_line
);
6863 defsubr (&Swindow_left_column
);
6864 defsubr (&Swindow_total_height
);
6865 defsubr (&Swindow_total_width
);
6866 defsubr (&Swindow_normal_size
);
6867 defsubr (&Swindow_new_total
);
6868 defsubr (&Swindow_new_normal
);
6869 defsubr (&Sset_window_new_total
);
6870 defsubr (&Sset_window_new_normal
);
6871 defsubr (&Swindow_resize_apply
);
6872 defsubr (&Swindow_body_height
);
6873 defsubr (&Swindow_body_width
);
6874 defsubr (&Swindow_hscroll
);
6875 defsubr (&Sset_window_hscroll
);
6876 defsubr (&Swindow_redisplay_end_trigger
);
6877 defsubr (&Sset_window_redisplay_end_trigger
);
6878 defsubr (&Swindow_edges
);
6879 defsubr (&Swindow_pixel_edges
);
6880 defsubr (&Swindow_absolute_pixel_edges
);
6881 defsubr (&Swindow_inside_edges
);
6882 defsubr (&Swindow_inside_pixel_edges
);
6883 defsubr (&Swindow_inside_absolute_pixel_edges
);
6884 defsubr (&Scoordinates_in_window_p
);
6885 defsubr (&Swindow_at
);
6886 defsubr (&Swindow_point
);
6887 defsubr (&Swindow_start
);
6888 defsubr (&Swindow_end
);
6889 defsubr (&Sset_window_point
);
6890 defsubr (&Sset_window_start
);
6891 defsubr (&Swindow_dedicated_p
);
6892 defsubr (&Sset_window_dedicated_p
);
6893 defsubr (&Swindow_display_table
);
6894 defsubr (&Sset_window_display_table
);
6895 defsubr (&Snext_window
);
6896 defsubr (&Sprevious_window
);
6897 defsubr (&Sget_buffer_window
);
6898 defsubr (&Sdelete_other_windows_internal
);
6899 defsubr (&Sdelete_window_internal
);
6900 defsubr (&Sresize_mini_window_internal
);
6901 defsubr (&Sset_window_buffer
);
6902 defsubr (&Srun_window_configuration_change_hook
);
6903 defsubr (&Sselect_window
);
6904 defsubr (&Sforce_window_update
);
6905 defsubr (&Stemp_output_buffer_show
);
6906 defsubr (&Ssplit_window_internal
);
6907 defsubr (&Sscroll_up
);
6908 defsubr (&Sscroll_down
);
6909 defsubr (&Sscroll_left
);
6910 defsubr (&Sscroll_right
);
6911 defsubr (&Sother_window_for_scrolling
);
6912 defsubr (&Sscroll_other_window
);
6913 defsubr (&Sminibuffer_selected_window
);
6914 defsubr (&Srecenter
);
6915 defsubr (&Swindow_text_height
);
6916 defsubr (&Smove_to_window_line
);
6917 defsubr (&Swindow_configuration_p
);
6918 defsubr (&Swindow_configuration_frame
);
6919 defsubr (&Sset_window_configuration
);
6920 defsubr (&Scurrent_window_configuration
);
6921 defsubr (&Sset_window_margins
);
6922 defsubr (&Swindow_margins
);
6923 defsubr (&Sset_window_fringes
);
6924 defsubr (&Swindow_fringes
);
6925 defsubr (&Sset_window_scroll_bars
);
6926 defsubr (&Swindow_scroll_bars
);
6927 defsubr (&Swindow_vscroll
);
6928 defsubr (&Sset_window_vscroll
);
6929 defsubr (&Scompare_window_configurations
);
6930 defsubr (&Swindow_list
);
6931 defsubr (&Swindow_list_1
);
6932 defsubr (&Swindow_prev_buffers
);
6933 defsubr (&Sset_window_prev_buffers
);
6934 defsubr (&Swindow_next_buffers
);
6935 defsubr (&Sset_window_next_buffers
);
6936 defsubr (&Swindow_parameters
);
6937 defsubr (&Swindow_parameter
);
6938 defsubr (&Sset_window_parameter
);
6942 keys_of_window (void)
6944 initial_define_key (control_x_map
, '<', "scroll-left");
6945 initial_define_key (control_x_map
, '>', "scroll-right");
6947 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6948 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6949 initial_define_key (meta_map
, 'v', "scroll-down-command");