1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2013 Free Software
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #define WINDOW_INLINE EXTERN_INLINE
28 #include "character.h"
38 #include "dispextern.h"
39 #include "blockinput.h"
40 #include "intervals.h"
41 #include "termhooks.h" /* For FRAME_TERMINAL. */
45 #endif /* HAVE_X_WINDOWS */
56 Lisp_Object Qwindowp
, Qwindow_live_p
;
57 static Lisp_Object Qwindow_valid_p
;
58 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
59 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
60 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
61 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
62 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
63 static Lisp_Object Qsafe
, Qabove
, Qbelow
, Qwindow_size
, Qclone_of
;
65 static int displayed_window_lines (struct window
*);
66 static int count_windows (struct window
*);
67 static int get_leaf_windows (struct window
*, struct window
**, int);
68 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
69 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
70 static void window_scroll_line_based (Lisp_Object
, int, int, int);
71 static int freeze_window_start (struct window
*, void *);
72 static Lisp_Object
window_list (void);
73 static int add_window_to_list (struct window
*, void *);
74 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
80 static void foreach_window (struct frame
*,
81 int (* fn
) (struct window
*, void *),
83 static int foreach_window_1 (struct window
*,
84 int (* fn
) (struct window
*, void *),
86 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
87 static int window_resize_check (struct window
*, int);
88 static void window_resize_apply (struct window
*, int);
89 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
90 static void select_window_1 (Lisp_Object
, bool);
92 /* This is the window in which the terminal's cursor should
93 be left when nothing is being done with it. This must
94 always be a leaf window, and its buffer is selected by
95 the top level editing loop at the end of each command.
97 This value is always the same as
98 FRAME_SELECTED_WINDOW (selected_frame). */
99 Lisp_Object selected_window
;
101 /* A list of all windows for use by next_window and Fwindow_list.
102 Functions creating or deleting windows should invalidate this cache
103 by setting it to nil. */
104 Lisp_Object Vwindow_list
;
106 /* The mini-buffer window of the selected frame.
107 Note that you cannot test for mini-bufferness of an arbitrary window
108 by comparing against this; but you can test for mini-bufferness of
109 the selected window. */
110 Lisp_Object minibuf_window
;
112 /* Non-nil means it is the window whose mode line should be
113 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Hook run at end of temp_output_buffer_show. */
117 static Lisp_Object Qtemp_buffer_show_hook
;
119 /* Nonzero after init_window_once has finished. */
120 static int window_initialized
;
122 /* Hook to run when window config changes. */
123 static Lisp_Object Qwindow_configuration_change_hook
;
125 /* Used by the function window_scroll_pixel_based */
126 static int window_scroll_pixel_based_preserve_x
;
127 static int window_scroll_pixel_based_preserve_y
;
129 /* Same for window_scroll_line_based. */
130 static EMACS_INT window_scroll_preserve_hpos
;
131 static EMACS_INT window_scroll_preserve_vpos
;
133 /* These setters are used only in this file, so they can be private. */
135 wset_combination_limit (struct window
*w
, Lisp_Object val
)
137 w
->combination_limit
= val
;
140 wset_dedicated (struct window
*w
, Lisp_Object val
)
145 wset_display_table (struct window
*w
, Lisp_Object val
)
147 w
->display_table
= val
;
150 wset_hchild (struct window
*w
, Lisp_Object val
)
155 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
157 w
->left_fringe_width
= val
;
160 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
162 w
->left_margin_cols
= val
;
165 wset_new_normal (struct window
*w
, Lisp_Object val
)
170 wset_new_total (struct window
*w
, Lisp_Object val
)
175 wset_normal_cols (struct window
*w
, Lisp_Object val
)
177 w
->normal_cols
= val
;
180 wset_normal_lines (struct window
*w
, Lisp_Object val
)
182 w
->normal_lines
= val
;
185 wset_parent (struct window
*w
, Lisp_Object val
)
190 wset_pointm (struct window
*w
, Lisp_Object val
)
195 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
197 w
->right_fringe_width
= val
;
200 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
202 w
->right_margin_cols
= val
;
205 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
207 w
->scroll_bar_width
= val
;
210 wset_start (struct window
*w
, Lisp_Object val
)
215 wset_temslot (struct window
*w
, Lisp_Object val
)
220 wset_vchild (struct window
*w
, Lisp_Object val
)
225 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
227 w
->vertical_scroll_bar_type
= val
;
230 wset_window_parameters (struct window
*w
, Lisp_Object val
)
232 w
->window_parameters
= val
;
236 decode_live_window (register Lisp_Object window
)
239 return XWINDOW (selected_window
);
241 CHECK_LIVE_WINDOW (window
);
242 return XWINDOW (window
);
246 decode_any_window (register Lisp_Object window
)
251 return XWINDOW (selected_window
);
253 CHECK_WINDOW (window
);
254 w
= XWINDOW (window
);
258 static struct window
*
259 decode_valid_window (register Lisp_Object window
)
264 return XWINDOW (selected_window
);
266 CHECK_VALID_WINDOW (window
);
267 w
= XWINDOW (window
);
271 /* Called when W's buffer slot is changed. ARG -1 means that W is about to
272 cease its buffer, and 1 means that W is about to set up the new one. */
275 adjust_window_count (struct window
*w
, int arg
)
277 eassert (eabs (arg
) == 1);
278 if (BUFFERP (w
->buffer
))
280 struct buffer
*b
= XBUFFER (w
->buffer
);
284 b
->window_count
+= arg
;
285 eassert (b
->window_count
>= 0);
286 /* These should be recalculated by redisplay code. */
287 w
->window_end_valid
= 0;
288 w
->base_line_pos
= 0;
292 /* Set W's buffer slot to VAL and recompute number
293 of windows showing VAL if it is a buffer. */
296 wset_buffer (struct window
*w
, Lisp_Object val
)
298 adjust_window_count (w
, -1);
300 adjust_window_count (w
, 1);
303 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
304 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
307 return WINDOWP (object
) ? Qt
: Qnil
;
310 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
311 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
312 A valid window is either a window that displays a buffer or an internal
313 window. Deleted windows are not live. */)
316 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
319 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
320 doc
: /* Return t if OBJECT is a live window and nil otherwise.
321 A live window is a window that displays a buffer.
322 Internal windows and deleted windows are not live. */)
325 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
328 /* Frames and windows. */
329 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
330 doc
: /* Return the frame that window WINDOW is on.
331 WINDOW must be a valid window and defaults to the selected one. */)
334 return decode_valid_window (window
)->frame
;
337 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
338 doc
: /* Return the root window of FRAME-OR-WINDOW.
339 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
340 With a frame argument, return that frame's root window.
341 With a window argument, return the root window of that window's frame. */)
342 (Lisp_Object frame_or_window
)
346 if (NILP (frame_or_window
))
347 window
= SELECTED_FRAME ()->root_window
;
348 else if (WINDOW_VALID_P (frame_or_window
))
349 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
352 CHECK_LIVE_FRAME (frame_or_window
);
353 window
= XFRAME (frame_or_window
)->root_window
;
359 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
360 doc
: /* Return the minibuffer window for frame FRAME.
361 If FRAME is omitted or nil, it defaults to the selected frame. */)
364 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
367 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
368 Swindow_minibuffer_p
, 0, 1, 0,
369 doc
: /* Return non-nil if WINDOW is a minibuffer window.
370 WINDOW must be a valid window and defaults to the selected one. */)
373 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
376 /* Don't move this to window.el - this must be a safe routine. */
377 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
378 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
379 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
380 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
381 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
382 the first window of that frame. */)
383 (Lisp_Object frame_or_window
)
387 if (NILP (frame_or_window
))
388 window
= SELECTED_FRAME ()->root_window
;
389 else if (WINDOW_VALID_P (frame_or_window
))
390 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
393 CHECK_LIVE_FRAME (frame_or_window
);
394 window
= XFRAME (frame_or_window
)->root_window
;
397 while (NILP (XWINDOW (window
)->buffer
))
399 if (! NILP (XWINDOW (window
)->hchild
))
400 window
= XWINDOW (window
)->hchild
;
401 else if (! NILP (XWINDOW (window
)->vchild
))
402 window
= XWINDOW (window
)->vchild
;
410 DEFUN ("frame-selected-window", Fframe_selected_window
,
411 Sframe_selected_window
, 0, 1, 0,
412 doc
: /* Return the selected window of FRAME-OR-WINDOW.
413 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
414 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
415 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
416 return the selected window of that frame. */)
417 (Lisp_Object frame_or_window
)
421 if (NILP (frame_or_window
))
422 window
= SELECTED_FRAME ()->selected_window
;
423 else if (WINDOW_VALID_P (frame_or_window
))
424 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
427 CHECK_LIVE_FRAME (frame_or_window
);
428 window
= XFRAME (frame_or_window
)->selected_window
;
434 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
435 Sset_frame_selected_window
, 2, 3, 0,
436 doc
: /* Set selected window of FRAME to WINDOW.
437 FRAME must be a live frame and defaults to the selected one. If FRAME
438 is the selected frame, this makes WINDOW the selected window. Optional
439 argument NORECORD non-nil means to neither change the order of recently
440 selected windows nor the buffer list. WINDOW must denote a live window.
442 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
445 frame
= selected_frame
;
447 CHECK_LIVE_FRAME (frame
);
448 CHECK_LIVE_WINDOW (window
);
450 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
451 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
453 if (EQ (frame
, selected_frame
))
454 return Fselect_window (window
, norecord
);
457 fset_selected_window (XFRAME (frame
), window
);
462 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
463 doc
: /* Return the selected window.
464 The selected window is the window in which the standard cursor for
465 selected windows appears and to which many commands apply. */)
468 return selected_window
;
471 int window_select_count
;
473 /* If select_window is called with inhibit_point_swap non-zero it will
474 not store point of the old selected window's buffer back into that
475 window's pointm slot. This is needed by Fset_window_configuration to
476 avoid that the display routine is called with selected_window set to
477 Qnil causing a subsequent crash. */
479 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
481 register struct window
*w
;
484 CHECK_LIVE_WINDOW (window
);
486 w
= XWINDOW (window
);
487 w
->frozen_window_start_p
= 0;
491 w
->use_time
= ++window_select_count
;
492 record_buffer (w
->buffer
);
495 /* Make the selected window's buffer current. */
496 Fset_buffer (w
->buffer
);
498 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
501 sf
= SELECTED_FRAME ();
502 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
504 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
505 /* Use this rather than Fhandle_switch_frame
506 so that FRAME_FOCUS_FRAME is moved appropriately as we
507 move around in the state where a minibuffer in a separate
509 Fselect_frame (WINDOW_FRAME (w
), norecord
);
510 /* Fselect_frame called us back so we've done all the work already. */
511 eassert (EQ (window
, selected_window
));
515 fset_selected_window (sf
, window
);
517 select_window_1 (window
, inhibit_point_swap
);
519 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
520 windows_or_buffers_changed
++;
524 /* Select window with a minimum of fuss, i.e. don't record the change anywhere
525 (not even for redisplay's benefit), and assume that the window's frame is
528 select_window_1 (Lisp_Object window
, bool inhibit_point_swap
)
530 /* Store the old selected window's buffer's point in pointm of the old
531 selected window. It belongs to that window, and when the window is
532 not selected, must be in the window. */
533 if (!inhibit_point_swap
)
535 struct window
*ow
= XWINDOW (selected_window
);
536 if (! NILP (ow
->buffer
))
537 set_marker_both (ow
->pointm
, ow
->buffer
,
538 BUF_PT (XBUFFER (ow
->buffer
)),
539 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
542 selected_window
= window
;
544 /* Go to the point recorded in the window.
545 This is important when the buffer is in more
546 than one window. It also matters when
547 redisplay_window has altered point after scrolling,
548 because it makes the change only in the window. */
550 register ptrdiff_t new_point
= marker_position (XWINDOW (window
)->pointm
);
551 if (new_point
< BEGV
)
553 else if (new_point
> ZV
)
560 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
561 doc
: /* Select WINDOW which must be a live window.
562 Also make WINDOW's frame the selected frame and WINDOW that frame's
563 selected window. In addition, make WINDOW's buffer current and set that
564 buffer's value of `point' to the value of WINDOW's `window-point'.
567 Optional second arg NORECORD non-nil means do not put this buffer at the
568 front of the buffer list and do not make this window the most recently
571 Note that the main editor command loop sets the current buffer to the
572 buffer of the selected window before each command. */)
573 (register Lisp_Object window
, Lisp_Object norecord
)
575 return select_window (window
, norecord
, 0);
578 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
579 doc
: /* Return the buffer displayed in window WINDOW.
580 If WINDOW is omitted or nil, it defaults to the selected window.
581 Return nil for an internal window or a deleted window. */)
584 return decode_any_window (window
)->buffer
;
587 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
588 doc
: /* Return the parent window of window WINDOW.
589 WINDOW must be a valid window and defaults to the selected one.
590 Return nil for a window with no parent (e.g. a root window). */)
593 return decode_valid_window (window
)->parent
;
596 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
597 doc
: /* Return the topmost child window of window WINDOW.
598 WINDOW must be a valid window and defaults to the selected one.
599 Return nil if WINDOW is a live window (live windows have no children).
600 Return nil if WINDOW is an internal window whose children form a
601 horizontal combination. */)
604 return decode_valid_window (window
)->vchild
;
607 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
608 doc
: /* Return the leftmost child window of window WINDOW.
609 WINDOW must be a valid window and defaults to the selected one.
610 Return nil if WINDOW is a live window (live windows have no children).
611 Return nil if WINDOW is an internal window whose children form a
612 vertical combination. */)
615 return decode_valid_window (window
)->hchild
;
618 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
619 doc
: /* Return the next sibling window of window WINDOW.
620 WINDOW must be a valid window and defaults to the selected one.
621 Return nil if WINDOW has no next sibling. */)
624 return decode_valid_window (window
)->next
;
627 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
628 doc
: /* Return the previous sibling window of window WINDOW.
629 WINDOW must be a valid window and defaults to the selected one.
630 Return nil if WINDOW has no previous sibling. */)
633 return decode_valid_window (window
)->prev
;
636 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
637 doc
: /* Return combination limit of window WINDOW.
638 If the return value is nil, child windows of WINDOW can be recombined with
639 WINDOW's siblings. A return value of t means that child windows of
640 WINDOW are never \(re-)combined with WINDOW's siblings.
642 WINDOW must be a valid window. The return value is meaningful for
643 internal windows only. */)
646 CHECK_VALID_WINDOW (window
);
647 return XWINDOW (window
)->combination_limit
;
650 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
651 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
652 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
653 siblings. LIMIT t means that child windows of WINDOW are never
654 \(re-)combined with WINDOW's siblings. Other values are reserved for
657 WINDOW must be a valid window. Setting the combination limit is
658 meaningful for internal windows only. */)
659 (Lisp_Object window
, Lisp_Object limit
)
661 wset_combination_limit (decode_valid_window (window
), limit
);
665 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
666 doc
: /* Return the use time of window WINDOW.
667 WINDOW must be a live window and defaults to the selected one.
668 The window with the highest use time is the most recently selected
669 one. The window with the lowest use time is the least recently
673 return make_number (decode_live_window (window
)->use_time
);
676 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
677 doc
: /* Return the total height, in lines, of window WINDOW.
678 WINDOW must be a valid window and defaults to the selected one.
680 The return value includes the mode line and header line, if any.
681 If WINDOW is an internal window, the total height is the height
682 of the screen areas spanned by its children.
684 On a graphical display, this total height is reported as an
685 integer multiple of the default character height. */)
688 return decode_valid_window (window
)->total_lines
;
691 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
692 doc
: /* Return the total width, in columns, of window WINDOW.
693 WINDOW must be a valid window and defaults to the selected one.
695 The return value includes any vertical dividers or scroll bars
696 belonging to WINDOW. If WINDOW is an internal window, the total width
697 is the width of the screen areas spanned by its children.
699 On a graphical display, this total width is reported as an
700 integer multiple of the default character width. */)
703 return decode_valid_window (window
)->total_cols
;
706 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
707 doc
: /* Return the new total size of window WINDOW.
708 WINDOW must be a valid window and defaults to the selected one. */)
711 return decode_valid_window (window
)->new_total
;
714 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
715 doc
: /* Return the normal height of window WINDOW.
716 WINDOW must be a valid window and defaults to the selected one.
717 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
718 (Lisp_Object window
, Lisp_Object horizontal
)
720 struct window
*w
= decode_valid_window (window
);
722 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
725 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
726 doc
: /* Return new normal size of window WINDOW.
727 WINDOW must be a valid window and defaults to the selected one. */)
730 return decode_valid_window (window
)->new_normal
;
733 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
734 doc
: /* Return left column of window WINDOW.
735 This is the distance, in columns, between the left edge of WINDOW and
736 the left edge of the frame's window area. For instance, the return
737 value is 0 if there is no window to the left of WINDOW.
739 WINDOW must be a valid window and defaults to the selected one. */)
742 return decode_valid_window (window
)->left_col
;
745 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
746 doc
: /* Return top line of window WINDOW.
747 This is the distance, in lines, between the top of WINDOW and the top
748 of the frame's window area. For instance, the return value is 0 if
749 there is no window above WINDOW.
751 WINDOW must be a valid window and defaults to the selected one. */)
754 return decode_valid_window (window
)->top_line
;
757 /* Return the number of lines of W's body. Don't count any mode or
761 window_body_lines (struct window
*w
)
763 int height
= XFASTINT (w
->total_lines
);
765 if (!MINI_WINDOW_P (w
))
767 if (WINDOW_WANTS_MODELINE_P (w
))
769 if (WINDOW_WANTS_HEADER_LINE_P (w
))
776 /* Return the number of columns of W's body. Don't count columns
777 occupied by the scroll bar or the vertical bar separating W from its
778 right sibling. On window-systems don't count fringes or display
782 window_body_cols (struct window
*w
)
784 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
785 int width
= XINT (w
->total_cols
);
787 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
788 /* Scroll bars occupy a few columns. */
789 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
790 else if (!FRAME_WINDOW_P (f
)
791 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
792 /* The column of `|' characters separating side-by-side windows
793 occupies one column only. */
796 /* Display margins cannot be used for normal text. */
797 width
-= WINDOW_LEFT_MARGIN_COLS (w
) + WINDOW_RIGHT_MARGIN_COLS (w
);
799 if (FRAME_WINDOW_P (f
))
800 /* On window-systems, fringes cannot be used for normal text. */
801 width
-= WINDOW_FRINGE_COLS (w
);
806 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
807 doc
: /* Return the height, in lines, of WINDOW's text area.
808 WINDOW must be a live window and defaults to the selected one.
810 The returned height does not include the mode line or header line.
811 On a graphical display, the height is expressed as an integer multiple
812 of the default character height. If a line at the bottom of the text
813 area is only partially visible, that counts as a whole line; to
814 exclude partially-visible lines, use `window-text-height'. */)
817 return make_number (window_body_lines (decode_live_window (window
)));
820 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
821 doc
: /* Return the width, in columns, of WINDOW's text area.
822 WINDOW must be a live window and defaults to the selected one.
824 The return value does not include any vertical dividers, fringe or
825 marginal areas, or scroll bars. On a graphical display, the width is
826 expressed as an integer multiple of the default character width. */)
829 return make_number (window_body_cols (decode_live_window (window
)));
832 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
833 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
834 WINDOW must be a live window and defaults to the selected one. */)
837 return make_number (decode_live_window (window
)->hscroll
);
840 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
841 range, returning the new amount as a fixnum. */
843 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
845 /* Horizontal scrolling has problems with large scroll amounts.
846 It's too slow with long lines, and even with small lines the
847 display can be messed up. For now, though, impose only the limits
848 required by the internal representation: horizontal scrolling must
849 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
850 (since it's stored in a ptrdiff_t). */
851 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
852 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
854 /* Prevent redisplay shortcuts when changing the hscroll. */
855 if (w
->hscroll
!= new_hscroll
)
856 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
858 w
->hscroll
= new_hscroll
;
859 return make_number (new_hscroll
);
862 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
863 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
864 WINDOW must be a live window and defaults to the selected one.
865 Clip the number to a reasonable value if out of range.
866 Return the new number. NCOL should be zero or positive.
868 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
869 window so that the location of point moves off-window. */)
870 (Lisp_Object window
, Lisp_Object ncol
)
873 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
876 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
877 Swindow_redisplay_end_trigger
, 0, 1, 0,
878 doc
: /* Return WINDOW's redisplay end trigger value.
879 WINDOW must be a live window and defaults to the selected one.
880 See `set-window-redisplay-end-trigger' for more information. */)
883 return decode_live_window (window
)->redisplay_end_trigger
;
886 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
887 Sset_window_redisplay_end_trigger
, 2, 2, 0,
888 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
889 WINDOW must be a live window and defaults to the selected one. VALUE
890 should be a buffer position (typically a marker) or nil. If it is a
891 buffer position, then if redisplay in WINDOW reaches a position beyond
892 VALUE, the functions in `redisplay-end-trigger-functions' are called
893 with two arguments: WINDOW, and the end trigger value. Afterwards the
894 end-trigger value is reset to nil. */)
895 (register Lisp_Object window
, Lisp_Object value
)
897 wset_redisplay_end_trigger (decode_live_window (window
), value
);
901 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
902 doc
: /* Return a list of the edge coordinates of WINDOW.
903 WINDOW must be a valid window and defaults to the selected one.
905 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
906 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
907 0 at top left corner of frame.
909 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
910 is one more than the bottommost row occupied by WINDOW. The edges
911 include the space used by WINDOW's scroll bar, display margins, fringes,
912 header line, and/or mode line. For the edges of just the text area, use
913 `window-inside-edges'. */)
916 register struct window
*w
= decode_valid_window (window
);
918 return list4i (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
919 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
922 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
923 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
924 WINDOW must be a valid window and defaults to the selected one.
926 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
927 0, 0 at the top left corner of the frame.
929 RIGHT is one more than the rightmost x position occupied by WINDOW.
930 BOTTOM is one more than the bottommost y position occupied by WINDOW.
931 The pixel edges include the space used by WINDOW's scroll bar, display
932 margins, fringes, header line, and/or mode line. For the pixel edges
933 of just the text area, use `window-inside-pixel-edges'. */)
936 register struct window
*w
= decode_valid_window (window
);
938 return list4i (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
939 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
943 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
945 struct frame
*f
= XFRAME (w
->frame
);
947 #ifdef FRAME_MENUBAR_HEIGHT
948 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
950 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
951 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
952 #elif FRAME_TOOLBAR_HEIGHT
953 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
955 #ifdef FRAME_NS_TITLEBAR_HEIGHT
956 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
958 *add_x
= f
->left_pos
;
959 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
960 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
964 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
965 Swindow_absolute_pixel_edges
, 0, 1, 0,
966 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
967 WINDOW must be a valid window and defaults to the selected one.
969 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
970 0, 0 at the top left corner of the display.
972 RIGHT is one more than the rightmost x position occupied by WINDOW.
973 BOTTOM is one more than the bottommost y position occupied by WINDOW.
974 The pixel edges include the space used by WINDOW's scroll bar, display
975 margins, fringes, header line, and/or mode line. For the pixel edges
976 of just the text area, use `window-inside-absolute-pixel-edges'. */)
979 register struct window
*w
= decode_valid_window (window
);
982 calc_absolute_offset (w
, &add_x
, &add_y
);
984 return list4i (WINDOW_LEFT_EDGE_X (w
) + add_x
,
985 WINDOW_TOP_EDGE_Y (w
) + add_y
,
986 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
987 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
990 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
991 doc
: /* Return a list of the edge coordinates of WINDOW.
992 WINDOW must be a live window and defaults to the selected one.
994 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
995 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
996 0 at top left corner of frame.
998 RIGHT is one more than the rightmost column of WINDOW's text area.
999 BOTTOM is one more than the bottommost row of WINDOW's text area. The
1000 inside edges do not include the space used by the WINDOW's scroll bar,
1001 display margins, fringes, header line, and/or mode line. */)
1002 (Lisp_Object window
)
1004 register struct window
*w
= decode_live_window (window
);
1006 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w
)
1007 + WINDOW_LEFT_MARGIN_COLS (w
)
1008 + WINDOW_LEFT_FRINGE_COLS (w
)),
1009 (WINDOW_TOP_EDGE_LINE (w
)
1010 + WINDOW_HEADER_LINE_LINES (w
)),
1011 (WINDOW_BOX_RIGHT_EDGE_COL (w
)
1012 - WINDOW_RIGHT_MARGIN_COLS (w
)
1013 - WINDOW_RIGHT_FRINGE_COLS (w
)),
1014 (WINDOW_BOTTOM_EDGE_LINE (w
)
1015 - WINDOW_MODE_LINE_LINES (w
)));
1018 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
1019 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1020 WINDOW must be a live window and defaults to the selected one.
1022 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1023 (0,0) at the top left corner of the frame's window area.
1025 RIGHT is one more than the rightmost x position of WINDOW's text area.
1026 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1027 The inside edges do not include the space used by WINDOW's scroll bar,
1028 display margins, fringes, header line, and/or mode line. */)
1029 (Lisp_Object window
)
1031 register struct window
*w
= decode_live_window (window
);
1033 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1034 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1035 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1036 (WINDOW_TOP_EDGE_Y (w
)
1037 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1038 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1039 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1040 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1041 (WINDOW_BOTTOM_EDGE_Y (w
)
1042 - WINDOW_MODE_LINE_HEIGHT (w
)));
1045 DEFUN ("window-inside-absolute-pixel-edges",
1046 Fwindow_inside_absolute_pixel_edges
,
1047 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1048 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1049 WINDOW must be a live window and defaults to the selected one.
1051 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1052 (0,0) at the top left corner of the frame's window area.
1054 RIGHT is one more than the rightmost x position of WINDOW's text area.
1055 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1056 The inside edges do not include the space used by WINDOW's scroll bar,
1057 display margins, fringes, header line, and/or mode line. */)
1058 (Lisp_Object window
)
1060 register struct window
*w
= decode_live_window (window
);
1063 calc_absolute_offset (w
, &add_x
, &add_y
);
1065 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1066 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1067 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1068 (WINDOW_TOP_EDGE_Y (w
)
1069 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1070 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1071 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1072 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1073 (WINDOW_BOTTOM_EDGE_Y (w
)
1074 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1077 /* Test if the character at column X, row Y is within window W.
1078 If it is not, return ON_NOTHING;
1079 if it is in the window's text area, return ON_TEXT;
1080 if it is on the window's modeline, return ON_MODE_LINE;
1081 if it is on the border between the window and its right sibling,
1082 return ON_VERTICAL_BORDER.
1083 if it is on a scroll bar, return ON_SCROLL_BAR.
1084 if it is on the window's top line, return ON_HEADER_LINE;
1085 if it is in left or right fringe of the window,
1086 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1087 if it is in the marginal area to the left/right of the window,
1088 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1090 X and Y are frame relative pixel coordinates. */
1092 static enum window_part
1093 coordinates_in_window (register struct window
*w
, int x
, int y
)
1095 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1096 enum window_part part
;
1097 int ux
= FRAME_COLUMN_WIDTH (f
);
1098 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1099 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1100 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1101 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1102 /* The width of the area where the vertical line can be dragged.
1103 (Between mode lines for instance. */
1104 int grabbable_width
= ux
;
1105 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1107 /* Outside any interesting row or column? */
1108 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1111 /* On the mode line or header line? */
1112 if ((WINDOW_WANTS_MODELINE_P (w
)
1113 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1114 && (part
= ON_MODE_LINE
))
1115 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1116 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1117 && (part
= ON_HEADER_LINE
)))
1119 /* If it's under/over the scroll bar portion of the mode/header
1120 line, say it's on the vertical line. That's to be able to
1121 resize windows horizontally in case we're using toolkit scroll
1122 bars. Note: If scrollbars are on the left, the window that
1123 must be eventually resized is that on the left of WINDOW. */
1124 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1125 && !WINDOW_LEFTMOST_P (w
)
1126 && eabs (x
- left_x
) < grabbable_width
)
1127 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1128 && !WINDOW_RIGHTMOST_P (w
)
1129 && eabs (x
- right_x
) < grabbable_width
))
1130 return ON_VERTICAL_BORDER
;
1135 /* In what's below, we subtract 1 when computing right_x because we
1136 want the rightmost pixel, which is given by left_pixel+width-1. */
1137 if (w
->pseudo_window_p
)
1140 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1144 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1145 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1148 /* Outside any interesting column? */
1149 if (x
< left_x
|| x
> right_x
)
1150 return ON_SCROLL_BAR
;
1152 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1153 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1155 text_left
= window_box_left (w
, TEXT_AREA
);
1156 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1158 if (FRAME_WINDOW_P (f
))
1160 if (!w
->pseudo_window_p
1161 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1162 && !WINDOW_RIGHTMOST_P (w
)
1163 && (eabs (x
- right_x
) < grabbable_width
))
1164 return ON_VERTICAL_BORDER
;
1166 /* Need to say "x > right_x" rather than >=, since on character
1167 terminals, the vertical line's x coordinate is right_x. */
1168 else if (!w
->pseudo_window_p
1169 && !WINDOW_RIGHTMOST_P (w
)
1170 && x
> right_x
- ux
)
1171 return ON_VERTICAL_BORDER
;
1175 if (lmargin_width
> 0
1176 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1177 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1178 : (x
< left_x
+ lmargin_width
)))
1179 return ON_LEFT_MARGIN
;
1181 return ON_LEFT_FRINGE
;
1184 if (x
>= text_right
)
1186 if (rmargin_width
> 0
1187 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1188 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1189 : (x
>= right_x
- rmargin_width
)))
1190 return ON_RIGHT_MARGIN
;
1192 return ON_RIGHT_FRINGE
;
1195 /* Everything special ruled out - must be on text area */
1199 /* Take X is the frame-relative pixel x-coordinate, and return the
1200 x-coordinate relative to part PART of window W. */
1202 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1204 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1209 return x
- window_box_left (w
, TEXT_AREA
);
1211 case ON_LEFT_FRINGE
:
1214 case ON_RIGHT_FRINGE
:
1215 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1217 case ON_LEFT_MARGIN
:
1219 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1220 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1222 case ON_RIGHT_MARGIN
:
1224 - ((w
->pseudo_window_p
)
1225 ? WINDOW_TOTAL_WIDTH (w
)
1226 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1227 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1228 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1229 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1232 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1237 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1238 Scoordinates_in_window_p
, 2, 2, 0,
1239 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1240 WINDOW must be a live window and defaults to the selected one.
1241 COORDINATES is a cons of the form (X . Y), X and Y being distances
1242 measured in characters from the upper-left corner of the frame.
1243 \(0 . 0) denotes the character in the upper left corner of the
1245 If COORDINATES are in the text portion of WINDOW,
1246 the coordinates relative to the window are returned.
1247 If they are in the mode line of WINDOW, `mode-line' is returned.
1248 If they are in the top mode line of WINDOW, `header-line' is returned.
1249 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1250 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1251 If they are on the border between WINDOW and its right sibling,
1252 `vertical-line' is returned.
1253 If they are in the windows's left or right marginal areas, `left-margin'\n\
1254 or `right-margin' is returned. */)
1255 (register Lisp_Object coordinates
, Lisp_Object window
)
1262 w
= decode_live_window (window
);
1263 f
= XFRAME (w
->frame
);
1264 CHECK_CONS (coordinates
);
1265 lx
= Fcar (coordinates
);
1266 ly
= Fcdr (coordinates
);
1267 CHECK_NUMBER_OR_FLOAT (lx
);
1268 CHECK_NUMBER_OR_FLOAT (ly
);
1269 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1270 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1272 switch (coordinates_in_window (w
, x
, y
))
1278 /* Convert X and Y to window relative pixel coordinates, and
1279 return the canonical char units. */
1280 x
-= window_box_left (w
, TEXT_AREA
);
1281 y
-= WINDOW_TOP_EDGE_Y (w
);
1282 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1283 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1288 case ON_VERTICAL_BORDER
:
1289 return Qvertical_line
;
1291 case ON_HEADER_LINE
:
1292 return Qheader_line
;
1294 case ON_LEFT_FRINGE
:
1295 return Qleft_fringe
;
1297 case ON_RIGHT_FRINGE
:
1298 return Qright_fringe
;
1300 case ON_LEFT_MARGIN
:
1301 return Qleft_margin
;
1303 case ON_RIGHT_MARGIN
:
1304 return Qright_margin
;
1307 /* Historically we are supposed to return nil in this case. */
1316 /* Callback for foreach_window, used in window_from_coordinates.
1317 Check if window W contains coordinates specified by USER_DATA which
1318 is actually a pointer to a struct check_window_data CW.
1320 Check if window W contains coordinates *CW->x and *CW->y. If it
1321 does, return W in *CW->window, as Lisp_Object, and return in
1322 *CW->part the part of the window under coordinates *X,*Y. Return
1323 zero from this function to stop iterating over windows. */
1325 struct check_window_data
1327 Lisp_Object
*window
;
1329 enum window_part
*part
;
1333 check_window_containing (struct window
*w
, void *user_data
)
1335 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1336 enum window_part found
;
1339 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1340 if (found
!= ON_NOTHING
)
1343 XSETWINDOW (*cw
->window
, w
);
1351 /* Find the window containing frame-relative pixel position X/Y and
1352 return it as a Lisp_Object.
1354 If X, Y is on one of the window's special `window_part' elements,
1355 set *PART to the id of that element.
1357 If there is no window under X, Y return nil and leave *PART
1358 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1360 This function was previously implemented with a loop cycling over
1361 windows with Fnext_window, and starting with the frame's selected
1362 window. It turned out that this doesn't work with an
1363 implementation of next_window using Vwindow_list, because
1364 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1365 tree of F when this function is called asynchronously from
1366 note_mouse_highlight. The original loop didn't terminate in this
1370 window_from_coordinates (struct frame
*f
, int x
, int y
,
1371 enum window_part
*part
, int tool_bar_p
)
1374 struct check_window_data cw
;
1375 enum window_part dummy
;
1381 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1382 foreach_window (f
, check_window_containing
, &cw
);
1384 /* If not found above, see if it's in the tool bar window, if a tool
1388 && WINDOWP (f
->tool_bar_window
)
1389 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1390 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1394 window
= f
->tool_bar_window
;
1400 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1401 doc
: /* Return window containing coordinates X and Y on FRAME.
1402 FRAME must be a live frame and defaults to the selected one.
1403 The top left corner of the frame is considered to be row 0,
1405 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1407 struct frame
*f
= decode_live_frame (frame
);
1409 /* Check that arguments are integers or floats. */
1410 CHECK_NUMBER_OR_FLOAT (x
);
1411 CHECK_NUMBER_OR_FLOAT (y
);
1413 return window_from_coordinates (f
,
1414 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1415 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1416 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1417 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1421 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1422 doc
: /* Return current value of point in WINDOW.
1423 WINDOW must be a live window and defaults to the selected one.
1425 For a nonselected window, this is the value point would have if that
1426 window were selected.
1428 Note that, when WINDOW is selected, the value returned is the same as
1429 that returned by `point' for WINDOW's buffer. It would be more strictly
1430 correct to return the top-level value of `point', outside of any
1431 `save-excursion' forms. But that is hard to define. */)
1432 (Lisp_Object window
)
1434 register struct window
*w
= decode_live_window (window
);
1436 if (w
== XWINDOW (selected_window
))
1437 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1439 return Fmarker_position (w
->pointm
);
1442 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1443 doc
: /* Return position at which display currently starts in WINDOW.
1444 WINDOW must be a live window and defaults to the selected one.
1445 This is updated by redisplay or by calling `set-window-start'. */)
1446 (Lisp_Object window
)
1448 return Fmarker_position (decode_live_window (window
)->start
);
1451 /* This is text temporarily removed from the doc string below.
1453 This function returns nil if the position is not currently known.
1454 That happens when redisplay is preempted and doesn't finish.
1455 If in that case you want to compute where the end of the window would
1456 have been if redisplay had finished, do this:
1458 (goto-char (window-start window))
1459 (vertical-motion (1- (window-height window)) window)
1462 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1463 doc
: /* Return position at which display currently ends in WINDOW.
1464 WINDOW must be a live window and defaults to the selected one.
1465 This is updated by redisplay, when it runs to completion.
1466 Simply changing the buffer text or setting `window-start'
1467 does not update this value.
1468 Return nil if there is no recorded value. (This can happen if the
1469 last redisplay of WINDOW was preempted, and did not finish.)
1470 If UPDATE is non-nil, compute the up-to-date position
1471 if it isn't already recorded. */)
1472 (Lisp_Object window
, Lisp_Object update
)
1475 struct window
*w
= decode_live_window (window
);
1484 && (windows_or_buffers_changed
|| !w
->window_end_valid
)
1487 struct text_pos startp
;
1488 ptrdiff_t charpos
= marker_position (w
->start
);
1490 struct buffer
*old_buffer
= NULL
;
1491 void *itdata
= NULL
;
1493 /* Cannot use Fvertical_motion because that function doesn't
1494 cope with variable-height lines. */
1495 if (b
!= current_buffer
)
1497 old_buffer
= current_buffer
;
1498 set_buffer_internal (b
);
1501 /* In case W->start is out of the range, use something
1502 reasonable. This situation occurred when loading a file with
1503 `-l' containing a call to `rmail' with subsequent other
1504 commands. At the end, W->start happened to be BEG, while
1505 rmail had already narrowed the buffer. */
1507 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1508 else if (charpos
> ZV
)
1509 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1511 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1513 itdata
= bidi_shelve_cache ();
1514 start_display (&it
, w
, startp
);
1515 move_it_vertically (&it
, window_box_height (w
));
1516 if (it
.current_y
< it
.last_visible_y
)
1517 move_it_past_eol (&it
);
1518 value
= make_number (IT_CHARPOS (it
));
1519 bidi_unshelve_cache (itdata
, 0);
1522 set_buffer_internal (old_buffer
);
1525 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1530 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1531 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1532 WINDOW must be a live window and defaults to the selected one.
1534 (Lisp_Object window
, Lisp_Object pos
)
1536 register struct window
*w
= decode_live_window (window
);
1538 /* Type of POS is checked by Fgoto_char or set_marker_restricted ... */
1540 if (w
== XWINDOW (selected_window
))
1542 if (XBUFFER (w
->buffer
) == current_buffer
)
1546 struct buffer
*old_buffer
= current_buffer
;
1548 /* ... but here we want to catch type error before buffer change. */
1549 CHECK_NUMBER_COERCE_MARKER (pos
);
1550 set_buffer_internal (XBUFFER (w
->buffer
));
1552 set_buffer_internal (old_buffer
);
1557 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1558 /* We have to make sure that redisplay updates the window to show
1559 the new value of point. */
1560 ++windows_or_buffers_changed
;
1566 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1567 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1568 WINDOW must be a live window and defaults to the selected one. Return
1569 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1570 overriding motion of point in order to display at this exact start. */)
1571 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1573 register struct window
*w
= decode_live_window (window
);
1575 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1576 /* This is not right, but much easier than doing what is right. */
1577 w
->start_at_line_beg
= 0;
1580 w
->update_mode_line
= 1;
1581 w
->last_modified
= 0;
1582 w
->last_overlay_modified
= 0;
1583 if (!EQ (window
, selected_window
))
1584 windows_or_buffers_changed
++;
1589 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1590 Spos_visible_in_window_p
, 0, 3, 0,
1591 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1592 WINDOW must be a live window and defaults to the selected one.
1594 Return nil if that position is scrolled vertically out of view. If a
1595 character is only partially visible, nil is returned, unless the
1596 optional argument PARTIALLY is non-nil. If POS is only out of view
1597 because of horizontal scrolling, return non-nil. If POS is t, it
1598 specifies the position of the last visible glyph in WINDOW. POS
1599 defaults to point in WINDOW; WINDOW defaults to the selected window.
1601 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1602 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1603 where X and Y are the pixel coordinates relative to the top left corner
1604 of the window. The remaining elements are omitted if the character after
1605 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1606 off-window at the top and bottom of the row, ROWH is the height of the
1607 display row, and VPOS is the row number (0-based) containing POS. */)
1608 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1610 register struct window
*w
;
1611 register EMACS_INT posint
;
1612 register struct buffer
*buf
;
1613 struct text_pos top
;
1614 Lisp_Object in_window
= Qnil
;
1615 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1618 w
= decode_live_window (window
);
1619 buf
= XBUFFER (w
->buffer
);
1620 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1624 else if (!NILP (pos
))
1626 CHECK_NUMBER_COERCE_MARKER (pos
);
1627 posint
= XINT (pos
);
1629 else if (w
== XWINDOW (selected_window
))
1632 posint
= marker_position (w
->pointm
);
1634 /* If position is above window start or outside buffer boundaries,
1635 or if window start is out of range, position is not visible. */
1637 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1638 && CHARPOS (top
) >= BUF_BEGV (buf
)
1639 && CHARPOS (top
) <= BUF_ZV (buf
)
1640 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1641 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1644 if (!NILP (in_window
) && !NILP (partially
))
1646 Lisp_Object part
= Qnil
;
1648 part
= list4i (rtop
, rbot
, rowh
, vpos
);
1649 in_window
= Fcons (make_number (x
),
1650 Fcons (make_number (y
), part
));
1656 DEFUN ("window-line-height", Fwindow_line_height
,
1657 Swindow_line_height
, 0, 2, 0,
1658 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1659 WINDOW must be a live window and defaults to the selected one.
1661 Return height of current line if LINE is omitted or nil. Return height of
1662 header or mode line if LINE is `header-line' or `mode-line'.
1663 Otherwise, LINE is a text line number starting from 0. A negative number
1664 counts from the end of the window.
1666 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1667 in pixels of the visible part of the line, VPOS and YPOS are the
1668 vertical position in lines and pixels of the line, relative to the top
1669 of the first text line, and OFFBOT is the number of off-window pixels at
1670 the bottom of the text line. If there are off-window pixels at the top
1671 of the (first) text line, YPOS is negative.
1673 Return nil if window display is not up-to-date. In that case, use
1674 `pos-visible-in-window-p' to obtain the information. */)
1675 (Lisp_Object line
, Lisp_Object window
)
1677 register struct window
*w
;
1678 register struct buffer
*b
;
1679 struct glyph_row
*row
, *end_row
;
1683 w
= decode_live_window (window
);
1685 if (noninteractive
|| w
->pseudo_window_p
)
1688 CHECK_BUFFER (w
->buffer
);
1689 b
= XBUFFER (w
->buffer
);
1691 /* Fail if current matrix is not up-to-date. */
1692 if (!w
->window_end_valid
1693 || current_buffer
->clip_changed
1694 || current_buffer
->prevent_redisplay_optimizations_p
1695 || w
->last_modified
< BUF_MODIFF (b
)
1696 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1702 if (i
< 0 || i
>= w
->current_matrix
->nrows
1703 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1705 max_y
= window_text_bottom_y (w
);
1709 if (EQ (line
, Qheader_line
))
1711 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1713 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1714 return row
->enabled_p
? list4i (row
->height
, 0, 0, 0) : Qnil
;
1717 if (EQ (line
, Qmode_line
))
1719 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1720 return (row
->enabled_p
?
1721 list4i (row
->height
,
1722 0, /* not accurate */
1723 (WINDOW_HEADER_LINE_HEIGHT (w
)
1724 + window_text_bottom_y (w
)),
1729 CHECK_NUMBER (line
);
1732 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1733 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1734 max_y
= window_text_bottom_y (w
);
1737 while ((n
< 0 || i
< n
)
1738 && row
<= end_row
&& row
->enabled_p
1739 && row
->y
+ row
->height
< max_y
)
1742 if (row
> end_row
|| !row
->enabled_p
)
1754 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1755 return list4i (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1758 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1760 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1761 More precisely, return the value assigned by the last call of
1762 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1763 never called with WINDOW as its argument, or the value set by that
1764 function was internally reset since its last call. WINDOW must be a
1765 live window and defaults to the selected one.
1767 When a window is dedicated to its buffer, `display-buffer' will refrain
1768 from displaying another buffer in it. `get-lru-window' and
1769 `get-largest-window' treat dedicated windows specially.
1770 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1771 `kill-buffer' can delete a dedicated window and the containing frame.
1773 Functions like `set-window-buffer' may change the buffer displayed by a
1774 window, unless that window is "strongly" dedicated to its buffer, that
1775 is the value returned by `window-dedicated-p' is t. */)
1776 (Lisp_Object window
)
1778 return decode_live_window (window
)->dedicated
;
1781 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1782 Sset_window_dedicated_p
, 2, 2, 0,
1783 doc
: /* Mark WINDOW as dedicated according to FLAG.
1784 WINDOW must be a live window and defaults to the selected one. FLAG
1785 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1786 mark WINDOW as non-dedicated. Return FLAG.
1788 When a window is dedicated to its buffer, `display-buffer' will refrain
1789 from displaying another buffer in it. `get-lru-window' and
1790 `get-largest-window' treat dedicated windows specially.
1791 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1792 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1793 and the containing frame.
1795 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1796 its buffer. Functions like `set-window-buffer' may change the buffer
1797 displayed by a window, unless that window is strongly dedicated to its
1798 buffer. If and when `set-window-buffer' displays another buffer in a
1799 window, it also makes sure that the window is no more dedicated. */)
1800 (Lisp_Object window
, Lisp_Object flag
)
1802 wset_dedicated (decode_live_window (window
), flag
);
1806 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1808 doc
: /* Return buffers previously shown in WINDOW.
1809 WINDOW must be a live window and defaults to the selected one.
1811 The return value is a list of elements (BUFFER WINDOW-START POS),
1812 where BUFFER is a buffer, WINDOW-START is the start position of the
1813 window for that buffer, and POS is a window-specific point value. */)
1814 (Lisp_Object window
)
1816 return decode_live_window (window
)->prev_buffers
;
1819 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1820 Sset_window_prev_buffers
, 2, 2, 0,
1821 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1822 WINDOW must be a live window and defaults to the selected one.
1824 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1825 where BUFFER is a buffer, WINDOW-START is the start position of the
1826 window for that buffer, and POS is a window-specific point value. */)
1827 (Lisp_Object window
, Lisp_Object prev_buffers
)
1829 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1830 return prev_buffers
;
1833 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1835 doc
: /* Return list of buffers recently re-shown in WINDOW.
1836 WINDOW must be a live window and defaults to the selected one. */)
1837 (Lisp_Object window
)
1839 return decode_live_window (window
)->next_buffers
;
1842 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1843 Sset_window_next_buffers
, 2, 2, 0,
1844 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1845 WINDOW must be a live window and defaults to the selected one.
1846 NEXT-BUFFERS should be a list of buffers. */)
1847 (Lisp_Object window
, Lisp_Object next_buffers
)
1849 wset_next_buffers (decode_live_window (window
), next_buffers
);
1850 return next_buffers
;
1853 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1855 doc
: /* Return the parameters of WINDOW and their values.
1856 WINDOW must be a valid window and defaults to the selected one. The
1857 return value is a list of elements of the form (PARAMETER . VALUE). */)
1858 (Lisp_Object window
)
1860 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1863 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1865 doc
: /* Return WINDOW's value for PARAMETER.
1866 WINDOW can be any window and defaults to the selected one. */)
1867 (Lisp_Object window
, Lisp_Object parameter
)
1871 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1872 return CDR_SAFE (result
);
1875 DEFUN ("set-window-parameter", Fset_window_parameter
,
1876 Sset_window_parameter
, 3, 3, 0,
1877 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1878 WINDOW can be any window and defaults to the selected one.
1880 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1882 register struct window
*w
= decode_any_window (window
);
1883 Lisp_Object old_alist_elt
;
1885 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1886 if (NILP (old_alist_elt
))
1887 wset_window_parameters
1888 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1890 Fsetcdr (old_alist_elt
, value
);
1894 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1896 doc
: /* Return the display-table that WINDOW is using.
1897 WINDOW must be a live window and defaults to the selected one. */)
1898 (Lisp_Object window
)
1900 return decode_live_window (window
)->display_table
;
1903 /* Get the display table for use on window W. This is either W's
1904 display table or W's buffer's display table. Ignore the specified
1905 tables if they are not valid; if no valid table is specified,
1908 struct Lisp_Char_Table
*
1909 window_display_table (struct window
*w
)
1911 struct Lisp_Char_Table
*dp
= NULL
;
1913 if (DISP_TABLE_P (w
->display_table
))
1914 dp
= XCHAR_TABLE (w
->display_table
);
1915 else if (BUFFERP (w
->buffer
))
1917 struct buffer
*b
= XBUFFER (w
->buffer
);
1919 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1920 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1921 else if (DISP_TABLE_P (Vstandard_display_table
))
1922 dp
= XCHAR_TABLE (Vstandard_display_table
);
1928 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1929 doc
: /* Set WINDOW's display-table to TABLE.
1930 WINDOW must be a live window and defaults to the selected one. */)
1931 (register Lisp_Object window
, Lisp_Object table
)
1933 wset_display_table (decode_live_window (window
), table
);
1937 /* Record info on buffer window W is displaying
1938 when it is about to cease to display that buffer. */
1940 unshow_buffer (register struct window
*w
)
1947 if (b
!= XMARKER (w
->pointm
)->buffer
)
1951 if (w
== XWINDOW (selected_window
)
1952 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1953 /* Do this except when the selected window's buffer
1954 is being removed from some other window. */
1956 /* last_window_start records the start position that this buffer
1957 had in the last window to be disconnected from it.
1958 Now that this statement is unconditional,
1959 it is possible for the buffer to be displayed in the
1960 selected window, while last_window_start reflects another
1961 window which was recently showing the same buffer.
1962 Some people might say that might be a good thing. Let's see. */
1963 b
->last_window_start
= marker_position (w
->start
);
1965 /* Point in the selected window's buffer
1966 is actually stored in that buffer, and the window's pointm isn't used.
1967 So don't clobber point in that buffer. */
1968 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1969 /* Don't clobber point in current buffer either (this could be
1970 useful in connection with bug#12208).
1971 && XBUFFER (buf) != current_buffer */
1972 /* This line helps to fix Horsley's testbug.el bug. */
1973 && !(WINDOWP (BVAR (b
, last_selected_window
))
1974 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1975 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1976 temp_set_point_both (b
,
1977 clip_to_bounds (BUF_BEGV (b
),
1978 marker_position (w
->pointm
),
1980 clip_to_bounds (BUF_BEGV_BYTE (b
),
1981 marker_byte_position (w
->pointm
),
1984 if (WINDOWP (BVAR (b
, last_selected_window
))
1985 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1986 bset_last_selected_window (b
, Qnil
);
1989 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1990 means change window structure only. Otherwise store geometry and
1991 other settings as well. */
1993 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1995 register Lisp_Object tem
;
1996 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1998 /* If OLD is its frame's root window, then NEW is the new
1999 root window for that frame. */
2000 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
2001 fset_root_window (XFRAME (o
->frame
), new);
2005 wset_left_col (n
, o
->left_col
);
2006 wset_top_line (n
, o
->top_line
);
2007 wset_total_cols (n
, o
->total_cols
);
2008 wset_total_lines (n
, o
->total_lines
);
2009 wset_normal_cols (n
, o
->normal_cols
);
2010 wset_normal_cols (o
, make_float (1.0));
2011 wset_normal_lines (n
, o
->normal_lines
);
2012 wset_normal_lines (o
, make_float (1.0));
2013 n
->desired_matrix
= n
->current_matrix
= 0;
2015 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
2016 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
2017 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
2018 n
->phys_cursor_type
= -1;
2019 n
->phys_cursor_width
= -1;
2020 n
->must_be_updated_p
= 0;
2021 n
->pseudo_window_p
= 0;
2022 wset_window_end_vpos (n
, make_number (0));
2023 wset_window_end_pos (n
, make_number (0));
2024 n
->window_end_valid
= 0;
2025 n
->frozen_window_start_p
= 0;
2031 wset_prev (XWINDOW (tem
), new);
2036 wset_next (XWINDOW (tem
), new);
2039 wset_parent (n
, tem
);
2042 if (EQ (XWINDOW (tem
)->vchild
, old
))
2043 wset_vchild (XWINDOW (tem
), new);
2044 if (EQ (XWINDOW (tem
)->hchild
, old
))
2045 wset_hchild (XWINDOW (tem
), new);
2049 /* If window WINDOW and its parent window are iso-combined, merge
2050 WINDOW's children into those of its parent window and mark WINDOW as
2054 recombine_windows (Lisp_Object window
)
2056 struct window
*w
, *p
, *c
;
2057 Lisp_Object parent
, child
;
2060 w
= XWINDOW (window
);
2062 if (!NILP (parent
) && NILP (w
->combination_limit
))
2064 p
= XWINDOW (parent
);
2065 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2066 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2067 /* WINDOW and PARENT are both either a vertical or a horizontal
2070 horflag
= NILP (w
->vchild
);
2071 child
= horflag
? w
->hchild
: w
->vchild
;
2072 c
= XWINDOW (child
);
2074 /* Splice WINDOW's children into its parent's children and
2075 assign new normal sizes. */
2078 wset_hchild (p
, child
);
2080 wset_vchild (p
, child
);
2083 wset_prev (c
, w
->prev
);
2084 wset_next (XWINDOW (w
->prev
), child
);
2089 wset_parent (c
, parent
);
2092 wset_normal_cols (c
,
2093 make_float (XFLOATINT (c
->total_cols
)
2094 / XFLOATINT (p
->total_cols
)));
2096 wset_normal_lines (c
,
2097 make_float (XFLOATINT (c
->total_lines
)
2098 / XFLOATINT (p
->total_lines
)));
2102 if (!NILP (w
->next
))
2104 wset_next (c
, w
->next
);
2105 wset_prev (XWINDOW (c
->next
), child
);
2113 c
= XWINDOW (child
);
2117 /* WINDOW can be deleted now. */
2118 wset_vchild (w
, Qnil
);
2119 wset_hchild (w
, Qnil
);
2124 /* If WINDOW can be deleted, delete it. */
2126 delete_deletable_window (Lisp_Object window
)
2128 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2129 call1 (Qdelete_window
, window
);
2132 /***********************************************************************
2134 ***********************************************************************/
2136 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2137 pointer. This is a callback function for foreach_window, used in
2138 the window_list function. */
2141 add_window_to_list (struct window
*w
, void *user_data
)
2143 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2145 XSETWINDOW (window
, w
);
2146 *list
= Fcons (window
, *list
);
2151 /* Return a list of all windows, for use by next_window. If
2152 Vwindow_list is a list, return that list. Otherwise, build a new
2153 list, cache it in Vwindow_list, and return that. */
2158 if (!CONSP (Vwindow_list
))
2160 Lisp_Object tail
, frame
;
2162 Vwindow_list
= Qnil
;
2163 FOR_EACH_FRAME (tail
, frame
)
2165 Lisp_Object args
[2];
2167 /* We are visiting windows in canonical order, and add
2168 new windows at the front of args[1], which means we
2169 have to reverse this list at the end. */
2171 foreach_window (XFRAME (frame
), add_window_to_list
, &args
[1]);
2172 args
[0] = Vwindow_list
;
2173 args
[1] = Fnreverse (args
[1]);
2174 Vwindow_list
= Fnconc (2, args
);
2178 return Vwindow_list
;
2182 /* Value is non-zero if WINDOW satisfies the constraints given by
2183 OWINDOW, MINIBUF and ALL_FRAMES.
2185 MINIBUF t means WINDOW may be minibuffer windows.
2186 `lambda' means WINDOW may not be a minibuffer window.
2187 a window means a specific minibuffer window
2189 ALL_FRAMES t means search all frames,
2190 nil means search just current frame,
2191 `visible' means search just visible frames on the
2193 0 means search visible and iconified frames on the
2195 a window means search the frame that window belongs to,
2196 a frame means consider windows on that frame, only. */
2199 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2201 struct window
*w
= XWINDOW (window
);
2202 struct frame
*f
= XFRAME (w
->frame
);
2203 int candidate_p
= 1;
2205 if (!BUFFERP (w
->buffer
))
2207 else if (MINI_WINDOW_P (w
)
2208 && (EQ (minibuf
, Qlambda
)
2209 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2211 /* If MINIBUF is `lambda' don't consider any mini-windows.
2212 If it is a window, consider only that one. */
2215 else if (EQ (all_frames
, Qt
))
2217 else if (NILP (all_frames
))
2219 eassert (WINDOWP (owindow
));
2220 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2222 else if (EQ (all_frames
, Qvisible
))
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 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2232 #ifdef HAVE_X_WINDOWS
2233 /* Yuck!! If we've just created the frame and the
2234 window-manager requested the user to place it
2235 manually, the window may still not be considered
2236 `visible'. I'd argue it should be at least
2237 something like `iconified', but don't know how to do
2239 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2240 && !f
->output_data
.x
->has_been_visible
)
2243 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2244 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2246 else if (WINDOWP (all_frames
))
2247 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2248 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2249 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2250 else if (FRAMEP (all_frames
))
2251 candidate_p
= EQ (all_frames
, w
->frame
);
2257 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2258 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2259 MINIBUF, and ALL_FRAMES. */
2262 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2264 struct window
*w
= decode_live_window (*window
);
2266 XSETWINDOW (*window
, w
);
2267 /* MINIBUF nil may or may not include minibuffers. Decide if it
2269 if (NILP (*minibuf
))
2270 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2271 else if (!EQ (*minibuf
, Qt
))
2274 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2275 => count none of them, or a specific minibuffer window (the
2276 active one) to count. */
2278 /* ALL_FRAMES nil doesn't specify which frames to include. */
2279 if (NILP (*all_frames
))
2281 = (!EQ (*minibuf
, Qlambda
)
2282 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2284 else if (EQ (*all_frames
, Qvisible
))
2286 else if (EQ (*all_frames
, make_number (0)))
2288 else if (FRAMEP (*all_frames
))
2290 else if (!EQ (*all_frames
, Qt
))
2295 /* Return the next or previous window of WINDOW in cyclic ordering
2296 of windows. NEXT_P non-zero means return the next window. See the
2297 documentation string of next-window for the meaning of MINIBUF and
2301 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2303 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2305 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2306 return the first window on the frame. */
2307 if (FRAMEP (all_frames
)
2308 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2309 return Fframe_first_window (all_frames
);
2315 /* Find WINDOW in the list of all windows. */
2316 list
= Fmemq (window
, window_list ());
2318 /* Scan forward from WINDOW to the end of the window list. */
2320 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2321 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2324 /* Scan from the start of the window list up to WINDOW. */
2326 for (list
= Vwindow_list
;
2327 CONSP (list
) && !EQ (XCAR (list
), window
);
2329 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2333 window
= XCAR (list
);
2337 Lisp_Object candidate
, list
;
2339 /* Scan through the list of windows for candidates. If there are
2340 candidate windows in front of WINDOW, the last one of these
2341 is the one we want. If there are candidates following WINDOW
2342 in the list, again the last one of these is the one we want. */
2344 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2346 if (EQ (XCAR (list
), window
))
2348 if (WINDOWP (candidate
))
2351 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2353 candidate
= XCAR (list
);
2356 if (WINDOWP (candidate
))
2364 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2365 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2366 WINDOW must be a live window and defaults to the selected one. The
2367 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2370 MINIBUF nil or omitted means consider the minibuffer window only if the
2371 minibuffer is active. MINIBUF t means consider the minibuffer window
2372 even if the minibuffer is not active. Any other value means do not
2373 consider the minibuffer window even if the minibuffer is active.
2375 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2376 plus the minibuffer window if specified by the MINIBUF argument. If the
2377 minibuffer counts, consider all windows on all frames that share that
2378 minibuffer too. The following non-nil values of ALL-FRAMES have special
2381 - t means consider all windows on all existing frames.
2383 - `visible' means consider all windows on all visible frames.
2385 - 0 (the number zero) means consider all windows on all visible and
2388 - A frame means consider all windows on that frame only.
2390 Anything else means consider all windows on WINDOW's frame and no
2393 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2394 `next-window' to iterate through the entire cycle of acceptable
2395 windows, eventually ending up back at the window you started with.
2396 `previous-window' traverses the same cycle, in the reverse order. */)
2397 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2399 return next_window (window
, minibuf
, all_frames
, 1);
2403 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2404 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2405 WINDOW must be a live window and defaults to the selected one. The
2406 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2409 MINIBUF nil or omitted means consider the minibuffer window only if the
2410 minibuffer is active. MINIBUF t means consider the minibuffer window
2411 even if the minibuffer is not active. Any other value means do not
2412 consider the minibuffer window even if the minibuffer is active.
2414 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2415 plus the minibuffer window if specified by the MINIBUF argument. If the
2416 minibuffer counts, consider all windows on all frames that share that
2417 minibuffer too. The following non-nil values of ALL-FRAMES have special
2420 - t means consider all windows on all existing frames.
2422 - `visible' means consider all windows on all visible frames.
2424 - 0 (the number zero) means consider all windows on all visible and
2427 - A frame means consider all windows on that frame only.
2429 Anything else means consider all windows on WINDOW's frame and no
2432 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2433 use `previous-window' to iterate through the entire cycle of
2434 acceptable windows, eventually ending up back at the window you
2435 started with. `next-window' traverses the same cycle, in the
2437 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2439 return next_window (window
, minibuf
, all_frames
, 0);
2443 /* Return a list of windows in cyclic ordering. Arguments are like
2444 for `next-window'. */
2447 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2449 Lisp_Object tail
, list
, rest
;
2451 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2454 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2455 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2456 list
= Fcons (XCAR (tail
), list
);
2458 /* Rotate the list to start with WINDOW. */
2459 list
= Fnreverse (list
);
2460 rest
= Fmemq (window
, list
);
2461 if (!NILP (rest
) && !EQ (rest
, list
))
2463 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2465 XSETCDR (tail
, Qnil
);
2466 list
= nconc2 (rest
, list
);
2472 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2473 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2474 FRAME nil or omitted means use the selected frame.
2475 WINDOW nil or omitted means use the window selected within FRAME.
2476 MINIBUF t means include the minibuffer window, even if it isn't active.
2477 MINIBUF nil or omitted means include the minibuffer window only
2479 MINIBUF neither nil nor t means never include the minibuffer window. */)
2480 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2483 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2484 CHECK_WINDOW (window
);
2486 frame
= selected_frame
;
2488 if (!EQ (frame
, XWINDOW (window
)->frame
))
2489 error ("Window is on a different frame");
2491 return window_list_1 (window
, minibuf
, frame
);
2495 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2496 doc
: /* Return a list of all live windows.
2497 WINDOW specifies the first window to list and defaults to the selected
2500 Optional argument MINIBUF nil or omitted means consider the minibuffer
2501 window only if the minibuffer is active. MINIBUF t means consider the
2502 minibuffer window even if the minibuffer is not active. Any other value
2503 means do not consider the minibuffer window even if the minibuffer is
2506 Optional argument ALL-FRAMES nil or omitted means consider all windows
2507 on WINDOW's frame, plus the minibuffer window if specified by the
2508 MINIBUF argument. If the minibuffer counts, consider all windows on all
2509 frames that share that minibuffer too. The following non-nil values of
2510 ALL-FRAMES have special meanings:
2512 - t means consider all windows on all existing frames.
2514 - `visible' means consider all windows on all visible frames.
2516 - 0 (the number zero) means consider all windows on all visible and
2519 - A frame means consider all windows on that frame only.
2521 Anything else means consider all windows on WINDOW's frame and no
2524 If WINDOW is not on the list of windows returned, some other window will
2525 be listed first but no error is signaled. */)
2526 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2528 return window_list_1 (window
, minibuf
, all_frames
);
2531 /* Look at all windows, performing an operation specified by TYPE
2533 If FRAMES is Qt, look at all frames;
2534 Qnil, look at just the selected frame;
2535 Qvisible, look at visible frames;
2536 a frame, just look at windows on that frame.
2537 If MINI is non-zero, perform the operation on minibuffer windows too. */
2542 GET_BUFFER_WINDOW
, /* Arg is buffer */
2543 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2544 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2549 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2551 Lisp_Object window
, windows
, best_window
, frame_arg
;
2552 int frame_best_window_flag
= 0;
2554 struct gcpro gcpro1
;
2556 /* If we're only looping through windows on a particular frame,
2557 frame points to that frame. If we're looping through windows
2558 on all frames, frame is 0. */
2559 if (FRAMEP (frames
))
2560 f
= XFRAME (frames
);
2561 else if (NILP (frames
))
2562 f
= SELECTED_FRAME ();
2567 frame_arg
= Qlambda
;
2568 else if (EQ (frames
, make_number (0)))
2570 else if (EQ (frames
, Qvisible
))
2575 /* frame_arg is Qlambda to stick to one frame,
2576 Qvisible to consider all visible frames,
2579 /* Pick a window to start with. */
2583 window
= FRAME_SELECTED_WINDOW (f
);
2585 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2587 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2591 for (; CONSP (windows
); windows
= XCDR (windows
))
2595 window
= XCAR (windows
);
2596 w
= XWINDOW (window
);
2598 /* Note that we do not pay attention here to whether the frame
2599 is visible, since Fwindow_list skips non-visible frames if
2600 that is desired, under the control of frame_arg. */
2601 if (!MINI_WINDOW_P (w
)
2602 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2603 consider all windows. */
2604 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2605 || (mini
&& minibuf_level
> 0))
2608 case GET_BUFFER_WINDOW
:
2609 if (EQ (w
->buffer
, obj
)
2610 /* Don't find any minibuffer window except the one that
2611 is currently in use. */
2612 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2614 if (EQ (window
, selected_window
))
2615 /* Preferably return the selected window. */
2616 RETURN_UNGCPRO (window
);
2617 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2618 && !frame_best_window_flag
)
2619 /* Prefer windows on the current frame (but don't
2620 choose another one if we have one already). */
2622 best_window
= window
;
2623 frame_best_window_flag
= 1;
2625 else if (NILP (best_window
))
2626 best_window
= window
;
2630 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2631 /* We could simply check whether the buffer shown by window
2632 is live, and show another buffer in case it isn't. */
2633 if (EQ (w
->buffer
, obj
))
2635 /* Undedicate WINDOW. */
2636 wset_dedicated (w
, Qnil
);
2637 /* Make WINDOW show the buffer returned by
2638 other_buffer_safely, don't run any hooks. */
2640 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2641 /* If WINDOW is the selected window, make its buffer
2642 current. But do so only if the window shows the
2643 current buffer (Bug#6454). */
2644 if (EQ (window
, selected_window
)
2645 && XBUFFER (w
->buffer
) == current_buffer
)
2646 Fset_buffer (w
->buffer
);
2650 case REDISPLAY_BUFFER_WINDOWS
:
2651 if (EQ (w
->buffer
, obj
))
2653 mark_window_display_accurate (window
, 0);
2654 w
->update_mode_line
= 1;
2655 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2656 ++update_mode_lines
;
2657 best_window
= window
;
2661 /* Check for a window that has a killed buffer. */
2662 case CHECK_ALL_WINDOWS
:
2663 if (! NILP (w
->buffer
)
2664 && !BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
2668 case WINDOW_LOOP_UNUSED
:
2677 /* Used for debugging. Abort if any window has a dead buffer. */
2679 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2681 check_all_windows (void)
2683 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2686 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2687 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2688 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2691 The optional argument ALL-FRAMES specifies the frames to consider:
2693 - t means consider all windows on all existing frames.
2695 - `visible' means consider all windows on all visible frames.
2697 - 0 (the number zero) means consider all windows on all visible
2698 and iconified frames.
2700 - A frame means consider all windows on that frame only.
2702 Any other value of ALL-FRAMES means consider all windows on the
2703 selected frame and no others. */)
2704 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2708 if (NILP (buffer_or_name
))
2709 buffer
= Fcurrent_buffer ();
2711 buffer
= Fget_buffer (buffer_or_name
);
2713 if (BUFFERP (buffer
))
2714 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2720 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2722 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2726 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2727 Sdelete_other_windows_internal
, 0, 2, "",
2728 doc
: /* Make WINDOW fill its frame.
2729 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2730 and defaults to the selected one.
2732 Optional argument ROOT, if non-nil, must specify an internal window such
2733 that WINDOW is in its window subtree. If this is the case, replace ROOT
2734 by WINDOW and leave alone any windows not part of ROOT's subtree.
2736 When WINDOW is live try to reduce display jumps by keeping the text
2737 previously visible in WINDOW in the same place on the frame. Doing this
2738 depends on the value of (window-start WINDOW), so if calling this
2739 function in a program gives strange scrolling, make sure the
2740 window-start value is reasonable when this function is called. */)
2741 (Lisp_Object window
, Lisp_Object root
)
2743 struct window
*w
, *r
, *s
;
2745 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2746 ptrdiff_t startpos
IF_LINT (= 0);
2747 int top
IF_LINT (= 0), new_top
, resize_failed
;
2749 w
= decode_valid_window (window
);
2750 XSETWINDOW (window
, w
);
2751 f
= XFRAME (w
->frame
);
2754 /* ROOT is the frame's root window. */
2756 root
= FRAME_ROOT_WINDOW (f
);
2760 /* ROOT must be an ancestor of WINDOW. */
2762 r
= decode_valid_window (root
);
2763 pwindow
= XWINDOW (window
)->parent
;
2764 while (!NILP (pwindow
))
2765 if (EQ (pwindow
, root
))
2768 pwindow
= XWINDOW (pwindow
)->parent
;
2769 if (!EQ (pwindow
, root
))
2770 error ("Specified root is not an ancestor of specified window");
2773 if (EQ (window
, root
))
2776 /* I don't understand the "top > 0" part below. If we deal with a
2777 standalone minibuffer it would have been caught by the preceding
2779 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2780 error ("Can't expand minibuffer to full frame");
2782 if (!NILP (w
->buffer
))
2784 startpos
= marker_position (w
->start
);
2785 top
= WINDOW_TOP_EDGE_LINE (w
)
2786 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2787 /* Make sure WINDOW is the frame's selected window. */
2788 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2790 if (EQ (selected_frame
, w
->frame
))
2791 Fselect_window (window
, Qnil
);
2793 fset_selected_window (f
, window
);
2798 /* See if the frame's selected window is a part of the window
2799 subtree rooted at WINDOW, by finding all the selected window's
2800 parents and comparing each one with WINDOW. If it isn't we
2801 need a new selected window for this frame. */
2802 swindow
= FRAME_SELECTED_WINDOW (f
);
2806 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2807 pwindow
= XWINDOW (pwindow
)->parent
;
2809 if (EQ (window
, pwindow
))
2810 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2811 as the new selected window. */
2814 /* Else try the previous window of SWINDOW. */
2815 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2818 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2820 if (EQ (selected_frame
, w
->frame
))
2821 Fselect_window (swindow
, Qnil
);
2823 fset_selected_window (f
, swindow
);
2828 if (!FRAME_INITIAL_P (f
))
2830 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2832 /* We are going to free the glyph matrices of WINDOW, and with
2833 that we might lose any information about glyph rows that have
2834 some of their glyphs highlighted in mouse face. (These rows
2835 are marked with a non-zero mouse_face_p flag.) If WINDOW
2836 indeed has some glyphs highlighted in mouse face, signal to
2837 frame's up-to-date hook that mouse highlight was overwritten,
2838 so that it will arrange for redisplaying the highlight. */
2839 if (EQ (hlinfo
->mouse_face_window
, window
))
2841 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2842 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2843 hlinfo
->mouse_face_window
= Qnil
;
2846 free_window_matrices (r
);
2848 windows_or_buffers_changed
++;
2849 Vwindow_list
= Qnil
;
2850 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2853 if (NILP (w
->buffer
))
2855 /* Resize child windows vertically. */
2856 XSETINT (delta
, XINT (r
->total_lines
)
2857 - XINT (w
->total_lines
));
2858 wset_top_line (w
, r
->top_line
);
2859 resize_root_window (window
, delta
, Qnil
, Qnil
);
2860 if (window_resize_check (w
, 0))
2861 window_resize_apply (w
, 0);
2864 resize_root_window (window
, delta
, Qnil
, Qt
);
2865 if (window_resize_check (w
, 0))
2866 window_resize_apply (w
, 0);
2871 /* Resize child windows horizontally. */
2874 wset_left_col (w
, r
->left_col
);
2876 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2877 wset_left_col (w
, r
->left_col
);
2878 resize_root_window (window
, delta
, Qt
, Qnil
);
2879 if (window_resize_check (w
, 1))
2880 window_resize_apply (w
, 1);
2883 resize_root_window (window
, delta
, Qt
, Qt
);
2884 if (window_resize_check (w
, 1))
2885 window_resize_apply (w
, 1);
2892 /* Play safe, if we still can ... */
2895 w
= XWINDOW (window
);
2899 /* Cleanly unlink WINDOW from window-tree. */
2900 if (!NILP (w
->prev
))
2901 /* Get SIBLING above (on the left of) WINDOW. */
2904 s
= XWINDOW (sibling
);
2905 wset_next (s
, w
->next
);
2906 if (!NILP (s
->next
))
2907 wset_prev (XWINDOW (s
->next
), sibling
);
2910 /* Get SIBLING below (on the right of) WINDOW. */
2913 s
= XWINDOW (sibling
);
2914 wset_prev (s
, Qnil
);
2915 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2916 wset_vchild (XWINDOW (w
->parent
), sibling
);
2918 wset_hchild (XWINDOW (w
->parent
), sibling
);
2921 /* Delete ROOT and all child windows of ROOT. */
2922 if (!NILP (r
->vchild
))
2924 delete_all_child_windows (r
->vchild
);
2925 wset_vchild (r
, Qnil
);
2927 else if (!NILP (r
->hchild
))
2929 delete_all_child_windows (r
->hchild
);
2930 wset_hchild (r
, Qnil
);
2933 replace_window (root
, window
, 1);
2935 /* This must become SWINDOW anyway ....... */
2936 if (!NILP (w
->buffer
) && !resize_failed
)
2938 /* Try to minimize scrolling, by setting the window start to the
2939 point will cause the text at the old window start to be at the
2940 same place on the frame. But don't try to do this if the
2941 window start is outside the visible portion (as might happen
2942 when the display is not current, due to typeahead). */
2943 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2945 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2946 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2948 struct position pos
;
2949 struct buffer
*obuf
= current_buffer
;
2951 Fset_buffer (w
->buffer
);
2952 /* This computation used to temporarily move point, but that
2953 can have unwanted side effects due to text properties. */
2954 pos
= *vmotion (startpos
, -top
, w
);
2956 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2957 w
->window_end_valid
= 0;
2958 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2959 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2960 /* We need to do this, so that the window-scroll-functions
2962 w
->optional_new_start
= 1;
2964 set_buffer_internal (obuf
);
2971 run_window_configuration_change_hook (f
);
2978 replace_buffer_in_windows (Lisp_Object buffer
)
2980 call1 (Qreplace_buffer_in_windows
, buffer
);
2983 /* If BUFFER is shown in a window, safely replace it with some other
2984 buffer in all windows of all frames, even those on other keyboards. */
2987 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2989 if (buffer_window_count (XBUFFER (buffer
)))
2991 Lisp_Object tail
, frame
;
2993 /* A single call to window_loop won't do the job because it only
2994 considers frames on the current keyboard. So loop manually over
2995 frames, and handle each one. */
2996 FOR_EACH_FRAME (tail
, frame
)
2997 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
3001 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
3002 minimum allowable size. */
3005 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
3007 /* For height, we have to see:
3008 how many windows the frame has at minimum (one or two),
3009 and whether it has a menu bar or other special stuff at the top. */
3011 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
3012 ? MIN_SAFE_WINDOW_HEIGHT
3013 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
3015 if (FRAME_TOP_MARGIN (frame
) > 0)
3016 min_height
+= FRAME_TOP_MARGIN (frame
);
3018 if (*rows
< min_height
)
3020 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
3021 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3024 /* Adjust the margins of window W if text area is too small.
3025 Return 1 if window width is ok after adjustment; 0 if window
3026 is still too narrow. */
3029 adjust_window_margins (struct window
*w
)
3031 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3032 - WINDOW_FRINGE_COLS (w
)
3033 - WINDOW_SCROLL_BAR_COLS (w
));
3034 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3035 + WINDOW_RIGHT_MARGIN_COLS (w
));
3037 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3040 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3043 /* Window's text area is too narrow, but reducing the window
3044 margins will fix that. */
3045 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3046 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3048 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3050 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3051 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3054 wset_right_margin_cols (w
, make_number (margin_cols
));
3057 wset_left_margin_cols (w
, make_number (margin_cols
));
3061 /* The following three routines are needed for running a window's
3062 configuration change hook. */
3064 run_funs (Lisp_Object funs
)
3066 for (; CONSP (funs
); funs
= XCDR (funs
))
3067 if (!EQ (XCAR (funs
), Qt
))
3068 call0 (XCAR (funs
));
3072 select_window_norecord (Lisp_Object window
)
3074 return WINDOW_LIVE_P (window
)
3075 ? Fselect_window (window
, Qt
) : selected_window
;
3079 select_frame_norecord (Lisp_Object frame
)
3081 return FRAME_LIVE_P (XFRAME (frame
))
3082 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3086 run_window_configuration_change_hook (struct frame
*f
)
3088 ptrdiff_t count
= SPECPDL_INDEX ();
3089 Lisp_Object frame
, global_wcch
3090 = Fdefault_value (Qwindow_configuration_change_hook
);
3091 XSETFRAME (frame
, f
);
3093 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3096 /* Use the right buffer. Matters when running the local hooks. */
3097 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3099 record_unwind_current_buffer ();
3100 Fset_buffer (Fwindow_buffer (Qnil
));
3103 if (SELECTED_FRAME () != f
)
3105 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3106 select_frame_norecord (frame
);
3109 /* Look for buffer-local values. */
3111 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3112 for (; CONSP (windows
); windows
= XCDR (windows
))
3114 Lisp_Object window
= XCAR (windows
);
3115 Lisp_Object buffer
= Fwindow_buffer (window
);
3116 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3119 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3120 record_unwind_protect (select_window_norecord
, Fselected_window ());
3121 select_window_norecord (window
);
3122 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3124 unbind_to (inner_count
, Qnil
);
3129 run_funs (global_wcch
);
3130 unbind_to (count
, Qnil
);
3133 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3134 Srun_window_configuration_change_hook
, 0, 1, 0,
3135 doc
: /* Run `window-configuration-change-hook' for FRAME.
3136 If FRAME is omitted or nil, it defaults to the selected frame. */)
3139 run_window_configuration_change_hook (decode_live_frame (frame
));
3143 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3144 means it's allowed to run hooks. See make_frame for a case where
3145 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3146 margins, fringes, and scroll-bar settings of the window are not
3147 reset from the buffer's local settings. */
3150 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3152 struct window
*w
= XWINDOW (window
);
3153 struct buffer
*b
= XBUFFER (buffer
);
3154 ptrdiff_t count
= SPECPDL_INDEX ();
3155 int samebuf
= EQ (buffer
, w
->buffer
);
3157 wset_buffer (w
, buffer
);
3159 if (EQ (window
, selected_window
))
3160 bset_last_selected_window (b
, window
);
3162 /* Let redisplay errors through. */
3163 b
->display_error_modiff
= 0;
3165 /* Update time stamps of buffer display. */
3166 if (INTEGERP (BVAR (b
, display_count
)))
3167 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3168 bset_display_time (b
, Fcurrent_time ());
3170 wset_window_end_pos (w
, make_number (0));
3171 wset_window_end_vpos (w
, make_number (0));
3172 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3174 if (!(keep_margins_p
&& samebuf
))
3175 { /* If we're not actually changing the buffer, don't reset hscroll and
3176 vscroll. This case happens for example when called from
3177 change_frame_size_1, where we use a dummy call to
3178 Fset_window_buffer on the frame's selected window (and no other)
3179 just in order to run window-configuration-change-hook.
3180 Resetting hscroll and vscroll here is problematic for things like
3181 image-mode and doc-view-mode since it resets the image's position
3182 whenever we resize the frame. */
3183 w
->hscroll
= w
->min_hscroll
= 0;
3185 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3186 set_marker_restricted (w
->start
,
3187 make_number (b
->last_window_start
),
3189 w
->start_at_line_beg
= 0;
3191 w
->last_modified
= 0;
3192 w
->last_overlay_modified
= 0;
3194 /* Maybe we could move this into the `if' but it's not obviously safe and
3195 I doubt it's worth the trouble. */
3196 windows_or_buffers_changed
++;
3198 /* We must select BUFFER for running the window-scroll-functions. */
3199 /* We can't check ! NILP (Vwindow_scroll_functions) here
3200 because that might itself be a local variable. */
3201 if (window_initialized
)
3203 record_unwind_current_buffer ();
3204 Fset_buffer (buffer
);
3207 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3209 if (!keep_margins_p
)
3211 /* Set left and right marginal area width etc. from buffer. */
3213 /* This may call adjust_window_margins three times, so
3214 temporarily disable window margins. */
3215 Lisp_Object save_left
= w
->left_margin_cols
;
3216 Lisp_Object save_right
= w
->right_margin_cols
;
3218 wset_left_margin_cols (w
, Qnil
);
3219 wset_right_margin_cols (w
, Qnil
);
3221 Fset_window_fringes (window
,
3222 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3223 BVAR (b
, fringes_outside_margins
));
3225 Fset_window_scroll_bars (window
,
3226 BVAR (b
, scroll_bar_width
),
3227 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3229 wset_left_margin_cols (w
, save_left
);
3230 wset_right_margin_cols (w
, save_right
);
3232 Fset_window_margins (window
,
3233 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3238 if (! NILP (Vwindow_scroll_functions
))
3239 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3240 Fmarker_position (w
->start
));
3241 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3244 unbind_to (count
, Qnil
);
3247 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3248 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3249 WINDOW must be a live window and defaults to the selected one.
3250 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3252 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3253 display margins, fringe widths, and scroll bar settings are preserved;
3254 the default is to reset these from the local settings for BUFFER-OR-NAME
3255 or the frame defaults. Return nil.
3257 This function throws an error when WINDOW is strongly dedicated to its
3258 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3259 already display BUFFER-OR-NAME.
3261 This function runs `window-scroll-functions' before running
3262 `window-configuration-change-hook'. */)
3263 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3265 register Lisp_Object tem
, buffer
;
3266 register struct window
*w
= decode_live_window (window
);
3268 XSETWINDOW (window
, w
);
3269 buffer
= Fget_buffer (buffer_or_name
);
3270 CHECK_BUFFER (buffer
);
3271 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3272 error ("Attempt to display deleted buffer");
3276 error ("Window is deleted");
3279 if (!EQ (tem
, buffer
))
3281 if (EQ (w
->dedicated
, Qt
))
3282 /* WINDOW is strongly dedicated to its buffer, signal an
3284 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3286 /* WINDOW is weakly dedicated to its buffer, reset
3288 wset_dedicated (w
, Qnil
);
3290 call1 (Qrecord_window_buffer
, window
);
3296 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3302 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3304 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3307 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3309 doc
: /* Force all windows to be updated on next redisplay.
3310 If optional arg OBJECT is a window, force redisplay of that window only.
3311 If OBJECT is a buffer or buffer name, force redisplay of all windows
3312 displaying that buffer. */)
3313 (Lisp_Object object
)
3317 windows_or_buffers_changed
++;
3318 update_mode_lines
++;
3322 if (WINDOWP (object
))
3324 struct window
*w
= XWINDOW (object
);
3325 mark_window_display_accurate (object
, 0);
3326 w
->update_mode_line
= 1;
3327 if (BUFFERP (w
->buffer
))
3328 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3329 ++update_mode_lines
;
3333 if (STRINGP (object
))
3334 object
= Fget_buffer (object
);
3335 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
))
3336 && buffer_window_count (XBUFFER (object
)))
3338 /* If buffer is live and shown in at least one window, find
3339 all windows showing this buffer and force update of them. */
3340 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3341 return NILP (object
) ? Qnil
: Qt
;
3344 /* If nothing suitable was found, just return.
3345 We could signal an error, but this feature will typically be used
3346 asynchronously in timers or process sentinels, so we don't. */
3350 /* Obsolete since 24.3. */
3352 temp_output_buffer_show (register Lisp_Object buf
)
3354 register struct buffer
*old
= current_buffer
;
3355 register Lisp_Object window
;
3356 register struct window
*w
;
3358 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3361 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3365 set_buffer_internal (old
);
3367 if (!NILP (Vtemp_buffer_show_function
))
3368 call1 (Vtemp_buffer_show_function
, buf
);
3371 window
= display_buffer (buf
, Qnil
, Qnil
);
3373 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3374 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3375 Vminibuf_scroll_window
= window
;
3376 w
= XWINDOW (window
);
3379 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3380 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3382 /* Run temp-buffer-show-hook, with the chosen window selected
3383 and its buffer current. */
3385 ptrdiff_t count
= SPECPDL_INDEX ();
3386 Lisp_Object prev_window
, prev_buffer
;
3387 prev_window
= selected_window
;
3388 XSETBUFFER (prev_buffer
, old
);
3390 /* Select the window that was chosen, for running the hook.
3391 Note: Both Fselect_window and select_window_norecord may
3392 set-buffer to the buffer displayed in the window,
3393 so we need to save the current buffer. --stef */
3394 record_unwind_protect (Fset_buffer
, prev_buffer
);
3395 record_unwind_protect (select_window_norecord
, prev_window
);
3396 Fselect_window (window
, Qt
);
3397 Fset_buffer (w
->buffer
);
3398 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3399 unbind_to (count
, Qnil
);
3404 /* Make new window, have it replace WINDOW in window-tree, and make
3405 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3406 horizontal child). */
3408 make_parent_window (Lisp_Object window
, int horflag
)
3411 register struct window
*o
, *p
;
3413 o
= XWINDOW (window
);
3414 p
= allocate_window ();
3415 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3416 (char *) o
+ sizeof (struct vectorlike_header
),
3417 word_size
* VECSIZE (struct window
));
3418 /* P's buffer slot may change from nil to a buffer. */
3419 adjust_window_count (p
, 1);
3420 XSETWINDOW (parent
, p
);
3422 replace_window (window
, parent
, 1);
3424 wset_next (o
, Qnil
);
3425 wset_prev (o
, Qnil
);
3426 wset_parent (o
, parent
);
3428 wset_hchild (p
, horflag
? window
: Qnil
);
3429 wset_vchild (p
, horflag
? Qnil
: window
);
3430 wset_start (p
, Qnil
);
3431 wset_pointm (p
, Qnil
);
3432 wset_buffer (p
, Qnil
);
3433 wset_combination_limit (p
, Qnil
);
3434 wset_window_parameters (p
, Qnil
);
3437 /* Make new window from scratch. */
3442 register struct window
*w
;
3444 w
= allocate_window ();
3445 /* Initialize Lisp data. Note that allocate_window initializes all
3446 Lisp data to nil, so do it only for slots which should not be nil. */
3447 wset_left_col (w
, make_number (0));
3448 wset_top_line (w
, make_number (0));
3449 wset_total_lines (w
, make_number (0));
3450 wset_total_cols (w
, make_number (0));
3451 wset_normal_lines (w
, make_float (1.0));
3452 wset_normal_cols (w
, make_float (1.0));
3453 wset_new_total (w
, make_number (0));
3454 wset_new_normal (w
, make_number (0));
3455 wset_start (w
, Fmake_marker ());
3456 wset_pointm (w
, Fmake_marker ());
3457 wset_vertical_scroll_bar_type (w
, Qt
);
3458 wset_window_end_pos (w
, make_number (0));
3459 wset_window_end_vpos (w
, make_number (0));
3460 /* These Lisp fields are marked specially so they're not set to nil by
3462 wset_prev_buffers (w
, Qnil
);
3463 wset_next_buffers (w
, Qnil
);
3465 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3466 non-Lisp data, so do it only for slots which should not be zero. */
3467 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3468 w
->phys_cursor_type
= -1;
3469 w
->phys_cursor_width
= -1;
3470 w
->column_number_displayed
= -1;
3472 /* Reset window_list. */
3473 Vwindow_list
= Qnil
;
3474 /* Return window. */
3475 XSETWINDOW (window
, w
);
3479 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3480 doc
: /* Set new total size of WINDOW to SIZE.
3481 WINDOW must be a valid window and defaults to the selected one.
3484 Optional argument ADD non-nil means add SIZE to the new total size of
3485 WINDOW and return the sum.
3487 Note: This function does not operate on any child windows of WINDOW. */)
3488 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3490 struct window
*w
= decode_valid_window (window
);
3492 CHECK_NUMBER (size
);
3494 wset_new_total (w
, size
);
3496 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3498 return w
->new_total
;
3501 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3502 doc
: /* Set new normal size of WINDOW to SIZE.
3503 WINDOW must be a valid window and defaults to the selected one.
3506 Note: This function does not operate on any child windows of WINDOW. */)
3507 (Lisp_Object window
, Lisp_Object size
)
3509 wset_new_normal (decode_valid_window (window
), size
);
3513 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3514 non-zero) to w->new_total would result in correct heights (widths)
3515 for window W and recursively all child windows of W.
3517 Note: This function does not check any of `window-fixed-size-p',
3518 `window-min-height' or `window-min-width'. It does check that window
3519 sizes do not drop below one line (two columns). */
3521 window_resize_check (struct window
*w
, int horflag
)
3525 if (!NILP (w
->vchild
))
3526 /* W is a vertical combination. */
3528 c
= XWINDOW (w
->vchild
);
3530 /* All child windows of W must have the same width as W. */
3534 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3535 || !window_resize_check (c
, horflag
))
3537 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3542 /* The sum of the heights of the child windows of W must equal
3545 int sum_of_sizes
= 0;
3548 if (!window_resize_check (c
, horflag
))
3550 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3551 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3553 return (sum_of_sizes
== XINT (w
->new_total
));
3556 else if (!NILP (w
->hchild
))
3557 /* W is a horizontal combination. */
3559 c
= XWINDOW (w
->hchild
);
3561 /* The sum of the widths of the child windows of W must equal W's
3564 int sum_of_sizes
= 0;
3567 if (!window_resize_check (c
, horflag
))
3569 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3570 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3572 return (sum_of_sizes
== XINT (w
->new_total
));
3575 /* All child windows of W must have the same height as W. */
3579 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3580 || !window_resize_check (c
, horflag
))
3582 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3588 /* A leaf window. Make sure it's not too small. The following
3589 hardcodes the values of `window-safe-min-width' (2) and
3590 `window-safe-min-height' (1) which are defined in window.el. */
3591 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3594 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3595 w->new_total for window W and recursively all child windows of W.
3596 Also calculate and assign the new vertical (horizontal) start
3597 positions of each of these windows.
3599 This function does not perform any error checks. Make sure you have
3600 run window_resize_check on W before applying this function. */
3602 window_resize_apply (struct window
*w
, int horflag
)
3607 /* Note: Assigning new_normal requires that the new total size of the
3608 parent window has been set *before*. */
3611 wset_total_cols (w
, w
->new_total
);
3612 if (NUMBERP (w
->new_normal
))
3613 wset_normal_cols (w
, w
->new_normal
);
3615 pos
= XINT (w
->left_col
);
3619 wset_total_lines (w
, w
->new_total
);
3620 if (NUMBERP (w
->new_normal
))
3621 wset_normal_lines (w
, w
->new_normal
);
3623 pos
= XINT (w
->top_line
);
3626 if (!NILP (w
->vchild
))
3627 /* W is a vertical combination. */
3629 c
= XWINDOW (w
->vchild
);
3633 wset_left_col (c
, make_number (pos
));
3635 wset_top_line (c
, make_number (pos
));
3636 window_resize_apply (c
, horflag
);
3638 pos
= pos
+ XINT (c
->total_lines
);
3639 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3642 else if (!NILP (w
->hchild
))
3643 /* W is a horizontal combination. */
3645 c
= XWINDOW (w
->hchild
);
3649 wset_left_col (c
, make_number (pos
));
3651 wset_top_line (c
, make_number (pos
));
3652 window_resize_apply (c
, horflag
);
3654 pos
= pos
+ XINT (c
->total_cols
);
3655 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3659 /* Clear out some redisplay caches. */
3660 w
->last_modified
= 0;
3661 w
->last_overlay_modified
= 0;
3665 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3666 doc
: /* Apply requested size values for window-tree of FRAME.
3667 If FRAME is omitted or nil, it defaults to the selected frame.
3669 Optional argument HORIZONTAL omitted or nil means apply requested
3670 height values. HORIZONTAL non-nil means apply requested width values.
3672 This function checks whether the requested values sum up to a valid
3673 window layout, recursively assigns the new sizes of all child windows
3674 and calculates and assigns the new start positions of these windows.
3676 Note: This function does not check any of `window-fixed-size-p',
3677 `window-min-height' or `window-min-width'. All these checks have to
3678 be applied on the Elisp level. */)
3679 (Lisp_Object frame
, Lisp_Object horizontal
)
3681 struct frame
*f
= decode_live_frame (frame
);
3682 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3683 int horflag
= !NILP (horizontal
);
3685 if (!window_resize_check (r
, horflag
)
3686 || ! EQ (r
->new_total
,
3687 (horflag
? r
->total_cols
: r
->total_lines
)))
3691 window_resize_apply (r
, horflag
);
3693 windows_or_buffers_changed
++;
3694 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3699 run_window_configuration_change_hook (f
);
3705 /* Resize frame F's windows when number of lines of F is set to SIZE.
3706 HORFLAG 1 means resize windows when number of columns of F is set to
3709 This function can delete all windows but the selected one in order to
3710 satisfy the request. The result will be meaningful if and only if
3711 F's windows have meaningful sizes when you call this. */
3713 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3715 Lisp_Object root
= f
->root_window
;
3716 struct window
*r
= XWINDOW (root
);
3717 Lisp_Object mini
= f
->minibuffer_window
;
3719 /* new_size is the new size of the frame's root window. */
3720 int new_size
= (horflag
3723 - FRAME_TOP_MARGIN (f
)
3724 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3727 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3728 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3729 /* For a leaf root window just set the size. */
3731 wset_total_cols (r
, make_number (new_size
));
3733 wset_total_lines (r
, make_number (new_size
));
3736 /* old_size is the old size of the frame's root window. */
3737 int old_size
= XFASTINT (horflag
? r
->total_cols
3741 XSETINT (delta
, new_size
- old_size
);
3742 /* Try a "normal" resize first. */
3743 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3744 if (window_resize_check (r
, horflag
)
3745 && new_size
== XINT (r
->new_total
))
3746 window_resize_apply (r
, horflag
);
3749 /* Try with "reasonable" minimum sizes next. */
3750 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3751 if (window_resize_check (r
, horflag
)
3752 && new_size
== XINT (r
->new_total
))
3753 window_resize_apply (r
, horflag
);
3756 /* Finally, try with "safe" minimum sizes. */
3757 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3758 if (window_resize_check (r
, horflag
)
3759 && new_size
== XINT (r
->new_total
))
3760 window_resize_apply (r
, horflag
);
3763 /* We lost. Delete all windows but the frame's
3765 root
= f
->selected_window
;
3766 Fdelete_other_windows_internal (root
, Qnil
);
3768 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3770 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3776 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3780 wset_total_cols (m
, make_number (size
));
3783 /* Are we sure we always want 1 line here? */
3784 wset_total_lines (m
, make_number (1));
3786 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3790 windows_or_buffers_changed
++;
3794 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3795 doc
: /* Split window OLD.
3796 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3797 new window. In any case TOTAL-SIZE must be a positive integer.
3799 Third argument SIDE nil (or `below') specifies that the new window shall
3800 be located below WINDOW. SIDE `above' means the new window shall be
3801 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3802 lines of the new window including space reserved for the mode and/or
3805 SIDE t (or `right') specifies that the new window shall be located on
3806 the right side of WINDOW. SIDE `left' means the new window shall be
3807 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3808 number of columns of the new window including space reserved for fringes
3809 and the scrollbar or a divider column.
3811 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3812 according to the SIDE argument.
3814 The new total and normal sizes of all involved windows must have been
3815 set correctly. See the code of `split-window' for how this is done. */)
3816 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3818 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3819 parent window or an internal window we have to install as OLD's new
3820 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3821 provided OLD is a leaf window, or to the frame's selected window.
3822 NEW (*n) is the new window created with some parameters taken from
3824 register Lisp_Object
new, frame
, reference
;
3825 register struct window
*o
, *p
, *n
, *r
;
3828 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3829 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3830 int combination_limit
= 0;
3834 frame
= WINDOW_FRAME (o
);
3837 CHECK_NUMBER (total_size
);
3839 /* Set combination_limit to 1 if we have to make a new parent window.
3840 We do that if either `window-combination-limit' is t, or OLD has no
3841 parent, or OLD is ortho-combined. */
3843 EQ (Vwindow_combination_limit
, Qt
)
3846 ? (XWINDOW (o
->parent
)->hchild
)
3847 : (XWINDOW (o
->parent
)->vchild
));
3849 /* We need a live reference window to initialize some parameters. */
3850 if (WINDOW_LIVE_P (old
))
3851 /* OLD is live, use it as reference window. */
3854 /* Use the frame's selected window as reference window. */
3855 reference
= FRAME_SELECTED_WINDOW (f
);
3856 r
= XWINDOW (reference
);
3858 /* The following bugs are caught by `split-window'. */
3859 if (MINI_WINDOW_P (o
))
3860 error ("Attempt to split minibuffer window");
3861 else if (XINT (total_size
) < (horflag
? 2 : 1))
3862 error ("Size of new window too small (after split)");
3863 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3864 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3867 p
= XWINDOW (o
->parent
);
3868 /* Temporarily pretend we split the parent window. */
3870 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3871 - XINT (total_size
)));
3872 if (!window_resize_check (p
, horflag
))
3873 error ("Window sizes don't fit");
3875 /* Undo the temporary pretension. */
3876 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3880 if (!window_resize_check (o
, horflag
))
3881 error ("Resizing old window failed");
3882 else if (XINT (total_size
) + XINT (o
->new_total
)
3883 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3884 error ("Sum of sizes of old and new window don't fit");
3887 /* This is our point of no return. */
3888 if (combination_limit
)
3890 /* Save the old value of o->normal_cols/lines. It gets corrupted
3891 by make_parent_window and we need it below for assigning it to
3893 Lisp_Object new_normal
3894 = horflag
? o
->normal_cols
: o
->normal_lines
;
3896 make_parent_window (old
, horflag
);
3897 p
= XWINDOW (o
->parent
);
3898 if (EQ (Vwindow_combination_limit
, Qt
))
3899 /* Store t in the new parent's combination_limit slot to avoid
3900 that its children get merged into another window. */
3901 wset_combination_limit (p
, Qt
);
3902 /* These get applied below. */
3903 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3904 wset_new_normal (p
, new_normal
);
3907 p
= XWINDOW (o
->parent
);
3909 windows_or_buffers_changed
++;
3910 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3911 new = make_window ();
3913 wset_frame (n
, frame
);
3914 wset_parent (n
, o
->parent
);
3915 wset_vchild (n
, Qnil
);
3916 wset_hchild (n
, Qnil
);
3918 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3920 wset_prev (n
, o
->prev
);
3923 wset_hchild (p
, new);
3925 wset_vchild (p
, new);
3927 wset_next (XWINDOW (n
->prev
), new);
3933 wset_next (n
, o
->next
);
3934 if (!NILP (n
->next
))
3935 wset_prev (XWINDOW (n
->next
), new);
3940 n
->window_end_valid
= 0;
3941 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3943 /* Get special geometry settings from reference window. */
3944 wset_left_margin_cols (n
, r
->left_margin_cols
);
3945 wset_right_margin_cols (n
, r
->right_margin_cols
);
3946 wset_left_fringe_width (n
, r
->left_fringe_width
);
3947 wset_right_fringe_width (n
, r
->right_fringe_width
);
3948 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3949 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3950 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3952 /* Directly assign orthogonal coordinates and sizes. */
3955 wset_top_line (n
, o
->top_line
);
3956 wset_total_lines (n
, o
->total_lines
);
3960 wset_left_col (n
, o
->left_col
);
3961 wset_total_cols (n
, o
->total_cols
);
3964 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3965 get them ready here. */
3966 wset_new_total (n
, total_size
);
3967 wset_new_normal (n
, normal_size
);
3970 window_resize_apply (p
, horflag
);
3972 /* Set buffer of NEW to buffer of reference window. Don't run
3974 set_window_buffer (new, r
->buffer
, 0, 1);
3977 /* Maybe we should run the scroll functions in Elisp (which already
3978 runs the configuration change hook). */
3979 if (! NILP (Vwindow_scroll_functions
))
3980 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3981 Fmarker_position (n
->start
));
3987 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3988 doc
: /* Remove WINDOW from its frame.
3989 WINDOW defaults to the selected window. Return nil.
3990 Signal an error when WINDOW is the only window on its frame. */)
3991 (register Lisp_Object window
)
3993 register Lisp_Object parent
, sibling
, frame
, root
;
3994 struct window
*w
, *p
, *s
, *r
;
3997 int before_sibling
= 0;
3999 w
= decode_any_window (window
);
4000 XSETWINDOW (window
, w
);
4001 if (NILP (w
->buffer
)
4002 && NILP (w
->hchild
) && NILP (w
->vchild
))
4003 /* It's a no-op to delete an already deleted window. */
4008 /* Never delete a minibuffer or frame root window. */
4009 error ("Attempt to delete minibuffer or sole ordinary window");
4010 else if (NILP (w
->prev
) && NILP (w
->next
))
4011 /* Rather bow out here, this case should be handled on the Elisp
4013 error ("Attempt to delete sole window of parent");
4015 p
= XWINDOW (parent
);
4016 horflag
= NILP (p
->vchild
);
4018 frame
= WINDOW_FRAME (w
);
4021 root
= FRAME_ROOT_WINDOW (f
);
4024 /* Unlink WINDOW from window tree. */
4026 /* Get SIBLING below (on the right of) WINDOW. */
4028 /* before_sibling 1 means WINDOW is the first child of its
4029 parent and thus before the sibling. */
4032 s
= XWINDOW (sibling
);
4033 wset_prev (s
, Qnil
);
4035 wset_hchild (p
, sibling
);
4037 wset_vchild (p
, sibling
);
4040 /* Get SIBLING above (on the left of) WINDOW. */
4043 s
= XWINDOW (sibling
);
4044 wset_next (s
, w
->next
);
4045 if (!NILP (s
->next
))
4046 wset_prev (XWINDOW (s
->next
), sibling
);
4049 if (window_resize_check (r
, horflag
)
4050 && EQ (r
->new_total
,
4051 (horflag
? r
->total_cols
: r
->total_lines
)))
4052 /* We can delete WINDOW now. */
4057 window_resize_apply (p
, horflag
);
4059 /* If this window is referred to by the dpyinfo's mouse
4060 highlight, invalidate that slot to be safe (Bug#9904). */
4061 if (!FRAME_INITIAL_P (f
))
4063 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4065 if (EQ (hlinfo
->mouse_face_window
, window
))
4066 hlinfo
->mouse_face_window
= Qnil
;
4069 windows_or_buffers_changed
++;
4070 Vwindow_list
= Qnil
;
4071 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4073 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4074 free_window_matrices (w
);
4076 if (!NILP (w
->vchild
))
4078 delete_all_child_windows (w
->vchild
);
4079 wset_vchild (w
, Qnil
);
4081 else if (!NILP (w
->hchild
))
4083 delete_all_child_windows (w
->hchild
);
4084 wset_hchild (w
, Qnil
);
4086 else if (!NILP (w
->buffer
))
4089 unchain_marker (XMARKER (w
->pointm
));
4090 unchain_marker (XMARKER (w
->start
));
4091 wset_buffer (w
, Qnil
);
4094 if (NILP (s
->prev
) && NILP (s
->next
))
4095 /* A matrjoshka where SIBLING has become the only child of
4098 /* Put SIBLING into PARENT's place. */
4099 replace_window (parent
, sibling
, 0);
4100 /* Have SIBLING inherit the following three slot values from
4101 PARENT (the combination_limit slot is not inherited). */
4102 wset_normal_cols (s
, p
->normal_cols
);
4103 wset_normal_lines (s
, p
->normal_lines
);
4104 /* Mark PARENT as deleted. */
4105 wset_vchild (p
, Qnil
);
4106 wset_hchild (p
, Qnil
);
4107 /* Try to merge SIBLING into its new parent. */
4108 recombine_windows (sibling
);
4113 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4114 /* We deleted the frame's selected window. */
4116 /* Use the frame's first window as fallback ... */
4117 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4118 /* ... but preferably use its most recently used window. */
4119 Lisp_Object mru_window
;
4121 /* `get-mru-window' might fail for some reason so play it safe
4122 - promote the first window _without recording it_ first. */
4123 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4124 Fselect_window (new_selected_window
, Qt
);
4126 fset_selected_window (f
, new_selected_window
);
4130 /* Now look whether `get-mru-window' gets us something. */
4131 mru_window
= call1 (Qget_mru_window
, frame
);
4132 if (WINDOW_LIVE_P (mru_window
)
4133 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4134 new_selected_window
= mru_window
;
4136 /* If all ended up well, we now promote the mru window. */
4137 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4138 Fselect_window (new_selected_window
, Qnil
);
4140 fset_selected_window (f
, new_selected_window
);
4145 /* Must be run by the caller:
4146 run_window_configuration_change_hook (f); */
4149 /* We failed: Relink WINDOW into window tree. */
4153 wset_prev (s
, window
);
4155 wset_hchild (p
, window
);
4157 wset_vchild (p
, window
);
4161 wset_next (s
, window
);
4162 if (!NILP (w
->next
))
4163 wset_prev (XWINDOW (w
->next
), window
);
4165 error ("Deletion failed");
4171 /***********************************************************************
4172 Resizing Mini-Windows
4173 ***********************************************************************/
4175 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4178 grow_mini_window (struct window
*w
, int delta
)
4180 struct frame
*f
= XFRAME (w
->frame
);
4182 Lisp_Object root
, value
;
4184 eassert (MINI_WINDOW_P (w
));
4185 eassert (delta
>= 0);
4187 root
= FRAME_ROOT_WINDOW (f
);
4189 value
= call2 (Qwindow_resize_root_window_vertically
,
4190 root
, make_number (- delta
));
4191 if (INTEGERP (value
) && window_resize_check (r
, 0))
4194 window_resize_apply (r
, 0);
4196 /* Grow the mini-window. */
4198 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4200 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4201 w
->last_modified
= 0;
4202 w
->last_overlay_modified
= 0;
4204 windows_or_buffers_changed
++;
4211 /* Shrink mini-window W. */
4213 shrink_mini_window (struct window
*w
)
4215 struct frame
*f
= XFRAME (w
->frame
);
4217 Lisp_Object root
, value
;
4220 eassert (MINI_WINDOW_P (w
));
4222 size
= XINT (w
->total_lines
);
4225 root
= FRAME_ROOT_WINDOW (f
);
4227 value
= call2 (Qwindow_resize_root_window_vertically
,
4228 root
, make_number (size
- 1));
4229 if (INTEGERP (value
) && window_resize_check (r
, 0))
4232 window_resize_apply (r
, 0);
4234 /* Shrink the mini-window. */
4235 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4236 + XFASTINT (r
->total_lines
)));
4237 wset_total_lines (w
, make_number (1));
4239 w
->last_modified
= 0;
4240 w
->last_overlay_modified
= 0;
4242 windows_or_buffers_changed
++;
4246 /* If the above failed for whatever strange reason we must make a
4247 one window frame here. The same routine will be needed when
4248 shrinking the frame (and probably when making the initial
4249 *scratch* window). For the moment leave things as they are. */
4253 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4254 doc
: /* Resize minibuffer window WINDOW. */)
4255 (Lisp_Object window
)
4257 struct window
*w
= XWINDOW (window
);
4262 CHECK_WINDOW (window
);
4263 f
= XFRAME (w
->frame
);
4265 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4266 error ("Not a valid minibuffer window");
4267 else if (FRAME_MINIBUF_ONLY_P (f
))
4268 error ("Cannot resize a minibuffer-only frame");
4270 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4271 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4272 if (window_resize_check (r
, 0)
4273 && XINT (w
->new_total
) > 0
4274 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4277 window_resize_apply (r
, 0);
4279 wset_total_lines (w
, w
->new_total
);
4280 wset_top_line (w
, make_number (XINT (r
->top_line
)
4281 + XINT (r
->total_lines
)));
4283 windows_or_buffers_changed
++;
4284 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4288 run_window_configuration_change_hook (f
);
4291 else error ("Failed to resize minibuffer window");
4294 /* Mark window cursors off for all windows in the window tree rooted
4295 at W by setting their phys_cursor_on_p flag to zero. Called from
4296 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4297 the frame are cleared. */
4300 mark_window_cursors_off (struct window
*w
)
4304 if (!NILP (w
->hchild
))
4305 mark_window_cursors_off (XWINDOW (w
->hchild
));
4306 else if (!NILP (w
->vchild
))
4307 mark_window_cursors_off (XWINDOW (w
->vchild
));
4309 w
->phys_cursor_on_p
= 0;
4311 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4316 /* Return number of lines of text (not counting mode lines) in W. */
4319 window_internal_height (struct window
*w
)
4321 int ht
= XFASTINT (w
->total_lines
);
4323 if (!MINI_WINDOW_P (w
))
4325 if (!NILP (w
->parent
)
4326 || !NILP (w
->vchild
)
4327 || !NILP (w
->hchild
)
4330 || WINDOW_WANTS_MODELINE_P (w
))
4333 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4340 /************************************************************************
4342 ***********************************************************************/
4344 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4345 N screen-fulls, which is defined as the height of the window minus
4346 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4347 instead. Negative values of N mean scroll down. NOERROR non-zero
4348 means don't signal an error if we try to move over BEGV or ZV,
4352 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4355 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4357 /* If we must, use the pixel-based version which is much slower than
4358 the line-based one but can handle varying line heights. */
4359 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4360 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4362 window_scroll_line_based (window
, n
, whole
, noerror
);
4368 /* Implementation of window_scroll that works based on pixel line
4369 heights. See the comment of window_scroll for parameter
4373 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4376 struct window
*w
= XWINDOW (window
);
4377 struct text_pos start
;
4378 int this_scroll_margin
;
4379 /* True if we fiddled the window vscroll field without really scrolling. */
4381 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4382 void *itdata
= NULL
;
4384 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4385 /* Scrolling a minibuffer window via scroll bar when the echo area
4386 shows long text sometimes resets the minibuffer contents behind
4388 if (CHARPOS (start
) > ZV
)
4389 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4391 /* If PT is not visible in WINDOW, move back one half of
4392 the screen. Allow PT to be partially visible, otherwise
4393 something like (scroll-down 1) with PT in the line before
4394 the partially visible one would recenter. */
4396 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4398 itdata
= bidi_shelve_cache ();
4399 /* Move backward half the height of the window. Performance note:
4400 vmotion used here is about 10% faster, but would give wrong
4401 results for variable height lines. */
4402 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4403 it
.current_y
= it
.last_visible_y
;
4404 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4406 /* The function move_iterator_vertically may move over more than
4407 the specified y-distance. If it->w is small, e.g. a
4408 mini-buffer window, we may end up in front of the window's
4409 display area. This is the case when Start displaying at the
4410 start of the line containing PT in this case. */
4411 if (it
.current_y
<= 0)
4413 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4414 move_it_vertically_backward (&it
, 0);
4418 start
= it
.current
.pos
;
4419 bidi_unshelve_cache (itdata
, 0);
4421 else if (auto_window_vscroll_p
)
4423 if (rtop
|| rbot
) /* partially visible */
4426 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4428 dy
= max ((window_box_height (w
)
4429 - next_screen_context_lines
* dy
),
4435 /* Only vscroll backwards if already vscrolled forwards. */
4436 if (w
->vscroll
< 0 && rtop
> 0)
4438 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4439 Fset_window_vscroll (window
, make_number (px
), Qt
);
4445 /* Do vscroll if already vscrolled or only display line. */
4446 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4448 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4449 Fset_window_vscroll (window
, make_number (px
), Qt
);
4453 /* Maybe modify window start instead of scrolling. */
4454 if (rbot
> 0 || w
->vscroll
< 0)
4458 Fset_window_vscroll (window
, make_number (0), Qt
);
4459 /* If there are other text lines above the current row,
4460 move window start to current row. Else to next row. */
4462 spos
= XINT (Fline_beginning_position (Qnil
));
4464 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4465 set_marker_restricted (w
->start
, make_number (spos
),
4467 w
->start_at_line_beg
= 1;
4468 w
->update_mode_line
= 1;
4469 w
->last_modified
= 0;
4470 w
->last_overlay_modified
= 0;
4471 /* Set force_start so that redisplay_window will run the
4472 window-scroll-functions. */
4478 /* Cancel previous vscroll. */
4479 Fset_window_vscroll (window
, make_number (0), Qt
);
4482 itdata
= bidi_shelve_cache ();
4483 /* If scroll_preserve_screen_position is non-nil, we try to set
4484 point in the same window line as it is now, so get that line. */
4485 if (!NILP (Vscroll_preserve_screen_position
))
4487 /* We preserve the goal pixel coordinate across consecutive
4488 calls to scroll-up, scroll-down and other commands that
4489 have the `scroll-command' property. This avoids the
4490 possibility of point becoming "stuck" on a tall line when
4491 scrolling by one line. */
4492 if (window_scroll_pixel_based_preserve_y
< 0
4493 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4494 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4496 start_display (&it
, w
, start
);
4497 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4498 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4499 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4503 window_scroll_pixel_based_preserve_y
4504 = window_scroll_pixel_based_preserve_x
= -1;
4506 /* Move iterator it from start the specified distance forward or
4507 backward. The result is the new window start. */
4508 start_display (&it
, w
, start
);
4511 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4512 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4513 dy
= max ((window_box_height (w
)
4514 - next_screen_context_lines
* dy
),
4517 /* Note that move_it_vertically always moves the iterator to the
4518 start of a line. So, if the last line doesn't have a newline,
4519 we would end up at the start of the line ending at ZV. */
4522 move_it_vertically_backward (&it
, -dy
);
4523 /* Ensure we actually do move, e.g. in case we are currently
4524 looking at an image that is taller that the window height. */
4525 while (start_pos
== IT_CHARPOS (it
)
4526 && start_pos
> BEGV
)
4527 move_it_by_lines (&it
, -1);
4531 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4532 MOVE_TO_POS
| MOVE_TO_Y
);
4533 /* Ensure we actually do move, e.g. in case we are currently
4534 looking at an image that is taller that the window height. */
4535 while (start_pos
== IT_CHARPOS (it
)
4537 move_it_by_lines (&it
, 1);
4541 move_it_by_lines (&it
, n
);
4543 /* We failed if we find ZV is already on the screen (scrolling up,
4544 means there's nothing past the end), or if we can't start any
4545 earlier (scrolling down, means there's nothing past the top). */
4546 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4547 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4549 if (IT_CHARPOS (it
) == ZV
)
4551 if (it
.current_y
< it
.last_visible_y
4552 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4553 > it
.last_visible_y
))
4555 /* The last line was only partially visible, make it fully
4557 w
->vscroll
= (it
.last_visible_y
4558 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4559 adjust_glyphs (it
.f
);
4563 bidi_unshelve_cache (itdata
, 0);
4566 else if (n
< 0) /* could happen with empty buffers */
4567 xsignal0 (Qbeginning_of_buffer
);
4569 xsignal0 (Qend_of_buffer
);
4574 if (w
->vscroll
!= 0)
4575 /* The first line was only partially visible, make it fully
4580 bidi_unshelve_cache (itdata
, 0);
4584 xsignal0 (Qbeginning_of_buffer
);
4588 /* If control gets here, then we vscrolled. */
4590 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4592 /* Don't try to change the window start below. */
4598 ptrdiff_t pos
= IT_CHARPOS (it
);
4601 /* If in the middle of a multi-glyph character move forward to
4602 the next character. */
4603 if (in_display_vector_p (&it
))
4606 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4609 /* Set the window start, and set up the window for redisplay. */
4610 set_marker_restricted_both (w
->start
, w
->buffer
, IT_CHARPOS (it
),
4612 bytepos
= marker_byte_position (w
->start
);
4613 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4614 w
->update_mode_line
= 1;
4615 w
->last_modified
= 0;
4616 w
->last_overlay_modified
= 0;
4617 /* Set force_start so that redisplay_window will run the
4618 window-scroll-functions. */
4622 /* The rest of this function uses current_y in a nonstandard way,
4623 not including the height of the header line if any. */
4624 it
.current_y
= it
.vpos
= 0;
4626 /* Move PT out of scroll margins.
4627 This code wants current_y to be zero at the window start position
4628 even if there is a header line. */
4629 this_scroll_margin
= max (0, scroll_margin
);
4631 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4632 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4636 /* We moved the window start towards ZV, so PT may be now
4637 in the scroll margin at the top. */
4638 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4639 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4640 && (NILP (Vscroll_preserve_screen_position
)
4641 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4642 /* We found PT at a legitimate height. Leave it alone. */
4644 else if (window_scroll_pixel_based_preserve_y
>= 0)
4646 /* If we have a header line, take account of it.
4647 This is necessary because we set it.current_y to 0, above. */
4648 move_it_to (&it
, -1,
4649 window_scroll_pixel_based_preserve_x
,
4650 window_scroll_pixel_based_preserve_y
4651 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4652 -1, MOVE_TO_Y
| MOVE_TO_X
);
4653 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4657 while (it
.current_y
< this_scroll_margin
)
4659 int prev
= it
.current_y
;
4660 move_it_by_lines (&it
, 1);
4661 if (prev
== it
.current_y
)
4664 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4669 ptrdiff_t charpos
, bytepos
;
4672 /* Save our position, for the
4673 window_scroll_pixel_based_preserve_y case. */
4674 charpos
= IT_CHARPOS (it
);
4675 bytepos
= IT_BYTEPOS (it
);
4677 /* We moved the window start towards BEGV, so PT may be now
4678 in the scroll margin at the bottom. */
4679 move_it_to (&it
, PT
, -1,
4680 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4681 - this_scroll_margin
- 1),
4683 MOVE_TO_POS
| MOVE_TO_Y
);
4685 /* Save our position, in case it's correct. */
4686 charpos
= IT_CHARPOS (it
);
4687 bytepos
= IT_BYTEPOS (it
);
4689 /* See if point is on a partially visible line at the end. */
4690 if (it
.what
== IT_EOB
)
4691 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4694 move_it_by_lines (&it
, 1);
4695 partial_p
= it
.current_y
> it
.last_visible_y
;
4698 if (charpos
== PT
&& !partial_p
4699 && (NILP (Vscroll_preserve_screen_position
)
4700 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4701 /* We found PT before we found the display margin, so PT is ok. */
4703 else if (window_scroll_pixel_based_preserve_y
>= 0)
4705 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4706 start_display (&it
, w
, start
);
4707 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4708 here because we called start_display again and did not
4709 alter it.current_y this time. */
4710 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4711 window_scroll_pixel_based_preserve_y
, -1,
4712 MOVE_TO_Y
| MOVE_TO_X
);
4713 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4718 /* The last line was only partially visible, so back up two
4719 lines to make sure we're on a fully visible line. */
4721 move_it_by_lines (&it
, -2);
4722 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4725 /* No, the position we saved is OK, so use it. */
4726 SET_PT_BOTH (charpos
, bytepos
);
4729 bidi_unshelve_cache (itdata
, 0);
4733 /* Implementation of window_scroll that works based on screen lines.
4734 See the comment of window_scroll for parameter descriptions. */
4737 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4739 register struct window
*w
= XWINDOW (window
);
4740 /* Fvertical_motion enters redisplay, which can trigger
4741 fontification, which in turn can modify buffer text (e.g., if the
4742 fontification functions replace escape sequences with faces, as
4743 in `grep-mode-font-lock-keywords'). So we use a marker to record
4744 the old point position, to prevent crashes in SET_PT_BOTH. */
4745 Lisp_Object opoint_marker
= Fpoint_marker ();
4746 register ptrdiff_t pos
, pos_byte
;
4747 register int ht
= window_internal_height (w
);
4748 register Lisp_Object tem
;
4752 Lisp_Object original_pos
= Qnil
;
4754 /* If scrolling screen-fulls, compute the number of lines to
4755 scroll from the window's height. */
4757 n
*= max (1, ht
- next_screen_context_lines
);
4759 startpos
= marker_position (w
->start
);
4761 if (!NILP (Vscroll_preserve_screen_position
))
4763 if (window_scroll_preserve_vpos
<= 0
4764 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4765 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4767 struct position posit
4768 = *compute_motion (startpos
, 0, 0, 0,
4772 window_scroll_preserve_vpos
= posit
.vpos
;
4773 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4776 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4777 make_number (window_scroll_preserve_vpos
));
4780 XSETFASTINT (tem
, PT
);
4781 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4785 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4790 lose
= n
< 0 && PT
== BEGV
;
4791 Fvertical_motion (make_number (n
), window
);
4795 SET_PT_BOTH (marker_position (opoint_marker
),
4796 marker_byte_position (opoint_marker
));
4803 xsignal0 (Qbeginning_of_buffer
);
4808 /* Don't use a scroll margin that is negative or too large. */
4809 int this_scroll_margin
=
4810 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4812 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4813 w
->start_at_line_beg
= !NILP (bolp
);
4814 w
->update_mode_line
= 1;
4815 w
->last_modified
= 0;
4816 w
->last_overlay_modified
= 0;
4817 /* Set force_start so that redisplay_window will run
4818 the window-scroll-functions. */
4821 if (!NILP (Vscroll_preserve_screen_position
)
4822 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4824 SET_PT_BOTH (pos
, pos_byte
);
4825 Fvertical_motion (original_pos
, window
);
4827 /* If we scrolled forward, put point enough lines down
4828 that it is outside the scroll margin. */
4833 if (this_scroll_margin
> 0)
4835 SET_PT_BOTH (pos
, pos_byte
);
4836 Fvertical_motion (make_number (this_scroll_margin
), window
);
4842 if (top_margin
<= marker_position (opoint_marker
))
4843 SET_PT_BOTH (marker_position (opoint_marker
),
4844 marker_byte_position (opoint_marker
));
4845 else if (!NILP (Vscroll_preserve_screen_position
))
4847 SET_PT_BOTH (pos
, pos_byte
);
4848 Fvertical_motion (original_pos
, window
);
4851 SET_PT (top_margin
);
4857 /* If we scrolled backward, put point near the end of the window
4858 but not within the scroll margin. */
4859 SET_PT_BOTH (pos
, pos_byte
);
4860 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4861 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4864 bottom_margin
= PT
+ 1;
4866 if (bottom_margin
> marker_position (opoint_marker
))
4867 SET_PT_BOTH (marker_position (opoint_marker
),
4868 marker_byte_position (opoint_marker
));
4871 if (!NILP (Vscroll_preserve_screen_position
))
4873 SET_PT_BOTH (pos
, pos_byte
);
4874 Fvertical_motion (original_pos
, window
);
4877 Fvertical_motion (make_number (-1), window
);
4886 xsignal0 (Qend_of_buffer
);
4891 /* Scroll selected_window up or down. If N is nil, scroll a
4892 screen-full which is defined as the height of the window minus
4893 next_screen_context_lines. If N is the symbol `-', scroll.
4894 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4895 up. This is the guts of Fscroll_up and Fscroll_down. */
4898 scroll_command (Lisp_Object n
, int direction
)
4900 ptrdiff_t count
= SPECPDL_INDEX ();
4902 eassert (eabs (direction
) == 1);
4904 /* If selected window's buffer isn't current, make it current for
4905 the moment. But don't screw up if window_scroll gets an error. */
4906 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4908 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4909 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4911 /* Make redisplay consider other windows than just selected_window. */
4912 ++windows_or_buffers_changed
;
4916 window_scroll (selected_window
, direction
, 1, 0);
4917 else if (EQ (n
, Qminus
))
4918 window_scroll (selected_window
, -direction
, 1, 0);
4921 n
= Fprefix_numeric_value (n
);
4922 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4925 unbind_to (count
, Qnil
);
4928 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4929 doc
: /* Scroll text of selected window upward ARG lines.
4930 If ARG is omitted or nil, scroll upward by a near full screen.
4931 A near full screen is `next-screen-context-lines' less than a full screen.
4932 Negative ARG means scroll downward.
4933 If ARG is the atom `-', scroll downward by nearly full screen.
4934 When calling from a program, supply as argument a number, nil, or `-'. */)
4937 scroll_command (arg
, 1);
4941 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4942 doc
: /* Scroll text of selected window down ARG lines.
4943 If ARG is omitted or nil, scroll down by a near full screen.
4944 A near full screen is `next-screen-context-lines' less than a full screen.
4945 Negative ARG means scroll upward.
4946 If ARG is the atom `-', scroll upward by nearly full screen.
4947 When calling from a program, supply as argument a number, nil, or `-'. */)
4950 scroll_command (arg
, -1);
4954 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4955 doc
: /* Return the other window for \"other window scroll\" commands.
4956 If `other-window-scroll-buffer' is non-nil, a window
4957 showing that buffer is used.
4958 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4959 specifies the window. This takes precedence over
4960 `other-window-scroll-buffer'. */)
4965 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4966 && !NILP (Vminibuf_scroll_window
))
4967 window
= Vminibuf_scroll_window
;
4968 /* If buffer is specified, scroll that buffer. */
4969 else if (!NILP (Vother_window_scroll_buffer
))
4971 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4973 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4977 /* Nothing specified; look for a neighboring window on the same
4979 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4981 if (EQ (window
, selected_window
))
4982 /* That didn't get us anywhere; look for a window on another
4985 window
= Fnext_window (window
, Qnil
, Qt
);
4986 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4987 && ! EQ (window
, selected_window
));
4990 CHECK_LIVE_WINDOW (window
);
4992 if (EQ (window
, selected_window
))
4993 error ("There is no other window");
4998 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4999 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5000 A near full screen is `next-screen-context-lines' less than a full screen.
5001 The next window is the one below the current one; or the one at the top
5002 if the current one is at the bottom. Negative ARG means scroll downward.
5003 If ARG is the atom `-', scroll downward by nearly full screen.
5004 When calling from a program, supply as argument a number, nil, or `-'.
5006 If `other-window-scroll-buffer' is non-nil, scroll the window
5007 showing that buffer, popping the buffer up if necessary.
5008 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5009 specifies the window to scroll. This takes precedence over
5010 `other-window-scroll-buffer'. */)
5015 ptrdiff_t count
= SPECPDL_INDEX ();
5017 window
= Fother_window_for_scrolling ();
5018 w
= XWINDOW (window
);
5020 /* Don't screw up if window_scroll gets an error. */
5021 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5022 ++windows_or_buffers_changed
;
5024 Fset_buffer (w
->buffer
);
5025 SET_PT (marker_position (w
->pointm
));
5028 window_scroll (window
, 1, 1, 1);
5029 else if (EQ (arg
, Qminus
))
5030 window_scroll (window
, -1, 1, 1);
5036 window_scroll (window
, XINT (arg
), 0, 1);
5039 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5040 unbind_to (count
, Qnil
);
5045 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5046 doc
: /* Scroll selected window display ARG columns left.
5047 Default for ARG is window width minus 2.
5048 Value is the total amount of leftward horizontal scrolling in
5049 effect after the change.
5050 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5051 lower bound for automatic scrolling, i.e. automatic scrolling
5052 will not scroll a window to a column less than the value returned
5053 by this function. This happens in an interactive call. */)
5054 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5056 struct window
*w
= XWINDOW (selected_window
);
5057 EMACS_INT requested_arg
= (NILP (arg
)
5058 ? window_body_cols (w
) - 2
5059 : XINT (Fprefix_numeric_value (arg
)));
5060 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5062 if (!NILP (set_minimum
))
5063 w
->min_hscroll
= w
->hscroll
;
5068 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5069 doc
: /* Scroll selected window display ARG columns right.
5070 Default for ARG is window width minus 2.
5071 Value is the total amount of leftward horizontal scrolling in
5072 effect after the change.
5073 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5074 lower bound for automatic scrolling, i.e. automatic scrolling
5075 will not scroll a window to a column less than the value returned
5076 by this function. This happens in an interactive call. */)
5077 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5079 struct window
*w
= XWINDOW (selected_window
);
5080 EMACS_INT requested_arg
= (NILP (arg
)
5081 ? window_body_cols (w
) - 2
5082 : XINT (Fprefix_numeric_value (arg
)));
5083 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5085 if (!NILP (set_minimum
))
5086 w
->min_hscroll
= w
->hscroll
;
5091 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5092 doc
: /* Return the window which was selected when entering the minibuffer.
5093 Returns nil, if selected window is not a minibuffer window. */)
5096 if (minibuf_level
> 0
5097 && MINI_WINDOW_P (XWINDOW (selected_window
))
5098 && WINDOW_LIVE_P (minibuf_selected_window
))
5099 return minibuf_selected_window
;
5104 /* Value is the number of lines actually displayed in window W,
5105 as opposed to its height. */
5108 displayed_window_lines (struct window
*w
)
5111 struct text_pos start
;
5112 ptrdiff_t charpos
= marker_position (w
->start
);
5113 int height
= window_box_height (w
);
5114 struct buffer
*old_buffer
;
5116 void *itdata
= NULL
;
5118 if (XBUFFER (w
->buffer
) != current_buffer
)
5120 old_buffer
= current_buffer
;
5121 set_buffer_internal (XBUFFER (w
->buffer
));
5126 /* In case W->start is out of the accessible range, do something
5127 reasonable. This happens in Info mode when Info-scroll-down
5128 calls (recenter -1) while W->start is 1. */
5130 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5131 else if (charpos
> ZV
)
5132 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5134 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5136 itdata
= bidi_shelve_cache ();
5137 start_display (&it
, w
, start
);
5138 move_it_vertically (&it
, height
);
5139 bottom_y
= line_bottom_y (&it
);
5140 bidi_unshelve_cache (itdata
, 0);
5142 /* rms: On a non-window display,
5143 the value of it.vpos at the bottom of the screen
5144 seems to be 1 larger than window_box_height (w).
5145 This kludge fixes a bug whereby (move-to-window-line -1)
5146 when ZV is on the last screen line
5147 moves to the previous screen line instead of the last one. */
5148 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5151 /* Add in empty lines at the bottom of the window. */
5152 if (bottom_y
< height
)
5154 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5155 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5159 set_buffer_internal (old_buffer
);
5165 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5166 doc
: /* Center point in selected window and maybe redisplay frame.
5167 With a numeric prefix argument ARG, recenter putting point on screen line ARG
5168 relative to the selected window. If ARG is negative, it counts up from the
5169 bottom of the window. (ARG should be less than the height of the window.)
5171 If ARG is omitted or nil, then recenter with point on the middle line of
5172 the selected window; if the variable `recenter-redisplay' is non-nil,
5173 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5174 is set to `grow-only', this resets the tool-bar's height to the minimum
5175 height needed); if `recenter-redisplay' has the special value `tty',
5176 then only tty frames are redrawn.
5178 Just C-u as prefix means put point in the center of the window
5179 and redisplay normally--don't erase and redraw the frame. */)
5180 (register Lisp_Object arg
)
5182 struct window
*w
= XWINDOW (selected_window
);
5183 struct buffer
*buf
= XBUFFER (w
->buffer
);
5184 struct buffer
*obuf
= current_buffer
;
5186 ptrdiff_t charpos
, bytepos
;
5187 EMACS_INT iarg
IF_LINT (= 0);
5188 int this_scroll_margin
;
5190 /* If redisplay is suppressed due to an error, try again. */
5191 obuf
->display_error_modiff
= 0;
5195 if (!NILP (Vrecenter_redisplay
)
5196 && (!EQ (Vrecenter_redisplay
, Qtty
)
5197 || !NILP (Ftty_type (selected_frame
))))
5201 /* Invalidate pixel data calculated for all compositions. */
5202 for (i
= 0; i
< n_compositions
; i
++)
5203 composition_table
[i
]->font
= NULL
;
5205 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5207 Fredraw_frame (WINDOW_FRAME (w
));
5208 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5213 else if (CONSP (arg
)) /* Just C-u. */
5217 arg
= Fprefix_numeric_value (arg
);
5222 set_buffer_internal (buf
);
5224 /* Do this after making BUF current
5225 in case scroll_margin is buffer-local. */
5226 this_scroll_margin
=
5227 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5229 /* Handle centering on a graphical frame specially. Such frames can
5230 have variable-height lines and centering point on the basis of
5231 line counts would lead to strange effects. */
5232 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5238 void *itdata
= bidi_shelve_cache ();
5240 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5241 start_display (&it
, w
, pt
);
5242 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5243 charpos
= IT_CHARPOS (it
);
5244 bytepos
= IT_BYTEPOS (it
);
5245 bidi_unshelve_cache (itdata
, 0);
5251 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5252 int extra_line_spacing
;
5253 int h
= window_box_height (w
);
5254 void *itdata
= bidi_shelve_cache ();
5256 iarg
= - max (-iarg
, this_scroll_margin
);
5258 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5259 start_display (&it
, w
, pt
);
5261 /* Be sure we have the exact height of the full line containing PT. */
5262 move_it_by_lines (&it
, 0);
5264 /* The amount of pixels we have to move back is the window
5265 height minus what's displayed in the line containing PT,
5266 and the lines below. */
5269 move_it_by_lines (&it
, nlines
);
5271 if (it
.vpos
== nlines
)
5275 /* Last line has no newline */
5276 h
-= line_bottom_y (&it
);
5280 /* Don't reserve space for extra line spacing of last line. */
5281 extra_line_spacing
= it
.max_extra_line_spacing
;
5283 /* If we can't move down NLINES lines because we hit
5284 the end of the buffer, count in some empty lines. */
5285 if (it
.vpos
< nlines
)
5288 extra_line_spacing
= it
.extra_line_spacing
;
5289 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5293 bidi_unshelve_cache (itdata
, 0);
5297 /* Now find the new top line (starting position) of the window. */
5298 start_display (&it
, w
, pt
);
5300 move_it_vertically_backward (&it
, h
);
5302 /* If extra line spacing is present, we may move too far
5303 back. This causes the last line to be only partially
5304 visible (which triggers redisplay to recenter that line
5305 in the middle), so move forward.
5306 But ignore extra line spacing on last line, as it is not
5307 considered to be part of the visible height of the line.
5309 h
+= extra_line_spacing
;
5310 while (-it
.current_y
> h
)
5311 move_it_by_lines (&it
, 1);
5313 charpos
= IT_CHARPOS (it
);
5314 bytepos
= IT_BYTEPOS (it
);
5316 bidi_unshelve_cache (itdata
, 0);
5320 struct position pos
;
5322 iarg
= max (iarg
, this_scroll_margin
);
5324 pos
= *vmotion (PT
, -iarg
, w
);
5325 charpos
= pos
.bufpos
;
5326 bytepos
= pos
.bytepos
;
5331 struct position pos
;
5332 int ht
= window_internal_height (w
);
5339 /* Don't let it get into the margin at either top or bottom. */
5340 iarg
= clip_to_bounds (this_scroll_margin
, iarg
,
5341 ht
- this_scroll_margin
- 1);
5343 pos
= *vmotion (PT
, - iarg
, w
);
5344 charpos
= pos
.bufpos
;
5345 bytepos
= pos
.bytepos
;
5348 /* Set the new window start. */
5349 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5350 w
->window_end_valid
= 0;
5352 w
->optional_new_start
= 1;
5354 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5355 FETCH_BYTE (bytepos
- 1) == '\n');
5357 set_buffer_internal (obuf
);
5361 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5363 doc
: /* Return the height in lines of the text display area of WINDOW.
5364 WINDOW must be a live window and defaults to the selected one.
5366 The returned height does not include the mode line, any header line,
5367 nor any partial-height lines at the bottom of the text area. */)
5368 (Lisp_Object window
)
5370 struct window
*w
= decode_live_window (window
);
5371 int pixel_height
= window_box_height (w
);
5372 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5373 return make_number (line_height
);
5378 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5380 doc
: /* Position point relative to window.
5381 ARG nil means position point at center of window.
5382 Else, ARG specifies vertical position within the window;
5383 zero means top of window, negative means relative to bottom of window. */)
5386 struct window
*w
= XWINDOW (selected_window
);
5390 int this_scroll_margin
;
5393 if (!(BUFFERP (w
->buffer
)
5394 && XBUFFER (w
->buffer
) == current_buffer
))
5395 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5396 when passed below to set_marker_both. */
5397 error ("move-to-window-line called from unrelated buffer");
5399 window
= selected_window
;
5400 start
= marker_position (w
->start
);
5401 if (start
< BEGV
|| start
> ZV
)
5403 int height
= window_internal_height (w
);
5404 Fvertical_motion (make_number (- (height
/ 2)), window
);
5405 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5406 w
->start_at_line_beg
= !NILP (Fbolp ());
5410 Fgoto_char (w
->start
);
5412 lines
= displayed_window_lines (w
);
5415 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5419 XSETFASTINT (arg
, lines
/ 2);
5422 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5425 iarg
= iarg
+ lines
;
5427 #if 0 /* This code would prevent move-to-window-line from moving point
5428 to a place inside the scroll margins (which would cause the
5429 next redisplay to scroll). I wrote this code, but then concluded
5430 it is probably better not to install it. However, it is here
5431 inside #if 0 so as not to lose it. -- rms. */
5433 /* Don't let it get into the margin at either top or bottom. */
5434 iarg
= max (iarg
, this_scroll_margin
);
5435 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5438 arg
= make_number (iarg
);
5441 /* Skip past a partially visible first line. */
5443 XSETINT (arg
, XINT (arg
) + 1);
5445 return Fvertical_motion (arg
, window
);
5450 /***********************************************************************
5451 Window Configuration
5452 ***********************************************************************/
5454 struct save_window_data
5456 struct vectorlike_header header
;
5457 Lisp_Object selected_frame
;
5458 Lisp_Object current_window
;
5459 Lisp_Object current_buffer
;
5460 Lisp_Object minibuf_scroll_window
;
5461 Lisp_Object minibuf_selected_window
;
5462 Lisp_Object root_window
;
5463 Lisp_Object focus_frame
;
5464 /* A vector, each of whose elements is a struct saved_window
5466 Lisp_Object saved_windows
;
5468 /* All fields above are traced by the GC.
5469 From `fame-cols' down, the fields are ignored by the GC. */
5471 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5472 int frame_tool_bar_lines
;
5475 /* This is saved as a Lisp_Vector */
5478 struct vectorlike_header header
;
5480 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5481 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5482 Lisp_Object normal_cols
, normal_lines
;
5483 Lisp_Object hscroll
, min_hscroll
;
5484 Lisp_Object parent
, prev
;
5485 Lisp_Object start_at_line_beg
;
5486 Lisp_Object display_table
;
5487 Lisp_Object left_margin_cols
, right_margin_cols
;
5488 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5489 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5490 Lisp_Object combination_limit
, window_parameters
;
5493 #define SAVED_WINDOW_N(swv,n) \
5494 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5496 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5497 doc
: /* Return t if OBJECT is a window-configuration object. */)
5498 (Lisp_Object object
)
5500 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5503 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5504 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5505 (Lisp_Object config
)
5507 register struct save_window_data
*data
;
5508 struct Lisp_Vector
*saved_windows
;
5510 CHECK_WINDOW_CONFIGURATION (config
);
5512 data
= (struct save_window_data
*) XVECTOR (config
);
5513 saved_windows
= XVECTOR (data
->saved_windows
);
5514 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5517 DEFUN ("set-window-configuration", Fset_window_configuration
,
5518 Sset_window_configuration
, 1, 1, 0,
5519 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5520 CONFIGURATION must be a value previously returned
5521 by `current-window-configuration' (which see).
5522 If CONFIGURATION was made from a frame that is now deleted,
5523 only frame-independent values can be restored. In this case,
5524 the return value is nil. Otherwise the value is t. */)
5525 (Lisp_Object configuration
)
5527 register struct save_window_data
*data
;
5528 struct Lisp_Vector
*saved_windows
;
5529 Lisp_Object new_current_buffer
;
5532 ptrdiff_t old_point
= -1;
5534 CHECK_WINDOW_CONFIGURATION (configuration
);
5536 data
= (struct save_window_data
*) XVECTOR (configuration
);
5537 saved_windows
= XVECTOR (data
->saved_windows
);
5539 new_current_buffer
= data
->current_buffer
;
5540 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5541 new_current_buffer
= Qnil
;
5544 if (XBUFFER (new_current_buffer
) == current_buffer
)
5545 /* The code further down "preserves point" by saving here PT in
5546 old_point and then setting it later back into PT. When the
5547 current-selected-window and the final-selected-window both show
5548 the current buffer, this suffers from the problem that the
5549 current PT is the window-point of the current-selected-window,
5550 while the final PT is the point of the final-selected-window, so
5551 this copy from one PT to the other would end up moving the
5552 window-point of the final-selected-window to the window-point of
5553 the current-selected-window. So we have to be careful which
5554 point of the current-buffer we copy into old_point. */
5555 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5556 && WINDOWP (selected_window
)
5557 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5558 && !EQ (selected_window
, data
->current_window
))
5559 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5563 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5564 point in new_current_buffer as of the last time this buffer was
5565 used. This can be non-deterministic since it can be changed by
5566 things like jit-lock by mere temporary selection of some random
5567 window that happens to show this buffer.
5568 So if possible we want this arbitrary choice of "which point" to
5569 be the one from the to-be-selected-window so as to prevent this
5570 window's cursor from being copied from another window. */
5571 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5572 /* If current_window = selected_window, its point is in BUF_PT. */
5573 && !EQ (selected_window
, data
->current_window
))
5574 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5576 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5579 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5582 /* If f is a dead frame, don't bother rebuilding its window tree.
5583 However, there is other stuff we should still try to do below. */
5584 if (FRAME_LIVE_P (f
))
5587 Lisp_Object dead_windows
= Qnil
;
5588 register Lisp_Object tem
, par
, pers
;
5589 register struct window
*w
;
5590 register struct saved_window
*p
;
5591 struct window
*root_window
;
5592 struct window
**leaf_windows
;
5597 /* If the frame has been resized since this window configuration was
5598 made, we change the frame to the size specified in the
5599 configuration, restore the configuration, and then resize it
5600 back. We keep track of the prevailing height in these variables. */
5601 int previous_frame_lines
= FRAME_LINES (f
);
5602 int previous_frame_cols
= FRAME_COLS (f
);
5603 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5604 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5606 /* Don't do this within the main loop below: This may call Lisp
5607 code and is thus potentially unsafe while input is blocked. */
5608 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5610 p
= SAVED_WINDOW_N (saved_windows
, k
);
5612 w
= XWINDOW (window
);
5613 if (!NILP (w
->buffer
)
5614 && !EQ (w
->buffer
, p
->buffer
)
5615 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5616 /* If a window we restore gets another buffer, record the
5617 window's old buffer. */
5618 call1 (Qrecord_window_buffer
, window
);
5621 /* The mouse highlighting code could get screwed up
5622 if it runs during this. */
5625 if (data
->frame_lines
!= previous_frame_lines
5626 || data
->frame_cols
!= previous_frame_cols
)
5627 change_frame_size (f
, data
->frame_lines
,
5628 data
->frame_cols
, 0, 0, 0);
5629 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5630 if (data
->frame_menu_bar_lines
5631 != previous_frame_menu_bar_lines
)
5632 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5634 #ifdef HAVE_WINDOW_SYSTEM
5635 if (data
->frame_tool_bar_lines
5636 != previous_frame_tool_bar_lines
)
5637 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5642 /* "Swap out" point from the selected window's buffer
5643 into the window itself. (Normally the pointm of the selected
5644 window holds garbage.) We do this now, before
5645 restoring the window contents, and prevent it from
5646 being done later on when we select a new window. */
5647 if (! NILP (XWINDOW (selected_window
)->buffer
))
5649 w
= XWINDOW (selected_window
);
5650 set_marker_both (w
->pointm
,
5652 BUF_PT (XBUFFER (w
->buffer
)),
5653 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5656 windows_or_buffers_changed
++;
5657 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5659 /* Problem: Freeing all matrices and later allocating them again
5660 is a serious redisplay flickering problem. What we would
5661 really like to do is to free only those matrices not reused
5663 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5664 leaf_windows
= alloca (count_windows (root_window
)
5665 * sizeof *leaf_windows
);
5666 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5669 Mark all windows now on frame as "deleted".
5670 Restoring the new configuration "undeletes" any that are in it.
5672 Save their current buffers in their height fields, since we may
5673 need it later, if a buffer saved in the configuration is now
5675 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5677 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5679 p
= SAVED_WINDOW_N (saved_windows
, k
);
5681 w
= XWINDOW (window
);
5682 wset_next (w
, Qnil
);
5684 if (!NILP (p
->parent
))
5686 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5688 wset_parent (w
, Qnil
);
5690 if (!NILP (p
->prev
))
5693 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5694 wset_next (XWINDOW (w
->prev
), p
->window
);
5698 wset_prev (w
, Qnil
);
5699 if (!NILP (w
->parent
))
5701 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5703 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5704 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5708 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5709 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5714 /* If we squirreled away the buffer in the window's height,
5716 if (BUFFERP (w
->total_lines
))
5717 wset_buffer (w
, w
->total_lines
);
5718 wset_left_col (w
, p
->left_col
);
5719 wset_top_line (w
, p
->top_line
);
5720 wset_total_cols (w
, p
->total_cols
);
5721 wset_total_lines (w
, p
->total_lines
);
5722 wset_normal_cols (w
, p
->normal_cols
);
5723 wset_normal_lines (w
, p
->normal_lines
);
5724 w
->hscroll
= XFASTINT (p
->hscroll
);
5725 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5726 wset_display_table (w
, p
->display_table
);
5727 wset_left_margin_cols (w
, p
->left_margin_cols
);
5728 wset_right_margin_cols (w
, p
->right_margin_cols
);
5729 wset_left_fringe_width (w
, p
->left_fringe_width
);
5730 wset_right_fringe_width (w
, p
->right_fringe_width
);
5731 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5732 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5733 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5734 wset_dedicated (w
, p
->dedicated
);
5735 wset_combination_limit (w
, p
->combination_limit
);
5736 /* Restore any window parameters that have been saved.
5737 Parameters that have not been saved are left alone. */
5738 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5743 if (NILP (XCDR (pers
)))
5745 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5746 if (CONSP (par
) && !NILP (XCDR (par
)))
5747 /* Reset a parameter to nil if and only if it
5748 has a non-nil association. Don't make new
5750 Fsetcdr (par
, Qnil
);
5753 /* Always restore a non-nil value. */
5754 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5758 w
->last_modified
= 0;
5759 w
->last_overlay_modified
= 0;
5761 /* Reinstall the saved buffer and pointers into it. */
5762 if (NILP (p
->buffer
))
5763 /* An internal window. */
5764 wset_buffer (w
, p
->buffer
);
5765 else if (BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5766 /* If saved buffer is alive, install it. */
5768 wset_buffer (w
, p
->buffer
);
5769 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5770 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5771 set_marker_restricted (w
->pointm
, p
->pointm
,
5773 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5774 p
->mark
, w
->buffer
);
5776 /* As documented in Fcurrent_window_configuration, don't
5777 restore the location of point in the buffer which was
5778 current when the window configuration was recorded. */
5779 if (!EQ (p
->buffer
, new_current_buffer
)
5780 && XBUFFER (p
->buffer
) == current_buffer
)
5781 Fgoto_char (w
->pointm
);
5783 else if (!NILP (w
->buffer
)
5784 && BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
5785 /* Keep window's old buffer; make sure the markers are
5788 /* Set window markers at start of visible range. */
5789 if (XMARKER (w
->start
)->buffer
== 0)
5790 set_marker_restricted_both (w
->start
, w
->buffer
, 0, 0);
5791 if (XMARKER (w
->pointm
)->buffer
== 0)
5792 set_marker_restricted_both
5793 (w
->pointm
, w
->buffer
,
5794 BUF_PT (XBUFFER (w
->buffer
)),
5795 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5796 w
->start_at_line_beg
= 1;
5799 /* Window has no live buffer, get one. */
5801 /* Get the buffer via other_buffer_safely in order to
5802 avoid showing an unimportant buffer and, if necessary, to
5803 recreate *scratch* in the course (part of Juanma's bs-show
5804 scenario from March 2011). */
5805 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5806 /* This will set the markers to beginning of visible
5808 set_marker_restricted_both (w
->start
, w
->buffer
, 0, 0);
5809 set_marker_restricted_both (w
->pointm
, w
->buffer
, 0, 0);
5810 w
->start_at_line_beg
= 1;
5811 if (!NILP (w
->dedicated
))
5812 /* Record this window as dead. */
5813 dead_windows
= Fcons (window
, dead_windows
);
5814 /* Make sure window is no more dedicated. */
5815 wset_dedicated (w
, Qnil
);
5819 fset_root_window (f
, data
->root_window
);
5820 /* Arrange *not* to restore point in the buffer that was
5821 current when the window configuration was saved. */
5822 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5823 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5824 make_number (old_point
),
5825 XWINDOW (data
->current_window
)->buffer
);
5827 /* In the following call to `select-window', prevent "swapping out
5828 point" in the old selected window using the buffer that has
5829 been restored into it. We already swapped out that point from
5830 that window's old buffer. */
5831 select_window (data
->current_window
, Qnil
, 1);
5832 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5835 if (NILP (data
->focus_frame
)
5836 || (FRAMEP (data
->focus_frame
)
5837 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5838 Fredirect_frame_focus (frame
, data
->focus_frame
);
5840 /* Set the screen height to the value it had before this function. */
5841 if (previous_frame_lines
!= FRAME_LINES (f
)
5842 || previous_frame_cols
!= FRAME_COLS (f
))
5843 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5845 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5846 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5847 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5849 #ifdef HAVE_WINDOW_SYSTEM
5850 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5851 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5856 /* Now, free glyph matrices in windows that were not reused. */
5857 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5859 if (NILP (leaf_windows
[i
]->buffer
))
5861 /* Assert it's not reused as a combination. */
5862 eassert (NILP (leaf_windows
[i
]->hchild
)
5863 && NILP (leaf_windows
[i
]->vchild
));
5864 free_window_matrices (leaf_windows
[i
]);
5866 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5873 /* Scan dead buffer windows. */
5874 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5876 window
= XCAR (dead_windows
);
5877 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5878 delete_deletable_window (window
);
5881 /* Fselect_window will have made f the selected frame, so we
5882 reselect the proper frame here. Fhandle_switch_frame will change the
5883 selected window too, but that doesn't make the call to
5884 Fselect_window above totally superfluous; it still sets f's
5886 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5887 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5889 run_window_configuration_change_hook (f
);
5892 if (!NILP (new_current_buffer
))
5894 Fset_buffer (new_current_buffer
);
5895 /* If the new current buffer doesn't appear in the selected
5896 window, go to its old point (see bug#12208). */
5897 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5898 Fgoto_char (make_number (old_point
));
5901 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5902 minibuf_selected_window
= data
->minibuf_selected_window
;
5904 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5908 /* Recursively delete all child windows reachable via the next, vchild,
5909 and hchild slots of WINDOW. */
5911 delete_all_child_windows (Lisp_Object window
)
5913 register struct window
*w
;
5915 w
= XWINDOW (window
);
5917 if (!NILP (w
->next
))
5918 /* Delete WINDOW's siblings (we traverse postorderly). */
5919 delete_all_child_windows (w
->next
);
5921 /* See Fset_window_configuration for excuse. */
5922 wset_total_lines (w
, w
->buffer
);
5924 if (!NILP (w
->vchild
))
5926 delete_all_child_windows (w
->vchild
);
5927 wset_vchild (w
, Qnil
);
5929 else if (!NILP (w
->hchild
))
5931 delete_all_child_windows (w
->hchild
);
5932 wset_hchild (w
, Qnil
);
5934 else if (!NILP (w
->buffer
))
5937 unchain_marker (XMARKER (w
->pointm
));
5938 unchain_marker (XMARKER (w
->start
));
5939 wset_buffer (w
, Qnil
);
5942 Vwindow_list
= Qnil
;
5946 count_windows (register struct window
*window
)
5948 register int count
= 1;
5949 if (!NILP (window
->next
))
5950 count
+= count_windows (XWINDOW (window
->next
));
5951 if (!NILP (window
->vchild
))
5952 count
+= count_windows (XWINDOW (window
->vchild
));
5953 if (!NILP (window
->hchild
))
5954 count
+= count_windows (XWINDOW (window
->hchild
));
5959 /* Fill vector FLAT with leaf windows under W, starting at index I.
5960 Value is last index + 1. */
5962 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5966 if (!NILP (w
->hchild
))
5967 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5968 else if (!NILP (w
->vchild
))
5969 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5973 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5980 /* Return a pointer to the glyph W's physical cursor is on. Value is
5981 null if W's current matrix is invalid, so that no meaningful glyph
5984 get_phys_cursor_glyph (struct window
*w
)
5986 struct glyph_row
*row
;
5987 struct glyph
*glyph
;
5988 int hpos
= w
->phys_cursor
.hpos
;
5990 if (!(w
->phys_cursor
.vpos
>= 0
5991 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5994 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5995 if (!row
->enabled_p
)
6000 /* When the window is hscrolled, cursor hpos can legitimately be
6001 out of bounds, but we draw the cursor at the corresponding
6002 window margin in that case. */
6003 if (!row
->reversed_p
&& hpos
< 0)
6005 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
6006 hpos
= row
->used
[TEXT_AREA
] - 1;
6009 if (row
->used
[TEXT_AREA
] > hpos
6011 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
6020 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6022 register struct saved_window
*p
;
6023 register struct window
*w
;
6024 register Lisp_Object tem
, pers
, par
;
6026 for (;!NILP (window
); window
= w
->next
)
6028 p
= SAVED_WINDOW_N (vector
, i
);
6029 w
= XWINDOW (window
);
6031 wset_temslot (w
, make_number (i
)); i
++;
6033 p
->buffer
= w
->buffer
;
6034 p
->left_col
= w
->left_col
;
6035 p
->top_line
= w
->top_line
;
6036 p
->total_cols
= w
->total_cols
;
6037 p
->total_lines
= w
->total_lines
;
6038 p
->normal_cols
= w
->normal_cols
;
6039 p
->normal_lines
= w
->normal_lines
;
6040 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6041 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6042 p
->display_table
= w
->display_table
;
6043 p
->left_margin_cols
= w
->left_margin_cols
;
6044 p
->right_margin_cols
= w
->right_margin_cols
;
6045 p
->left_fringe_width
= w
->left_fringe_width
;
6046 p
->right_fringe_width
= w
->right_fringe_width
;
6047 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6048 p
->scroll_bar_width
= w
->scroll_bar_width
;
6049 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6050 p
->dedicated
= w
->dedicated
;
6051 p
->combination_limit
= w
->combination_limit
;
6052 p
->window_parameters
= Qnil
;
6054 if (!NILP (Vwindow_persistent_parameters
))
6056 /* Run cycle detection on Vwindow_persistent_parameters. */
6057 Lisp_Object tortoise
, hare
;
6059 hare
= tortoise
= Vwindow_persistent_parameters
;
6060 while (CONSP (hare
))
6067 tortoise
= XCDR (tortoise
);
6069 if (EQ (hare
, tortoise
))
6070 /* Reset Vwindow_persistent_parameters to Qnil. */
6072 Vwindow_persistent_parameters
= Qnil
;
6077 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6081 /* Save values for persistent window parameters. */
6082 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6084 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6086 /* If the window has no value for the parameter,
6088 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6089 p
->window_parameters
);
6091 /* If the window has a value for the parameter,
6093 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6095 p
->window_parameters
);
6100 if (!NILP (w
->buffer
))
6102 /* Save w's value of point in the window configuration. If w
6103 is the selected window, then get the value of point from
6104 the buffer; pointm is garbage in the selected window. */
6105 if (EQ (window
, selected_window
))
6106 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6107 BUF_PT (XBUFFER (w
->buffer
)),
6108 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6110 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6111 XMARKER (p
->pointm
)->insertion_type
6112 = !NILP (Vwindow_point_insertion_type
);
6114 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6115 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6117 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6118 p
->mark
= Fcopy_marker (tem
, Qnil
);
6125 p
->start_at_line_beg
= Qnil
;
6128 if (NILP (w
->parent
))
6131 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6136 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6138 if (!NILP (w
->vchild
))
6139 i
= save_window_save (w
->vchild
, vector
, i
);
6140 if (!NILP (w
->hchild
))
6141 i
= save_window_save (w
->hchild
, vector
, i
);
6147 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6148 Scurrent_window_configuration
, 0, 1, 0,
6149 doc
: /* Return an object representing the current window configuration of FRAME.
6150 If FRAME is nil or omitted, use the selected frame.
6151 This describes the number of windows, their sizes and current buffers,
6152 and for each displayed buffer, where display starts, and the positions of
6153 point and mark. An exception is made for point in the current buffer:
6154 its value is -not- saved.
6155 This also records the currently selected frame, and FRAME's focus
6156 redirection (see `redirect-frame-focus'). The variable
6157 `window-persistent-parameters' specifies which window parameters are
6158 saved by this function. */)
6161 register Lisp_Object tem
;
6162 register int n_windows
;
6163 register struct save_window_data
*data
;
6165 struct frame
*f
= decode_live_frame (frame
);
6167 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6168 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6169 PVEC_WINDOW_CONFIGURATION
);
6171 data
->frame_cols
= FRAME_COLS (f
);
6172 data
->frame_lines
= FRAME_LINES (f
);
6173 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6174 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6175 data
->selected_frame
= selected_frame
;
6176 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6177 XSETBUFFER (data
->current_buffer
, current_buffer
);
6178 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6179 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6180 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6181 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6182 tem
= make_uninit_vector (n_windows
);
6183 data
->saved_windows
= tem
;
6184 for (i
= 0; i
< n_windows
; i
++)
6186 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6187 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6188 XSETWINDOW_CONFIGURATION (tem
, data
);
6192 /***********************************************************************
6194 ***********************************************************************/
6196 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6198 doc
: /* Set width of marginal areas of window WINDOW.
6199 WINDOW must be a live window and defaults to the selected one.
6201 Second arg LEFT-WIDTH specifies the number of character cells to
6202 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6203 does the same for the right marginal area. A nil width parameter
6204 means no margin. */)
6205 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6207 struct window
*w
= decode_live_window (window
);
6209 /* Translate negative or zero widths to nil.
6210 Margins that are too wide have to be checked elsewhere. */
6212 if (!NILP (left_width
))
6214 CHECK_NUMBER (left_width
);
6215 if (XINT (left_width
) <= 0)
6219 if (!NILP (right_width
))
6221 CHECK_NUMBER (right_width
);
6222 if (XINT (right_width
) <= 0)
6226 if (!EQ (w
->left_margin_cols
, left_width
)
6227 || !EQ (w
->right_margin_cols
, right_width
))
6229 wset_left_margin_cols (w
, left_width
);
6230 wset_right_margin_cols (w
, right_width
);
6232 adjust_window_margins (w
);
6234 ++windows_or_buffers_changed
;
6235 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6242 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6244 doc
: /* Get width of marginal areas of window WINDOW.
6245 WINDOW must be a live window and defaults to the selected one.
6247 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6248 If a marginal area does not exist, its width will be returned
6250 (Lisp_Object window
)
6252 struct window
*w
= decode_live_window (window
);
6253 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6258 /***********************************************************************
6260 ***********************************************************************/
6262 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6264 doc
: /* Set the fringe widths of window WINDOW.
6265 WINDOW must be a live window and defaults to the selected one.
6267 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6268 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6269 fringe width. If a fringe width arg is nil, that means to use the
6270 frame's default fringe width. Default fringe widths can be set with
6271 the command `set-fringe-style'.
6272 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6273 outside of the display margins. By default, fringes are drawn between
6274 display marginal areas and the text area. */)
6275 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6277 struct window
*w
= decode_live_window (window
);
6278 int outside
= !NILP (outside_margins
);
6280 if (!NILP (left_width
))
6281 CHECK_NATNUM (left_width
);
6282 if (!NILP (right_width
))
6283 CHECK_NATNUM (right_width
);
6285 /* Do nothing on a tty. */
6286 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6287 && (!EQ (w
->left_fringe_width
, left_width
)
6288 || !EQ (w
->right_fringe_width
, right_width
)
6289 || w
->fringes_outside_margins
!= outside
))
6291 wset_left_fringe_width (w
, left_width
);
6292 wset_right_fringe_width (w
, right_width
);
6293 w
->fringes_outside_margins
= outside
;
6295 adjust_window_margins (w
);
6297 clear_glyph_matrix (w
->current_matrix
);
6298 w
->window_end_valid
= 0;
6300 ++windows_or_buffers_changed
;
6301 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6308 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6310 doc
: /* Get width of fringes of window WINDOW.
6311 WINDOW must be a live window and defaults to the selected one.
6313 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6314 (Lisp_Object window
)
6316 struct window
*w
= decode_live_window (window
);
6318 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6319 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6320 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6325 /***********************************************************************
6327 ***********************************************************************/
6329 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6330 Sset_window_scroll_bars
, 2, 4, 0,
6331 doc
: /* Set width and type of scroll bars of window WINDOW.
6332 WINDOW must be a live window and defaults to the selected one.
6334 Second parameter WIDTH specifies the pixel width for the scroll bar;
6335 this is automatically adjusted to a multiple of the frame column width.
6336 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6337 bar: left, right, or nil.
6338 If WIDTH is nil, use the frame's scroll-bar width.
6339 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6340 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6341 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6343 struct window
*w
= decode_live_window (window
);
6347 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6349 if (XINT (width
) == 0)
6350 vertical_type
= Qnil
;
6353 if (!(NILP (vertical_type
)
6354 || EQ (vertical_type
, Qleft
)
6355 || EQ (vertical_type
, Qright
)
6356 || EQ (vertical_type
, Qt
)))
6357 error ("Invalid type of vertical scroll bar");
6359 if (!EQ (w
->scroll_bar_width
, width
)
6360 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6362 wset_scroll_bar_width (w
, width
);
6363 wset_vertical_scroll_bar_type (w
, vertical_type
);
6365 adjust_window_margins (w
);
6367 clear_glyph_matrix (w
->current_matrix
);
6368 w
->window_end_valid
= 0;
6370 ++windows_or_buffers_changed
;
6371 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6378 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6380 doc
: /* Get width and type of scroll bars of window WINDOW.
6381 WINDOW must be a live window and defaults to the selected one.
6383 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6384 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6386 (Lisp_Object window
)
6388 struct window
*w
= decode_live_window (window
);
6390 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6391 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6392 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6393 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6394 w
->vertical_scroll_bar_type
, Qnil
);
6399 /***********************************************************************
6401 ***********************************************************************/
6403 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6404 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6405 If WINDOW is omitted or nil, it defaults to the selected window.
6406 Normally, value is a multiple of the canonical character height of WINDOW;
6407 optional second arg PIXELS-P means value is measured in pixels. */)
6408 (Lisp_Object window
, Lisp_Object pixels_p
)
6411 struct window
*w
= decode_live_window (window
);
6412 struct frame
*f
= XFRAME (w
->frame
);
6414 if (FRAME_WINDOW_P (f
))
6415 result
= (NILP (pixels_p
)
6416 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6417 : make_number (-w
->vscroll
));
6419 result
= make_number (0);
6424 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6426 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6427 WINDOW nil means use the selected window. Normally, VSCROLL is a
6428 non-negative multiple of the canonical character height of WINDOW;
6429 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6430 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6431 corresponds to an integral number of pixels. The return value is the
6432 result of this rounding.
6433 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6434 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6436 struct window
*w
= decode_live_window (window
);
6437 struct frame
*f
= XFRAME (w
->frame
);
6439 CHECK_NUMBER_OR_FLOAT (vscroll
);
6441 if (FRAME_WINDOW_P (f
))
6443 int old_dy
= w
->vscroll
;
6445 w
->vscroll
= - (NILP (pixels_p
)
6446 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6447 : XFLOATINT (vscroll
));
6448 w
->vscroll
= min (w
->vscroll
, 0);
6450 if (w
->vscroll
!= old_dy
)
6452 /* Adjust glyph matrix of the frame if the virtual display
6453 area becomes larger than before. */
6454 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6457 /* Prevent redisplay shortcuts. */
6458 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6462 return Fwindow_vscroll (window
, pixels_p
);
6466 /* Call FN for all leaf windows on frame F. FN is called with the
6467 first argument being a pointer to the leaf window, and with
6468 additional argument USER_DATA. Stops when FN returns 0. */
6471 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6474 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6475 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6476 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6480 /* Helper function for foreach_window. Call FN for all leaf windows
6481 reachable from W. FN is called with the first argument being a
6482 pointer to the leaf window, and with additional argument USER_DATA.
6483 Stop when FN returns 0. Value is 0 if stopped by FN. */
6486 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6490 for (cont
= 1; w
&& cont
;)
6492 if (!NILP (w
->hchild
))
6493 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6494 else if (!NILP (w
->vchild
))
6495 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6497 cont
= fn (w
, user_data
);
6499 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6506 /* Freeze or unfreeze the window start of W unless it is a
6507 mini-window or the selected window. FREEZE_P non-null means freeze
6508 the window start. */
6511 freeze_window_start (struct window
*w
, void *freeze_p
)
6513 if (MINI_WINDOW_P (w
)
6514 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6515 && (w
== XWINDOW (selected_window
)
6516 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6517 && ! NILP (Vminibuf_scroll_window
)
6518 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6521 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6526 /* Freeze or unfreeze the window starts of all leaf windows on frame
6527 F, except the selected window and a mini-window. FREEZE_P non-zero
6528 means freeze the window start. */
6531 freeze_window_starts (struct frame
*f
, int freeze_p
)
6533 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6537 /***********************************************************************
6539 ***********************************************************************/
6541 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6542 describe the same state of affairs. This is used by Fequal.
6544 IGNORE_POSITIONS means ignore non-matching scroll positions
6547 This ignores a couple of things like the dedication status of
6548 window, combination_limit and the like. This might have to be
6552 compare_window_configurations (Lisp_Object configuration1
,
6553 Lisp_Object configuration2
,
6554 bool ignore_positions
)
6556 register struct save_window_data
*d1
, *d2
;
6557 struct Lisp_Vector
*sws1
, *sws2
;
6560 CHECK_WINDOW_CONFIGURATION (configuration1
);
6561 CHECK_WINDOW_CONFIGURATION (configuration2
);
6563 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6564 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6565 sws1
= XVECTOR (d1
->saved_windows
);
6566 sws2
= XVECTOR (d2
->saved_windows
);
6568 /* Frame settings must match. */
6569 if (d1
->frame_cols
!= d2
->frame_cols
6570 || d1
->frame_lines
!= d2
->frame_lines
6571 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6572 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6573 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6574 || (!ignore_positions
6575 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6576 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6577 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6578 /* Verify that the two configurations have the same number of windows. */
6579 || sws1
->header
.size
!= sws2
->header
.size
)
6582 for (i
= 0; i
< sws1
->header
.size
; i
++)
6584 struct saved_window
*sw1
, *sw2
;
6586 sw1
= SAVED_WINDOW_N (sws1
, i
);
6587 sw2
= SAVED_WINDOW_N (sws2
, i
);
6590 /* The "current" windows in the two configurations must
6591 correspond to each other. */
6592 EQ (d1
->current_window
, sw1
->window
)
6593 != EQ (d2
->current_window
, sw2
->window
)
6594 /* Windows' buffers must match. */
6595 || !EQ (sw1
->buffer
, sw2
->buffer
)
6596 || !EQ (sw1
->left_col
, sw2
->left_col
)
6597 || !EQ (sw1
->top_line
, sw2
->top_line
)
6598 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6599 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6600 || !EQ (sw1
->display_table
, sw2
->display_table
)
6601 /* The next two disjuncts check the window structure for
6603 || !EQ (sw1
->parent
, sw2
->parent
)
6604 || !EQ (sw1
->prev
, sw2
->prev
)
6605 || (!ignore_positions
6606 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6607 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6608 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6609 || NILP (Fequal (sw1
->start
, sw2
->start
))
6610 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6611 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6612 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6613 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6614 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6615 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6616 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6617 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6618 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6625 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6626 Scompare_window_configurations
, 2, 2, 0,
6627 doc
: /* Compare two window configurations as regards the structure of windows.
6628 This function ignores details such as the values of point and mark
6629 and scrolling positions. */)
6630 (Lisp_Object x
, Lisp_Object y
)
6632 if (compare_window_configurations (x
, y
, 1))
6638 init_window_once (void)
6640 struct frame
*f
= make_initial_frame ();
6641 XSETFRAME (selected_frame
, f
);
6642 Vterminal_frame
= selected_frame
;
6643 minibuf_window
= f
->minibuffer_window
;
6644 selected_window
= f
->selected_window
;
6645 last_nonminibuf_frame
= f
;
6647 window_initialized
= 1;
6653 Vwindow_list
= Qnil
;
6657 syms_of_window (void)
6659 DEFSYM (Qscroll_up
, "scroll-up");
6660 DEFSYM (Qscroll_down
, "scroll-down");
6661 DEFSYM (Qscroll_command
, "scroll-command");
6663 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6664 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6666 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6667 DEFSYM (Qwindowp
, "windowp");
6668 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6669 DEFSYM (Qwindow_live_p
, "window-live-p");
6670 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6671 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6672 DEFSYM (Qdelete_window
, "delete-window");
6673 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6674 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6675 DEFSYM (Qsafe
, "safe");
6676 DEFSYM (Qdisplay_buffer
, "display-buffer");
6677 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6678 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6679 DEFSYM (Qget_mru_window
, "get-mru-window");
6680 DEFSYM (Qwindow_size
, "window-size");
6681 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6682 DEFSYM (Qabove
, "above");
6683 DEFSYM (Qbelow
, "below");
6684 DEFSYM (Qclone_of
, "clone-of");
6686 staticpro (&Vwindow_list
);
6688 minibuf_selected_window
= Qnil
;
6689 staticpro (&minibuf_selected_window
);
6691 window_scroll_pixel_based_preserve_x
= -1;
6692 window_scroll_pixel_based_preserve_y
= -1;
6693 window_scroll_preserve_hpos
= -1;
6694 window_scroll_preserve_vpos
= -1;
6696 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6697 doc
: /* Non-nil means call as function to display a help buffer.
6698 The function is called with one argument, the buffer to be displayed.
6699 Used by `with-output-to-temp-buffer'.
6700 If this function is used, then it must do the entire job of showing
6701 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6702 Vtemp_buffer_show_function
= Qnil
;
6704 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6705 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6706 Vminibuf_scroll_window
= Qnil
;
6708 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6709 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6710 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6711 is displayed in the `mode-line' face. */);
6712 mode_line_in_non_selected_windows
= 1;
6714 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6715 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6716 Vother_window_scroll_buffer
= Qnil
;
6718 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6719 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6720 auto_window_vscroll_p
= 1;
6722 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6723 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6724 next_screen_context_lines
= 2;
6726 DEFVAR_LISP ("scroll-preserve-screen-position",
6727 Vscroll_preserve_screen_position
,
6728 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6729 A value of nil means point does not keep its screen position except
6730 at the scroll margin or window boundary respectively.
6731 A value of t means point keeps its screen position if the scroll
6732 command moved it vertically out of the window, e.g. when scrolling
6734 Any other value means point always keeps its screen position.
6735 Scroll commands should have the `scroll-command' property
6736 on their symbols to be controlled by this variable. */);
6737 Vscroll_preserve_screen_position
= Qnil
;
6739 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6740 doc
: /* Type of marker to use for `window-point'. */);
6741 Vwindow_point_insertion_type
= Qnil
;
6743 DEFVAR_LISP ("window-configuration-change-hook",
6744 Vwindow_configuration_change_hook
,
6745 doc
: /* Functions to call when window configuration changes.
6746 The buffer-local part is run once per window, with the relevant window
6747 selected; while the global part is run only once for the modified frame,
6748 with the relevant frame selected. */);
6749 Vwindow_configuration_change_hook
= Qnil
;
6751 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6752 doc
: /* Non-nil means `recenter' redraws entire frame.
6753 If this option is non-nil, then the `recenter' command with a nil
6754 argument will redraw the entire frame; the special value `tty' causes
6755 the frame to be redrawn only if it is a tty frame. */);
6756 Vrecenter_redisplay
= Qtty
;
6758 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6759 doc
: /* If t, resize window combinations proportionally.
6760 If this variable is nil, splitting a window gets the entire screen space
6761 for displaying the new window from the window to split. Deleting and
6762 resizing a window preferably resizes one adjacent window only.
6764 If this variable is t, splitting a window tries to get the space
6765 proportionally from all windows in the same combination. This also
6766 allows to split a window that is otherwise too small or of fixed size.
6767 Resizing and deleting a window proportionally resize all windows in the
6770 Other values are reserved for future use.
6772 This variable takes no effect if the variable `window-combination-limit' is
6774 Vwindow_combination_resize
= Qnil
;
6776 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6777 doc
: /* If non-nil, splitting a window makes a new parent window.
6778 The following values are recognized:
6780 nil means splitting a window will create a new parent window only if the
6781 window has no parent window or the window shall become part of a
6782 combination orthogonal to the one it is part of.
6784 `window-size' means that splitting a window for displaying a buffer
6785 makes a new parent window provided `display-buffer' is supposed to
6786 explicitly set the window's size due to the presence of a
6787 `window-height' or `window-width' entry in the alist used by
6788 `display-buffer'. Otherwise, this value is handled like nil.
6790 `temp-buffer' means that splitting a window for displaying a temporary
6791 buffer always makes a new parent window. Otherwise, this value is
6794 `display-buffer' means that splitting a window for displaying a buffer
6795 always makes a new parent window. Since temporary buffers are
6796 displayed by the function `display-buffer', this value is stronger
6797 than `temp-buffer'. Splitting a window for other purpose makes a
6798 new parent window only if needed.
6800 t means that splitting a window always creates a new parent window. If
6801 all splits behave this way, each frame's window tree is a binary
6802 tree and every window but the frame's root window has exactly one
6805 Other values are reserved for future use. */);
6806 Vwindow_combination_limit
= Qwindow_size
;
6808 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6809 doc
: /* Alist of persistent window parameters.
6810 This alist specifies which window parameters shall get saved by
6811 `current-window-configuration' and `window-state-get' and subsequently
6812 restored to their previous values by `set-window-configuration' and
6815 The car of each entry of this alist is the symbol specifying the
6816 parameter. The cdr is one of the following:
6818 nil means the parameter is neither saved by `window-state-get' nor by
6819 `current-window-configuration'.
6821 t means the parameter is saved by `current-window-configuration' and,
6822 provided its WRITABLE argument is nil, by `window-state-get'.
6824 The symbol `writable' means the parameter is saved unconditionally by
6825 both `current-window-configuration' and `window-state-get'. Do not use
6826 this value for parameters without read syntax (like windows or frames).
6828 Parameters not saved by `current-window-configuration' or
6829 `window-state-get' are left alone by `set-window-configuration'
6830 respectively are not installed by `window-state-put'. */);
6831 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6833 defsubr (&Sselected_window
);
6834 defsubr (&Sminibuffer_window
);
6835 defsubr (&Swindow_minibuffer_p
);
6836 defsubr (&Swindowp
);
6837 defsubr (&Swindow_valid_p
);
6838 defsubr (&Swindow_live_p
);
6839 defsubr (&Swindow_frame
);
6840 defsubr (&Sframe_root_window
);
6841 defsubr (&Sframe_first_window
);
6842 defsubr (&Sframe_selected_window
);
6843 defsubr (&Sset_frame_selected_window
);
6844 defsubr (&Spos_visible_in_window_p
);
6845 defsubr (&Swindow_line_height
);
6846 defsubr (&Swindow_buffer
);
6847 defsubr (&Swindow_parent
);
6848 defsubr (&Swindow_top_child
);
6849 defsubr (&Swindow_left_child
);
6850 defsubr (&Swindow_next_sibling
);
6851 defsubr (&Swindow_prev_sibling
);
6852 defsubr (&Swindow_combination_limit
);
6853 defsubr (&Sset_window_combination_limit
);
6854 defsubr (&Swindow_use_time
);
6855 defsubr (&Swindow_top_line
);
6856 defsubr (&Swindow_left_column
);
6857 defsubr (&Swindow_total_height
);
6858 defsubr (&Swindow_total_width
);
6859 defsubr (&Swindow_normal_size
);
6860 defsubr (&Swindow_new_total
);
6861 defsubr (&Swindow_new_normal
);
6862 defsubr (&Sset_window_new_total
);
6863 defsubr (&Sset_window_new_normal
);
6864 defsubr (&Swindow_resize_apply
);
6865 defsubr (&Swindow_body_height
);
6866 defsubr (&Swindow_body_width
);
6867 defsubr (&Swindow_hscroll
);
6868 defsubr (&Sset_window_hscroll
);
6869 defsubr (&Swindow_redisplay_end_trigger
);
6870 defsubr (&Sset_window_redisplay_end_trigger
);
6871 defsubr (&Swindow_edges
);
6872 defsubr (&Swindow_pixel_edges
);
6873 defsubr (&Swindow_absolute_pixel_edges
);
6874 defsubr (&Swindow_inside_edges
);
6875 defsubr (&Swindow_inside_pixel_edges
);
6876 defsubr (&Swindow_inside_absolute_pixel_edges
);
6877 defsubr (&Scoordinates_in_window_p
);
6878 defsubr (&Swindow_at
);
6879 defsubr (&Swindow_point
);
6880 defsubr (&Swindow_start
);
6881 defsubr (&Swindow_end
);
6882 defsubr (&Sset_window_point
);
6883 defsubr (&Sset_window_start
);
6884 defsubr (&Swindow_dedicated_p
);
6885 defsubr (&Sset_window_dedicated_p
);
6886 defsubr (&Swindow_display_table
);
6887 defsubr (&Sset_window_display_table
);
6888 defsubr (&Snext_window
);
6889 defsubr (&Sprevious_window
);
6890 defsubr (&Sget_buffer_window
);
6891 defsubr (&Sdelete_other_windows_internal
);
6892 defsubr (&Sdelete_window_internal
);
6893 defsubr (&Sresize_mini_window_internal
);
6894 defsubr (&Sset_window_buffer
);
6895 defsubr (&Srun_window_configuration_change_hook
);
6896 defsubr (&Sselect_window
);
6897 defsubr (&Sforce_window_update
);
6898 defsubr (&Ssplit_window_internal
);
6899 defsubr (&Sscroll_up
);
6900 defsubr (&Sscroll_down
);
6901 defsubr (&Sscroll_left
);
6902 defsubr (&Sscroll_right
);
6903 defsubr (&Sother_window_for_scrolling
);
6904 defsubr (&Sscroll_other_window
);
6905 defsubr (&Sminibuffer_selected_window
);
6906 defsubr (&Srecenter
);
6907 defsubr (&Swindow_text_height
);
6908 defsubr (&Smove_to_window_line
);
6909 defsubr (&Swindow_configuration_p
);
6910 defsubr (&Swindow_configuration_frame
);
6911 defsubr (&Sset_window_configuration
);
6912 defsubr (&Scurrent_window_configuration
);
6913 defsubr (&Sset_window_margins
);
6914 defsubr (&Swindow_margins
);
6915 defsubr (&Sset_window_fringes
);
6916 defsubr (&Swindow_fringes
);
6917 defsubr (&Sset_window_scroll_bars
);
6918 defsubr (&Swindow_scroll_bars
);
6919 defsubr (&Swindow_vscroll
);
6920 defsubr (&Sset_window_vscroll
);
6921 defsubr (&Scompare_window_configurations
);
6922 defsubr (&Swindow_list
);
6923 defsubr (&Swindow_list_1
);
6924 defsubr (&Swindow_prev_buffers
);
6925 defsubr (&Sset_window_prev_buffers
);
6926 defsubr (&Swindow_next_buffers
);
6927 defsubr (&Sset_window_next_buffers
);
6928 defsubr (&Swindow_parameters
);
6929 defsubr (&Swindow_parameter
);
6930 defsubr (&Sset_window_parameter
);
6934 keys_of_window (void)
6936 initial_define_key (control_x_map
, '<', "scroll-left");
6937 initial_define_key (control_x_map
, '>', "scroll-right");
6939 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6940 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6941 initial_define_key (meta_map
, 'v', "scroll-down-command");