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 */
59 Lisp_Object Qwindowp
, Qwindow_live_p
;
60 static Lisp_Object Qwindow_valid_p
;
61 static Lisp_Object Qwindow_configuration_p
;
62 static Lisp_Object Qrecord_window_buffer
;
63 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
64 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
65 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
66 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
67 static Lisp_Object Qsafe
, Qabove
, Qbelow
, Qwindow_size
, Qclone_of
;
69 static int displayed_window_lines (struct window
*);
70 static int count_windows (struct window
*);
71 static int get_leaf_windows (struct window
*, struct window
**, int);
72 static void window_scroll (Lisp_Object
, EMACS_INT
, bool, int);
73 static void window_scroll_pixel_based (Lisp_Object
, int, bool, int);
74 static void window_scroll_line_based (Lisp_Object
, int, bool, int);
75 static Lisp_Object
window_list (void);
76 static int add_window_to_list (struct window
*, void *);
77 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
79 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
81 static void foreach_window (struct frame
*,
82 int (* fn
) (struct window
*, void *),
84 static int foreach_window_1 (struct window
*,
85 int (* fn
) (struct window
*, void *),
87 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
88 static int window_resize_check (struct window
*, bool);
89 static void window_resize_apply (struct window
*, bool);
90 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
91 static void select_window_1 (Lisp_Object
, bool);
93 static struct window
*set_window_fringes (struct window
*, Lisp_Object
,
94 Lisp_Object
, Lisp_Object
);
95 static struct window
*set_window_margins (struct window
*, Lisp_Object
,
97 static struct window
*set_window_scroll_bars (struct window
*, Lisp_Object
,
98 Lisp_Object
, Lisp_Object
);
99 static void apply_window_adjustment (struct window
*);
101 /* This is the window in which the terminal's cursor should
102 be left when nothing is being done with it. This must
103 always be a leaf window, and its buffer is selected by
104 the top level editing loop at the end of each command.
106 This value is always the same as
107 FRAME_SELECTED_WINDOW (selected_frame). */
108 Lisp_Object selected_window
;
110 /* A list of all windows for use by next_window and Fwindow_list.
111 Functions creating or deleting windows should invalidate this cache
112 by setting it to nil. */
113 Lisp_Object Vwindow_list
;
115 /* The mini-buffer window of the selected frame.
116 Note that you cannot test for mini-bufferness of an arbitrary window
117 by comparing against this; but you can test for mini-bufferness of
118 the selected window. */
119 Lisp_Object minibuf_window
;
121 /* Non-nil means it is the window whose mode line should be
122 shown as the selected window when the minibuffer is selected. */
123 Lisp_Object minibuf_selected_window
;
125 /* Hook run at end of temp_output_buffer_show. */
126 static Lisp_Object Qtemp_buffer_show_hook
;
128 /* Nonzero after init_window_once has finished. */
129 static int window_initialized
;
131 /* Hook to run when window config changes. */
132 static Lisp_Object Qwindow_configuration_change_hook
;
134 /* Used by the function window_scroll_pixel_based */
135 static int window_scroll_pixel_based_preserve_x
;
136 static int window_scroll_pixel_based_preserve_y
;
138 /* Same for window_scroll_line_based. */
139 static EMACS_INT window_scroll_preserve_hpos
;
140 static EMACS_INT window_scroll_preserve_vpos
;
143 CHECK_WINDOW_CONFIGURATION (Lisp_Object x
)
145 CHECK_TYPE (WINDOW_CONFIGURATIONP (x
), Qwindow_configuration_p
, x
);
148 /* These setters are used only in this file, so they can be private. */
150 wset_combination_limit (struct window
*w
, Lisp_Object val
)
152 w
->combination_limit
= val
;
155 wset_dedicated (struct window
*w
, Lisp_Object val
)
160 wset_display_table (struct window
*w
, Lisp_Object val
)
162 w
->display_table
= 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_start (struct window
*w
, Lisp_Object val
)
200 wset_temslot (struct window
*w
, Lisp_Object val
)
205 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
207 w
->vertical_scroll_bar_type
= val
;
210 wset_window_parameters (struct window
*w
, Lisp_Object val
)
212 w
->window_parameters
= val
;
215 wset_combination (struct window
*w
, bool horflag
, Lisp_Object val
)
217 /* Since leaf windows never becomes non-leaf, there should
218 be no buffer and markers in start and pointm fields of W. */
219 eassert (!BUFFERP (w
->contents
) && NILP (w
->start
) && NILP (w
->pointm
));
221 /* When an internal window is deleted and VAL is nil, HORFLAG
224 w
->horizontal
= horflag
;
227 /* Nonzero if leaf window W doesn't reflect the actual state
228 of displayed buffer due to its text or overlays change. */
231 window_outdated (struct window
*w
)
233 struct buffer
*b
= XBUFFER (w
->contents
);
234 return (w
->last_modified
< BUF_MODIFF (b
)
235 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
));
239 decode_live_window (register Lisp_Object window
)
242 return XWINDOW (selected_window
);
244 CHECK_LIVE_WINDOW (window
);
245 return XWINDOW (window
);
249 decode_any_window (register Lisp_Object window
)
254 return XWINDOW (selected_window
);
256 CHECK_WINDOW (window
);
257 w
= XWINDOW (window
);
261 static struct window
*
262 decode_valid_window (register Lisp_Object window
)
267 return XWINDOW (selected_window
);
269 CHECK_VALID_WINDOW (window
);
270 w
= XWINDOW (window
);
274 /* Called when W's buffer slot is changed. ARG -1 means that W is about to
275 cease its buffer, and 1 means that W is about to set up the new one. */
278 adjust_window_count (struct window
*w
, int arg
)
280 eassert (eabs (arg
) == 1);
281 if (BUFFERP (w
->contents
))
283 struct buffer
*b
= XBUFFER (w
->contents
);
287 b
->window_count
+= arg
;
288 eassert (b
->window_count
>= 0);
289 /* These should be recalculated by redisplay code. */
290 w
->window_end_valid
= 0;
291 w
->base_line_pos
= 0;
295 /* Set W's buffer slot to VAL and recompute number
296 of windows showing VAL if it is a buffer. */
299 wset_buffer (struct window
*w
, Lisp_Object val
)
301 adjust_window_count (w
, -1);
303 /* Make sure that we do not assign the buffer
304 to an internal window. */
305 eassert (MARKERP (w
->start
) && MARKERP (w
->pointm
));
307 adjust_window_count (w
, 1);
310 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
311 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
314 return WINDOWP (object
) ? Qt
: Qnil
;
317 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
318 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
319 A valid window is either a window that displays a buffer or an internal
320 window. Deleted windows are not live. */)
323 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
326 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
327 doc
: /* Return t if OBJECT is a live window and nil otherwise.
328 A live window is a window that displays a buffer.
329 Internal windows and deleted windows are not live. */)
332 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
335 /* Frames and windows. */
336 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
337 doc
: /* Return the frame that window WINDOW is on.
338 WINDOW must be a valid window and defaults to the selected one. */)
341 return decode_valid_window (window
)->frame
;
344 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
345 doc
: /* Return the root window of FRAME-OR-WINDOW.
346 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
347 With a frame argument, return that frame's root window.
348 With a window argument, return the root window of that window's frame. */)
349 (Lisp_Object frame_or_window
)
353 if (NILP (frame_or_window
))
354 window
= SELECTED_FRAME ()->root_window
;
355 else if (WINDOW_VALID_P (frame_or_window
))
356 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
359 CHECK_LIVE_FRAME (frame_or_window
);
360 window
= XFRAME (frame_or_window
)->root_window
;
366 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
367 doc
: /* Return the minibuffer window for frame FRAME.
368 If FRAME is omitted or nil, it defaults to the selected frame. */)
371 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
374 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
375 Swindow_minibuffer_p
, 0, 1, 0,
376 doc
: /* Return non-nil if WINDOW is a minibuffer window.
377 WINDOW must be a valid window and defaults to the selected one. */)
380 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
383 /* Don't move this to window.el - this must be a safe routine. */
384 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
385 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
386 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
387 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
388 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
389 the first window of that frame. */)
390 (Lisp_Object frame_or_window
)
394 if (NILP (frame_or_window
))
395 window
= SELECTED_FRAME ()->root_window
;
396 else if (WINDOW_VALID_P (frame_or_window
))
397 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
400 CHECK_LIVE_FRAME (frame_or_window
);
401 window
= XFRAME (frame_or_window
)->root_window
;
404 while (WINDOWP (XWINDOW (window
)->contents
))
405 window
= XWINDOW (window
)->contents
;
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
);
488 /* Make the selected window's buffer current. */
489 Fset_buffer (w
->contents
);
491 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
492 /* `switch-to-buffer' uses (select-window (selected-window)) as a "clever"
493 way to call record_buffer from Elisp, so it's important that we call
494 record_buffer before returning here. */
495 goto record_and_return
;
497 sf
= SELECTED_FRAME ();
498 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
500 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
501 /* Use this rather than Fhandle_switch_frame
502 so that FRAME_FOCUS_FRAME is moved appropriately as we
503 move around in the state where a minibuffer in a separate
505 Fselect_frame (WINDOW_FRAME (w
), norecord
);
506 /* Fselect_frame called us back so we've done all the work already. */
507 eassert (EQ (window
, selected_window
));
511 fset_selected_window (sf
, window
);
513 select_window_1 (window
, inhibit_point_swap
);
514 bset_last_selected_window (XBUFFER (w
->contents
), window
);
515 windows_or_buffers_changed
++;
518 /* record_buffer can run QUIT, so make sure it is run only after we have
519 re-established the invariant between selected_window and selected_frame,
520 otherwise the temporary broken invariant might "escape" (bug#14161). */
523 w
->use_time
= ++window_select_count
;
524 record_buffer (w
->contents
);
530 /* Select window with a minimum of fuss, i.e. don't record the change anywhere
531 (not even for redisplay's benefit), and assume that the window's frame is
534 select_window_1 (Lisp_Object window
, bool inhibit_point_swap
)
536 /* Store the old selected window's buffer's point in pointm of the old
537 selected window. It belongs to that window, and when the window is
538 not selected, must be in the window. */
539 if (!inhibit_point_swap
)
541 struct window
*ow
= XWINDOW (selected_window
);
542 if (BUFFERP (ow
->contents
))
543 set_marker_both (ow
->pointm
, ow
->contents
,
544 BUF_PT (XBUFFER (ow
->contents
)),
545 BUF_PT_BYTE (XBUFFER (ow
->contents
)));
548 selected_window
= window
;
550 /* Go to the point recorded in the window.
551 This is important when the buffer is in more
552 than one window. It also matters when
553 redisplay_window has altered point after scrolling,
554 because it makes the change only in the window. */
556 register ptrdiff_t new_point
= marker_position (XWINDOW (window
)->pointm
);
557 if (new_point
< BEGV
)
559 else if (new_point
> ZV
)
566 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
567 doc
: /* Select WINDOW which must be a live window.
568 Also make WINDOW's frame the selected frame and WINDOW that frame's
569 selected window. In addition, make WINDOW's buffer current and set that
570 buffer's value of `point' to the value of WINDOW's `window-point'.
573 Optional second arg NORECORD non-nil means do not put this buffer at the
574 front of the buffer list and do not make this window the most recently
577 Note that the main editor command loop sets the current buffer to the
578 buffer of the selected window before each command. */)
579 (register Lisp_Object window
, Lisp_Object norecord
)
581 return select_window (window
, norecord
, 0);
584 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
585 doc
: /* Return the buffer displayed in window WINDOW.
586 If WINDOW is omitted or nil, it defaults to the selected window.
587 Return nil for an internal window or a deleted window. */)
590 struct window
*w
= decode_any_window (window
);
591 return WINDOW_LEAF_P (w
) ? w
->contents
: Qnil
;
594 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
595 doc
: /* Return the parent window of window WINDOW.
596 WINDOW must be a valid window and defaults to the selected one.
597 Return nil for a window with no parent (e.g. a root window). */)
600 return decode_valid_window (window
)->parent
;
603 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
604 doc
: /* Return the topmost child window of window WINDOW.
605 WINDOW must be a valid window and defaults to the selected one.
606 Return nil if WINDOW is a live window (live windows have no children).
607 Return nil if WINDOW is an internal window whose children form a
608 horizontal combination. */)
611 struct window
*w
= decode_valid_window (window
);
612 return WINDOW_VERTICAL_COMBINATION_P (w
) ? w
->contents
: Qnil
;
615 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
616 doc
: /* Return the leftmost child window of window WINDOW.
617 WINDOW must be a valid window and defaults to the selected one.
618 Return nil if WINDOW is a live window (live windows have no children).
619 Return nil if WINDOW is an internal window whose children form a
620 vertical combination. */)
623 struct window
*w
= decode_valid_window (window
);
624 return WINDOW_HORIZONTAL_COMBINATION_P (w
) ? w
->contents
: Qnil
;
627 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
628 doc
: /* Return the next 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 next sibling. */)
633 return decode_valid_window (window
)->next
;
636 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
637 doc
: /* Return the previous sibling window of window WINDOW.
638 WINDOW must be a valid window and defaults to the selected one.
639 Return nil if WINDOW has no previous sibling. */)
642 return decode_valid_window (window
)->prev
;
645 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
646 doc
: /* Return combination limit of window WINDOW.
647 WINDOW must be a valid window used in horizontal or vertical combination.
648 If the return value is nil, child windows of WINDOW can be recombined with
649 WINDOW's siblings. A return value of t means that child windows of
650 WINDOW are never \(re-)combined with WINDOW's siblings. */)
655 CHECK_VALID_WINDOW (window
);
656 w
= XWINDOW (window
);
657 if (WINDOW_LEAF_P (w
))
658 error ("Combination limit is meaningful for internal windows only");
659 return w
->combination_limit
;
662 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
663 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
664 WINDOW must be a valid window used in horizontal or vertical combination.
665 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
666 siblings. LIMIT t means that child windows of WINDOW are never
667 \(re-)combined with WINDOW's siblings. Other values are reserved for
669 (Lisp_Object window
, Lisp_Object limit
)
673 CHECK_VALID_WINDOW (window
);
674 w
= XWINDOW (window
);
675 if (WINDOW_LEAF_P (w
))
676 error ("Combination limit is meaningful for internal windows only");
677 wset_combination_limit (w
, limit
);
681 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
682 doc
: /* Return the use time of window WINDOW.
683 WINDOW must be a live window and defaults to the selected one.
684 The window with the highest use time is the most recently selected
685 one. The window with the lowest use time is the least recently
689 return make_number (decode_live_window (window
)->use_time
);
692 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
693 doc
: /* Return the total height, in lines, of window WINDOW.
694 WINDOW must be a valid window and defaults to the selected one.
696 The return value includes the mode line and header line, if any.
697 If WINDOW is an internal window, the total height is the height
698 of the screen areas spanned by its children.
700 On a graphical display, this total height is reported as an
701 integer multiple of the default character height. */)
704 return make_number (decode_valid_window (window
)->total_lines
);
707 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
708 doc
: /* Return the total width, in columns, of window WINDOW.
709 WINDOW must be a valid window and defaults to the selected one.
711 The return value includes any vertical dividers or scroll bars
712 belonging to WINDOW. If WINDOW is an internal window, the total width
713 is the width of the screen areas spanned by its children.
715 On a graphical display, this total width is reported as an
716 integer multiple of the default character width. */)
719 return make_number (decode_valid_window (window
)->total_cols
);
722 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
723 doc
: /* Return the new total size of window WINDOW.
724 WINDOW must be a valid window and defaults to the selected one. */)
727 return decode_valid_window (window
)->new_total
;
730 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
731 doc
: /* Return the normal height of window WINDOW.
732 WINDOW must be a valid window and defaults to the selected one.
733 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
734 (Lisp_Object window
, Lisp_Object horizontal
)
736 struct window
*w
= decode_valid_window (window
);
738 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
741 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
742 doc
: /* Return new normal size of window WINDOW.
743 WINDOW must be a valid window and defaults to the selected one. */)
746 return decode_valid_window (window
)->new_normal
;
749 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
750 doc
: /* Return left column of window WINDOW.
751 This is the distance, in columns, between the left edge of WINDOW and
752 the left edge of the frame's window area. For instance, the return
753 value is 0 if there is no window to the left of WINDOW.
755 WINDOW must be a valid window and defaults to the selected one. */)
758 return make_number (decode_valid_window (window
)->left_col
);
761 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
762 doc
: /* Return top line of window WINDOW.
763 This is the distance, in lines, between the top of WINDOW and the top
764 of the frame's window area. For instance, the return value is 0 if
765 there is no window above WINDOW.
767 WINDOW must be a valid window and defaults to the selected one. */)
770 return make_number (decode_valid_window (window
)->top_line
);
773 /* Return the number of lines of W's body. Don't count any mode or
777 window_body_lines (struct window
*w
)
779 int height
= w
->total_lines
;
781 if (!MINI_WINDOW_P (w
))
783 if (WINDOW_WANTS_MODELINE_P (w
))
785 if (WINDOW_WANTS_HEADER_LINE_P (w
))
792 /* Return the number of columns of W's body. Don't count columns
793 occupied by the scroll bar or the vertical bar separating W from its
794 right sibling. On window-systems don't count fringes or display
798 window_body_cols (struct window
*w
)
800 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
801 int width
= w
->total_cols
;
803 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
804 /* Scroll bars occupy a few columns. */
805 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
806 else if (!FRAME_WINDOW_P (f
)
807 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
808 /* The column of `|' characters separating side-by-side windows
809 occupies one column only. */
812 /* Display margins cannot be used for normal text. */
813 width
-= WINDOW_LEFT_MARGIN_COLS (w
) + WINDOW_RIGHT_MARGIN_COLS (w
);
815 if (FRAME_WINDOW_P (f
))
816 /* On window-systems, fringes cannot be used for normal text. */
817 width
-= WINDOW_FRINGE_COLS (w
);
822 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
823 doc
: /* Return the height, in lines, of WINDOW's text area.
824 WINDOW must be a live window and defaults to the selected one.
826 The returned height does not include the mode line or header line.
827 On a graphical display, the height is expressed as an integer multiple
828 of the default character height. If a line at the bottom of the text
829 area is only partially visible, that counts as a whole line; to
830 exclude partially-visible lines, use `window-text-height'. */)
833 return make_number (window_body_lines (decode_live_window (window
)));
836 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
837 doc
: /* Return the width, in columns, of WINDOW's text area.
838 WINDOW must be a live window and defaults to the selected one.
840 The return value does not include any vertical dividers, fringe or
841 marginal areas, or scroll bars. On a graphical display, the width is
842 expressed as an integer multiple of the default character width. */)
845 return make_number (window_body_cols (decode_live_window (window
)));
848 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
849 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
850 WINDOW must be a live window and defaults to the selected one. */)
853 return make_number (decode_live_window (window
)->hscroll
);
856 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
857 range, returning the new amount as a fixnum. */
859 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
861 /* Horizontal scrolling has problems with large scroll amounts.
862 It's too slow with long lines, and even with small lines the
863 display can be messed up. For now, though, impose only the limits
864 required by the internal representation: horizontal scrolling must
865 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
866 (since it's stored in a ptrdiff_t). */
867 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
868 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
870 /* Prevent redisplay shortcuts when changing the hscroll. */
871 if (w
->hscroll
!= new_hscroll
)
872 XBUFFER (w
->contents
)->prevent_redisplay_optimizations_p
= 1;
874 w
->hscroll
= new_hscroll
;
875 return make_number (new_hscroll
);
878 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
879 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
880 WINDOW must be a live window and defaults to the selected one.
881 Clip the number to a reasonable value if out of range.
882 Return the new number. NCOL should be zero or positive.
884 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
885 window so that the location of point moves off-window. */)
886 (Lisp_Object window
, Lisp_Object ncol
)
889 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
892 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
893 Swindow_redisplay_end_trigger
, 0, 1, 0,
894 doc
: /* Return WINDOW's redisplay end trigger value.
895 WINDOW must be a live window and defaults to the selected one.
896 See `set-window-redisplay-end-trigger' for more information. */)
899 return decode_live_window (window
)->redisplay_end_trigger
;
902 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
903 Sset_window_redisplay_end_trigger
, 2, 2, 0,
904 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
905 WINDOW must be a live window and defaults to the selected one. VALUE
906 should be a buffer position (typically a marker) or nil. If it is a
907 buffer position, then if redisplay in WINDOW reaches a position beyond
908 VALUE, the functions in `redisplay-end-trigger-functions' are called
909 with two arguments: WINDOW, and the end trigger value. Afterwards the
910 end-trigger value is reset to nil. */)
911 (register Lisp_Object window
, Lisp_Object value
)
913 wset_redisplay_end_trigger (decode_live_window (window
), value
);
917 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
918 doc
: /* Return a list of the edge coordinates of WINDOW.
919 WINDOW must be a valid window and defaults to the selected one.
921 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
922 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
923 0 at top left corner of frame.
925 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
926 is one more than the bottommost row occupied by WINDOW. The edges
927 include the space used by WINDOW's scroll bar, display margins, fringes,
928 header line, and/or mode line. For the edges of just the text area, use
929 `window-inside-edges'. */)
932 register struct window
*w
= decode_valid_window (window
);
934 return list4i (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
935 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
938 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
939 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
940 WINDOW must be a valid window and defaults to the selected one.
942 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
943 0, 0 at the top left corner of the frame.
945 RIGHT is one more than the rightmost x position occupied by WINDOW.
946 BOTTOM is one more than the bottommost y position occupied by WINDOW.
947 The pixel edges include the space used by WINDOW's scroll bar, display
948 margins, fringes, header line, and/or mode line. For the pixel edges
949 of just the text area, use `window-inside-pixel-edges'. */)
952 register struct window
*w
= decode_valid_window (window
);
954 return list4i (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
955 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
959 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
961 struct frame
*f
= XFRAME (w
->frame
);
963 #ifdef FRAME_MENUBAR_HEIGHT
964 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
966 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
967 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
968 #elif FRAME_TOOLBAR_HEIGHT
969 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
971 #ifdef FRAME_NS_TITLEBAR_HEIGHT
972 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
974 *add_x
= f
->left_pos
;
975 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
976 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
980 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
981 Swindow_absolute_pixel_edges
, 0, 1, 0,
982 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
983 WINDOW must be a valid window and defaults to the selected one.
985 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
986 0, 0 at the top left corner of the display.
988 RIGHT is one more than the rightmost x position occupied by WINDOW.
989 BOTTOM is one more than the bottommost y position occupied by WINDOW.
990 The pixel edges include the space used by WINDOW's scroll bar, display
991 margins, fringes, header line, and/or mode line. For the pixel edges
992 of just the text area, use `window-inside-absolute-pixel-edges'. */)
995 register struct window
*w
= decode_valid_window (window
);
998 calc_absolute_offset (w
, &add_x
, &add_y
);
1000 return list4i (WINDOW_LEFT_EDGE_X (w
) + add_x
,
1001 WINDOW_TOP_EDGE_Y (w
) + add_y
,
1002 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
1003 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
1006 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
1007 doc
: /* Return a list of the edge coordinates of WINDOW.
1008 WINDOW must be a live window and defaults to the selected one.
1010 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
1011 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
1012 0 at top left corner of frame.
1014 RIGHT is one more than the rightmost column of WINDOW's text area.
1015 BOTTOM is one more than the bottommost row of WINDOW's text area. The
1016 inside edges do not include the space used by the WINDOW's scroll bar,
1017 display margins, fringes, header line, and/or mode line. */)
1018 (Lisp_Object window
)
1020 register struct window
*w
= decode_live_window (window
);
1022 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w
)
1023 + WINDOW_LEFT_MARGIN_COLS (w
)
1024 + WINDOW_LEFT_FRINGE_COLS (w
)),
1025 (WINDOW_TOP_EDGE_LINE (w
)
1026 + WINDOW_HEADER_LINE_LINES (w
)),
1027 (WINDOW_BOX_RIGHT_EDGE_COL (w
)
1028 - WINDOW_RIGHT_MARGIN_COLS (w
)
1029 - WINDOW_RIGHT_FRINGE_COLS (w
)),
1030 (WINDOW_BOTTOM_EDGE_LINE (w
)
1031 - WINDOW_MODE_LINE_LINES (w
)));
1034 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
1035 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1036 WINDOW must be a live window and defaults to the selected one.
1038 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1039 (0,0) at the top left corner of the frame's window area.
1041 RIGHT is one more than the rightmost x position of WINDOW's text area.
1042 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1043 The inside edges do not include the space used by WINDOW's scroll bar,
1044 display margins, fringes, header line, and/or mode line. */)
1045 (Lisp_Object window
)
1047 register struct window
*w
= decode_live_window (window
);
1049 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1050 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1051 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1052 (WINDOW_TOP_EDGE_Y (w
)
1053 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1054 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1055 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1056 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1057 (WINDOW_BOTTOM_EDGE_Y (w
)
1058 - WINDOW_MODE_LINE_HEIGHT (w
)));
1061 DEFUN ("window-inside-absolute-pixel-edges",
1062 Fwindow_inside_absolute_pixel_edges
,
1063 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1064 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1065 WINDOW must be a live window and defaults to the selected one.
1067 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1068 (0,0) at the top left corner of the frame's window area.
1070 RIGHT is one more than the rightmost x position of WINDOW's text area.
1071 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1072 The inside edges do not include the space used by WINDOW's scroll bar,
1073 display margins, fringes, header line, and/or mode line. */)
1074 (Lisp_Object window
)
1076 register struct window
*w
= decode_live_window (window
);
1079 calc_absolute_offset (w
, &add_x
, &add_y
);
1081 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1082 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1083 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1084 (WINDOW_TOP_EDGE_Y (w
)
1085 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1086 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1087 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1088 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1089 (WINDOW_BOTTOM_EDGE_Y (w
)
1090 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1093 /* Test if the character at column X, row Y is within window W.
1094 If it is not, return ON_NOTHING;
1095 if it is in the window's text area, return ON_TEXT;
1096 if it is on the window's modeline, return ON_MODE_LINE;
1097 if it is on the border between the window and its right sibling,
1098 return ON_VERTICAL_BORDER.
1099 if it is on a scroll bar, return ON_SCROLL_BAR.
1100 if it is on the window's top line, return ON_HEADER_LINE;
1101 if it is in left or right fringe of the window,
1102 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1103 if it is in the marginal area to the left/right of the window,
1104 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1106 X and Y are frame relative pixel coordinates. */
1108 static enum window_part
1109 coordinates_in_window (register struct window
*w
, int x
, int y
)
1111 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1112 enum window_part part
;
1113 int ux
= FRAME_COLUMN_WIDTH (f
);
1114 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1115 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1116 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1117 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1118 /* The width of the area where the vertical line can be dragged.
1119 (Between mode lines for instance. */
1120 int grabbable_width
= ux
;
1121 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1123 /* Outside any interesting row or column? */
1124 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1127 /* On the mode line or header line? */
1128 if ((WINDOW_WANTS_MODELINE_P (w
)
1129 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1130 && (part
= ON_MODE_LINE
))
1131 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1132 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1133 && (part
= ON_HEADER_LINE
)))
1135 /* If it's under/over the scroll bar portion of the mode/header
1136 line, say it's on the vertical line. That's to be able to
1137 resize windows horizontally in case we're using toolkit scroll
1138 bars. Note: If scrollbars are on the left, the window that
1139 must be eventually resized is that on the left of WINDOW. */
1140 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1141 && !WINDOW_LEFTMOST_P (w
)
1142 && eabs (x
- left_x
) < grabbable_width
)
1143 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1144 && !WINDOW_RIGHTMOST_P (w
)
1145 && eabs (x
- right_x
) < grabbable_width
))
1146 return ON_VERTICAL_BORDER
;
1151 /* In what's below, we subtract 1 when computing right_x because we
1152 want the rightmost pixel, which is given by left_pixel+width-1. */
1153 if (w
->pseudo_window_p
)
1156 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1160 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1161 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1164 /* Outside any interesting column? */
1165 if (x
< left_x
|| x
> right_x
)
1166 return ON_SCROLL_BAR
;
1168 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1169 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1171 text_left
= window_box_left (w
, TEXT_AREA
);
1172 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1174 if (FRAME_WINDOW_P (f
))
1176 if (!w
->pseudo_window_p
1177 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1178 && !WINDOW_RIGHTMOST_P (w
)
1179 && (eabs (x
- right_x
) < grabbable_width
))
1180 return ON_VERTICAL_BORDER
;
1182 /* Need to say "x > right_x" rather than >=, since on character
1183 terminals, the vertical line's x coordinate is right_x. */
1184 else if (!w
->pseudo_window_p
1185 && !WINDOW_RIGHTMOST_P (w
)
1186 && x
> right_x
- ux
)
1187 return ON_VERTICAL_BORDER
;
1191 if (lmargin_width
> 0
1192 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1193 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1194 : (x
< left_x
+ lmargin_width
)))
1195 return ON_LEFT_MARGIN
;
1197 return ON_LEFT_FRINGE
;
1200 if (x
>= text_right
)
1202 if (rmargin_width
> 0
1203 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1204 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1205 : (x
>= right_x
- rmargin_width
)))
1206 return ON_RIGHT_MARGIN
;
1208 return ON_RIGHT_FRINGE
;
1211 /* Everything special ruled out - must be on text area */
1215 /* Take X is the frame-relative pixel x-coordinate, and return the
1216 x-coordinate relative to part PART of window W. */
1218 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1220 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1225 return x
- window_box_left (w
, TEXT_AREA
);
1227 case ON_LEFT_FRINGE
:
1230 case ON_RIGHT_FRINGE
:
1231 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1233 case ON_LEFT_MARGIN
:
1235 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1236 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1238 case ON_RIGHT_MARGIN
:
1240 - ((w
->pseudo_window_p
)
1241 ? WINDOW_TOTAL_WIDTH (w
)
1242 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1243 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1244 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1245 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1248 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1253 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1254 Scoordinates_in_window_p
, 2, 2, 0,
1255 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1256 WINDOW must be a live window and defaults to the selected one.
1257 COORDINATES is a cons of the form (X . Y), X and Y being distances
1258 measured in characters from the upper-left corner of the frame.
1259 \(0 . 0) denotes the character in the upper left corner of the
1261 If COORDINATES are in the text portion of WINDOW,
1262 the coordinates relative to the window are returned.
1263 If they are in the mode line of WINDOW, `mode-line' is returned.
1264 If they are in the top mode line of WINDOW, `header-line' is returned.
1265 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1266 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1267 If they are on the border between WINDOW and its right sibling,
1268 `vertical-line' is returned.
1269 If they are in the windows's left or right marginal areas, `left-margin'\n\
1270 or `right-margin' is returned. */)
1271 (register Lisp_Object coordinates
, Lisp_Object window
)
1278 w
= decode_live_window (window
);
1279 f
= XFRAME (w
->frame
);
1280 CHECK_CONS (coordinates
);
1281 lx
= Fcar (coordinates
);
1282 ly
= Fcdr (coordinates
);
1283 CHECK_NUMBER_OR_FLOAT (lx
);
1284 CHECK_NUMBER_OR_FLOAT (ly
);
1285 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1286 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1288 switch (coordinates_in_window (w
, x
, y
))
1294 /* Convert X and Y to window relative pixel coordinates, and
1295 return the canonical char units. */
1296 x
-= window_box_left (w
, TEXT_AREA
);
1297 y
-= WINDOW_TOP_EDGE_Y (w
);
1298 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1299 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1304 case ON_VERTICAL_BORDER
:
1305 return Qvertical_line
;
1307 case ON_HEADER_LINE
:
1308 return Qheader_line
;
1310 case ON_LEFT_FRINGE
:
1311 return Qleft_fringe
;
1313 case ON_RIGHT_FRINGE
:
1314 return Qright_fringe
;
1316 case ON_LEFT_MARGIN
:
1317 return Qleft_margin
;
1319 case ON_RIGHT_MARGIN
:
1320 return Qright_margin
;
1323 /* Historically we are supposed to return nil in this case. */
1332 /* Callback for foreach_window, used in window_from_coordinates.
1333 Check if window W contains coordinates specified by USER_DATA which
1334 is actually a pointer to a struct check_window_data CW.
1336 Check if window W contains coordinates *CW->x and *CW->y. If it
1337 does, return W in *CW->window, as Lisp_Object, and return in
1338 *CW->part the part of the window under coordinates *X,*Y. Return
1339 zero from this function to stop iterating over windows. */
1341 struct check_window_data
1343 Lisp_Object
*window
;
1345 enum window_part
*part
;
1349 check_window_containing (struct window
*w
, void *user_data
)
1351 struct check_window_data
*cw
= user_data
;
1352 enum window_part found
;
1355 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1356 if (found
!= ON_NOTHING
)
1359 XSETWINDOW (*cw
->window
, w
);
1367 /* Find the window containing frame-relative pixel position X/Y and
1368 return it as a Lisp_Object.
1370 If X, Y is on one of the window's special `window_part' elements,
1371 set *PART to the id of that element.
1373 If there is no window under X, Y return nil and leave *PART
1374 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1376 This function was previously implemented with a loop cycling over
1377 windows with Fnext_window, and starting with the frame's selected
1378 window. It turned out that this doesn't work with an
1379 implementation of next_window using Vwindow_list, because
1380 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1381 tree of F when this function is called asynchronously from
1382 note_mouse_highlight. The original loop didn't terminate in this
1386 window_from_coordinates (struct frame
*f
, int x
, int y
,
1387 enum window_part
*part
, bool tool_bar_p
)
1390 struct check_window_data cw
;
1391 enum window_part dummy
;
1397 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1398 foreach_window (f
, check_window_containing
, &cw
);
1400 /* If not found above, see if it's in the tool bar window, if a tool
1404 && WINDOWP (f
->tool_bar_window
)
1405 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1406 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1410 window
= f
->tool_bar_window
;
1416 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1417 doc
: /* Return window containing coordinates X and Y on FRAME.
1418 FRAME must be a live frame and defaults to the selected one.
1419 The top left corner of the frame is considered to be row 0,
1421 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1423 struct frame
*f
= decode_live_frame (frame
);
1425 /* Check that arguments are integers or floats. */
1426 CHECK_NUMBER_OR_FLOAT (x
);
1427 CHECK_NUMBER_OR_FLOAT (y
);
1429 return window_from_coordinates (f
,
1430 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1431 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1432 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1433 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1437 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1438 doc
: /* Return current value of point in WINDOW.
1439 WINDOW must be a live window and defaults to the selected one.
1441 For a nonselected window, this is the value point would have if that
1442 window were selected.
1444 Note that, when WINDOW is selected, the value returned is the same as
1445 that returned by `point' for WINDOW's buffer. It would be more strictly
1446 correct to return the top-level value of `point', outside of any
1447 `save-excursion' forms. But that is hard to define. */)
1448 (Lisp_Object window
)
1450 register struct window
*w
= decode_live_window (window
);
1452 if (w
== XWINDOW (selected_window
))
1453 return make_number (BUF_PT (XBUFFER (w
->contents
)));
1455 return Fmarker_position (w
->pointm
);
1458 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1459 doc
: /* Return position at which display currently starts in WINDOW.
1460 WINDOW must be a live window and defaults to the selected one.
1461 This is updated by redisplay or by calling `set-window-start'. */)
1462 (Lisp_Object window
)
1464 return Fmarker_position (decode_live_window (window
)->start
);
1467 /* This is text temporarily removed from the doc string below.
1469 This function returns nil if the position is not currently known.
1470 That happens when redisplay is preempted and doesn't finish.
1471 If in that case you want to compute where the end of the window would
1472 have been if redisplay had finished, do this:
1474 (goto-char (window-start window))
1475 (vertical-motion (1- (window-height window)) window)
1478 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1479 doc
: /* Return position at which display currently ends in WINDOW.
1480 WINDOW must be a live window and defaults to the selected one.
1481 This is updated by redisplay, when it runs to completion.
1482 Simply changing the buffer text or setting `window-start'
1483 does not update this value.
1484 Return nil if there is no recorded value. (This can happen if the
1485 last redisplay of WINDOW was preempted, and did not finish.)
1486 If UPDATE is non-nil, compute the up-to-date position
1487 if it isn't already recorded. */)
1488 (Lisp_Object window
, Lisp_Object update
)
1491 struct window
*w
= decode_live_window (window
);
1500 && (windows_or_buffers_changed
1501 || !w
->window_end_valid
1503 || b
->prevent_redisplay_optimizations_p
1504 || window_outdated (w
))
1507 struct text_pos startp
;
1508 ptrdiff_t charpos
= marker_position (w
->start
);
1510 struct buffer
*old_buffer
= NULL
;
1511 void *itdata
= NULL
;
1513 /* Cannot use Fvertical_motion because that function doesn't
1514 cope with variable-height lines. */
1515 if (b
!= current_buffer
)
1517 old_buffer
= current_buffer
;
1518 set_buffer_internal (b
);
1521 /* In case W->start is out of the range, use something
1522 reasonable. This situation occurred when loading a file with
1523 `-l' containing a call to `rmail' with subsequent other
1524 commands. At the end, W->start happened to be BEG, while
1525 rmail had already narrowed the buffer. */
1527 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1528 else if (charpos
> ZV
)
1529 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1531 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1533 itdata
= bidi_shelve_cache ();
1534 start_display (&it
, w
, startp
);
1535 move_it_vertically (&it
, window_box_height (w
));
1536 if (it
.current_y
< it
.last_visible_y
)
1537 move_it_past_eol (&it
);
1538 value
= make_number (IT_CHARPOS (it
));
1539 bidi_unshelve_cache (itdata
, 0);
1542 set_buffer_internal (old_buffer
);
1545 XSETINT (value
, BUF_Z (b
) - w
->window_end_pos
);
1550 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1551 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1552 WINDOW must be a live window and defaults to the selected one.
1554 (Lisp_Object window
, Lisp_Object pos
)
1556 register struct window
*w
= decode_live_window (window
);
1558 /* Type of POS is checked by Fgoto_char or set_marker_restricted ... */
1560 if (w
== XWINDOW (selected_window
))
1562 if (XBUFFER (w
->contents
) == current_buffer
)
1566 struct buffer
*old_buffer
= current_buffer
;
1568 /* ... but here we want to catch type error before buffer change. */
1569 CHECK_NUMBER_COERCE_MARKER (pos
);
1570 set_buffer_internal (XBUFFER (w
->contents
));
1572 set_buffer_internal (old_buffer
);
1577 set_marker_restricted (w
->pointm
, pos
, w
->contents
);
1578 /* We have to make sure that redisplay updates the window to show
1579 the new value of point. */
1580 ++windows_or_buffers_changed
;
1586 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1587 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1588 WINDOW must be a live window and defaults to the selected one. Return
1589 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1590 overriding motion of point in order to display at this exact start. */)
1591 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1593 register struct window
*w
= decode_live_window (window
);
1595 set_marker_restricted (w
->start
, pos
, w
->contents
);
1596 /* This is not right, but much easier than doing what is right. */
1597 w
->start_at_line_beg
= 0;
1600 w
->update_mode_line
= 1;
1601 if (w
!= XWINDOW (selected_window
))
1602 /* Enforce full redisplay. FIXME: make it more selective. */
1603 windows_or_buffers_changed
++;
1608 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1609 Spos_visible_in_window_p
, 0, 3, 0,
1610 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1611 WINDOW must be a live window and defaults to the selected one.
1613 Return nil if that position is scrolled vertically out of view. If a
1614 character is only partially visible, nil is returned, unless the
1615 optional argument PARTIALLY is non-nil. If POS is only out of view
1616 because of horizontal scrolling, return non-nil. If POS is t, it
1617 specifies the position of the last visible glyph in WINDOW. POS
1618 defaults to point in WINDOW; WINDOW defaults to the selected window.
1620 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1621 the return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1622 where X and Y are the pixel coordinates relative to the top left corner
1623 of the window. The remaining elements are omitted if the character after
1624 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1625 off-window at the top and bottom of the screen line ("row") containing
1626 POS, ROWH is the visible height of that row, and VPOS is the row number
1628 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1630 register struct window
*w
;
1631 register EMACS_INT posint
;
1632 register struct buffer
*buf
;
1633 struct text_pos top
;
1634 Lisp_Object in_window
= Qnil
;
1635 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1638 w
= decode_live_window (window
);
1639 buf
= XBUFFER (w
->contents
);
1640 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1644 else if (!NILP (pos
))
1646 CHECK_NUMBER_COERCE_MARKER (pos
);
1647 posint
= XINT (pos
);
1649 else if (w
== XWINDOW (selected_window
))
1652 posint
= marker_position (w
->pointm
);
1654 /* If position is above window start or outside buffer boundaries,
1655 or if window start is out of range, position is not visible. */
1657 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1658 && CHARPOS (top
) >= BUF_BEGV (buf
)
1659 && CHARPOS (top
) <= BUF_ZV (buf
)
1660 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1661 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1664 if (!NILP (in_window
) && !NILP (partially
))
1666 Lisp_Object part
= Qnil
;
1668 part
= list4i (rtop
, rbot
, rowh
, vpos
);
1669 in_window
= Fcons (make_number (x
),
1670 Fcons (make_number (y
), part
));
1676 DEFUN ("window-line-height", Fwindow_line_height
,
1677 Swindow_line_height
, 0, 2, 0,
1678 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1679 WINDOW must be a live window and defaults to the selected one.
1681 Return height of current line if LINE is omitted or nil. Return height of
1682 header or mode line if LINE is `header-line' or `mode-line'.
1683 Otherwise, LINE is a text line number starting from 0. A negative number
1684 counts from the end of the window.
1686 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1687 in pixels of the visible part of the line, VPOS and YPOS are the
1688 vertical position in lines and pixels of the line, relative to the top
1689 of the first text line, and OFFBOT is the number of off-window pixels at
1690 the bottom of the text line. If there are off-window pixels at the top
1691 of the (first) text line, YPOS is negative.
1693 Return nil if window display is not up-to-date. In that case, use
1694 `pos-visible-in-window-p' to obtain the information. */)
1695 (Lisp_Object line
, Lisp_Object window
)
1697 register struct window
*w
;
1698 register struct buffer
*b
;
1699 struct glyph_row
*row
, *end_row
;
1703 w
= decode_live_window (window
);
1705 if (noninteractive
|| w
->pseudo_window_p
)
1708 CHECK_BUFFER (w
->contents
);
1709 b
= XBUFFER (w
->contents
);
1711 /* Fail if current matrix is not up-to-date. */
1712 if (!w
->window_end_valid
1713 || windows_or_buffers_changed
1715 || b
->prevent_redisplay_optimizations_p
1716 || window_outdated (w
))
1722 if (i
< 0 || i
>= w
->current_matrix
->nrows
1723 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1725 max_y
= window_text_bottom_y (w
);
1729 if (EQ (line
, Qheader_line
))
1731 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1733 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1734 return row
->enabled_p
? list4i (row
->height
, 0, 0, 0) : Qnil
;
1737 if (EQ (line
, Qmode_line
))
1739 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1740 return (row
->enabled_p
?
1741 list4i (row
->height
,
1742 0, /* not accurate */
1743 (WINDOW_HEADER_LINE_HEIGHT (w
)
1744 + window_text_bottom_y (w
)),
1749 CHECK_NUMBER (line
);
1752 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1753 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1754 max_y
= window_text_bottom_y (w
);
1757 while ((n
< 0 || i
< n
)
1758 && row
<= end_row
&& row
->enabled_p
1759 && row
->y
+ row
->height
< max_y
)
1762 if (row
> end_row
|| !row
->enabled_p
)
1774 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1775 return list4i (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1778 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1780 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1781 More precisely, return the value assigned by the last call of
1782 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1783 never called with WINDOW as its argument, or the value set by that
1784 function was internally reset since its last call. WINDOW must be a
1785 live window and defaults to the selected one.
1787 When a window is dedicated to its buffer, `display-buffer' will refrain
1788 from displaying another buffer in it. `get-lru-window' and
1789 `get-largest-window' treat dedicated windows specially.
1790 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1791 `kill-buffer' can delete a dedicated window and the containing frame.
1793 Functions like `set-window-buffer' may change the buffer displayed by a
1794 window, unless that window is "strongly" dedicated to its buffer, that
1795 is the value returned by `window-dedicated-p' is t. */)
1796 (Lisp_Object window
)
1798 return decode_live_window (window
)->dedicated
;
1801 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1802 Sset_window_dedicated_p
, 2, 2, 0,
1803 doc
: /* Mark WINDOW as dedicated according to FLAG.
1804 WINDOW must be a live window and defaults to the selected one. FLAG
1805 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1806 mark WINDOW as non-dedicated. Return FLAG.
1808 When a window is dedicated to its buffer, `display-buffer' will refrain
1809 from displaying another buffer in it. `get-lru-window' and
1810 `get-largest-window' treat dedicated windows specially.
1811 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1812 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1813 and the containing frame.
1815 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1816 its buffer. Functions like `set-window-buffer' may change the buffer
1817 displayed by a window, unless that window is strongly dedicated to its
1818 buffer. If and when `set-window-buffer' displays another buffer in a
1819 window, it also makes sure that the window is no more dedicated. */)
1820 (Lisp_Object window
, Lisp_Object flag
)
1822 wset_dedicated (decode_live_window (window
), flag
);
1826 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1828 doc
: /* Return buffers previously shown in WINDOW.
1829 WINDOW must be a live window and defaults to the selected one.
1831 The return value is a list of elements (BUFFER WINDOW-START POS),
1832 where BUFFER is a buffer, WINDOW-START is the start position of the
1833 window for that buffer, and POS is a window-specific point value. */)
1834 (Lisp_Object window
)
1836 return decode_live_window (window
)->prev_buffers
;
1839 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1840 Sset_window_prev_buffers
, 2, 2, 0,
1841 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1842 WINDOW must be a live window and defaults to the selected one.
1844 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1845 where BUFFER is a buffer, WINDOW-START is the start position of the
1846 window for that buffer, and POS is a window-specific point value. */)
1847 (Lisp_Object window
, Lisp_Object prev_buffers
)
1849 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1850 return prev_buffers
;
1853 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1855 doc
: /* Return list of buffers recently re-shown in WINDOW.
1856 WINDOW must be a live window and defaults to the selected one. */)
1857 (Lisp_Object window
)
1859 return decode_live_window (window
)->next_buffers
;
1862 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1863 Sset_window_next_buffers
, 2, 2, 0,
1864 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1865 WINDOW must be a live window and defaults to the selected one.
1866 NEXT-BUFFERS should be a list of buffers. */)
1867 (Lisp_Object window
, Lisp_Object next_buffers
)
1869 wset_next_buffers (decode_live_window (window
), next_buffers
);
1870 return next_buffers
;
1873 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1875 doc
: /* Return the parameters of WINDOW and their values.
1876 WINDOW must be a valid window and defaults to the selected one. The
1877 return value is a list of elements of the form (PARAMETER . VALUE). */)
1878 (Lisp_Object window
)
1880 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1883 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1885 doc
: /* Return WINDOW's value for PARAMETER.
1886 WINDOW can be any window and defaults to the selected one. */)
1887 (Lisp_Object window
, Lisp_Object parameter
)
1891 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1892 return CDR_SAFE (result
);
1895 DEFUN ("set-window-parameter", Fset_window_parameter
,
1896 Sset_window_parameter
, 3, 3, 0,
1897 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1898 WINDOW can be any window and defaults to the selected one.
1900 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1902 register struct window
*w
= decode_any_window (window
);
1903 Lisp_Object old_alist_elt
;
1905 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1906 if (NILP (old_alist_elt
))
1907 wset_window_parameters
1908 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1910 Fsetcdr (old_alist_elt
, value
);
1914 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1916 doc
: /* Return the display-table that WINDOW is using.
1917 WINDOW must be a live window and defaults to the selected one. */)
1918 (Lisp_Object window
)
1920 return decode_live_window (window
)->display_table
;
1923 /* Get the display table for use on window W. This is either W's
1924 display table or W's buffer's display table. Ignore the specified
1925 tables if they are not valid; if no valid table is specified,
1928 struct Lisp_Char_Table
*
1929 window_display_table (struct window
*w
)
1931 struct Lisp_Char_Table
*dp
= NULL
;
1933 if (DISP_TABLE_P (w
->display_table
))
1934 dp
= XCHAR_TABLE (w
->display_table
);
1935 else if (BUFFERP (w
->contents
))
1937 struct buffer
*b
= XBUFFER (w
->contents
);
1939 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1940 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1941 else if (DISP_TABLE_P (Vstandard_display_table
))
1942 dp
= XCHAR_TABLE (Vstandard_display_table
);
1948 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1949 doc
: /* Set WINDOW's display-table to TABLE.
1950 WINDOW must be a live window and defaults to the selected one. */)
1951 (register Lisp_Object window
, Lisp_Object table
)
1953 wset_display_table (decode_live_window (window
), table
);
1957 /* Record info on buffer window W is displaying
1958 when it is about to cease to display that buffer. */
1960 unshow_buffer (register struct window
*w
)
1962 Lisp_Object buf
= w
->contents
;
1963 struct buffer
*b
= XBUFFER (buf
);
1965 eassert (b
== XMARKER (w
->pointm
)->buffer
);
1968 if (w
== XWINDOW (selected_window
)
1969 || ! EQ (buf
, XWINDOW (selected_window
)->contents
))
1970 /* Do this except when the selected window's buffer
1971 is being removed from some other window. */
1973 /* last_window_start records the start position that this buffer
1974 had in the last window to be disconnected from it.
1975 Now that this statement is unconditional,
1976 it is possible for the buffer to be displayed in the
1977 selected window, while last_window_start reflects another
1978 window which was recently showing the same buffer.
1979 Some people might say that might be a good thing. Let's see. */
1980 b
->last_window_start
= marker_position (w
->start
);
1982 /* Point in the selected window's buffer
1983 is actually stored in that buffer, and the window's pointm isn't used.
1984 So don't clobber point in that buffer. */
1985 if (! EQ (buf
, XWINDOW (selected_window
)->contents
)
1986 /* Don't clobber point in current buffer either (this could be
1987 useful in connection with bug#12208).
1988 && XBUFFER (buf) != current_buffer */
1989 /* This line helps to fix Horsley's testbug.el bug. */
1990 && !(WINDOWP (BVAR (b
, last_selected_window
))
1991 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1992 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->contents
)))
1993 temp_set_point_both (b
,
1994 clip_to_bounds (BUF_BEGV (b
),
1995 marker_position (w
->pointm
),
1997 clip_to_bounds (BUF_BEGV_BYTE (b
),
1998 marker_byte_position (w
->pointm
),
2001 if (WINDOWP (BVAR (b
, last_selected_window
))
2002 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
2003 bset_last_selected_window (b
, Qnil
);
2006 /* Put NEW into the window structure in place of OLD. SETFLAG zero
2007 means change window structure only. Otherwise store geometry and
2008 other settings as well. */
2010 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
2012 register Lisp_Object tem
;
2013 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
2015 /* If OLD is its frame's root window, then NEW is the new
2016 root window for that frame. */
2017 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
2018 fset_root_window (XFRAME (o
->frame
), new);
2022 n
->left_col
= o
->left_col
;
2023 n
->top_line
= o
->top_line
;
2024 n
->total_cols
= o
->total_cols
;
2025 n
->total_lines
= o
->total_lines
;
2026 wset_normal_cols (n
, o
->normal_cols
);
2027 wset_normal_cols (o
, make_float (1.0));
2028 wset_normal_lines (n
, o
->normal_lines
);
2029 wset_normal_lines (o
, make_float (1.0));
2030 n
->desired_matrix
= n
->current_matrix
= 0;
2032 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
2033 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
2034 n
->last_cursor_vpos
= 0;
2035 n
->phys_cursor_type
= -1;
2036 n
->phys_cursor_width
= -1;
2037 n
->must_be_updated_p
= 0;
2038 n
->pseudo_window_p
= 0;
2039 n
->window_end_vpos
= 0;
2040 n
->window_end_pos
= 0;
2041 n
->window_end_valid
= 0;
2047 wset_prev (XWINDOW (tem
), new);
2052 wset_next (XWINDOW (tem
), new);
2055 wset_parent (n
, tem
);
2056 if (!NILP (tem
) && EQ (XWINDOW (tem
)->contents
, old
))
2057 wset_combination (XWINDOW (tem
), XWINDOW (tem
)->horizontal
, new);
2060 /* If window WINDOW and its parent window are iso-combined, merge
2061 WINDOW's children into those of its parent window and mark WINDOW as
2065 recombine_windows (Lisp_Object window
)
2067 struct window
*w
, *p
, *c
;
2068 Lisp_Object parent
, child
;
2071 w
= XWINDOW (window
);
2073 if (!NILP (parent
) && NILP (w
->combination_limit
))
2075 p
= XWINDOW (parent
);
2076 if (WINDOWP (p
->contents
) && WINDOWP (w
->contents
)
2077 && p
->horizontal
== w
->horizontal
)
2078 /* WINDOW and PARENT are both either a vertical or a horizontal
2081 horflag
= WINDOW_HORIZONTAL_COMBINATION_P (w
);
2082 child
= w
->contents
;
2083 c
= XWINDOW (child
);
2085 /* Splice WINDOW's children into its parent's children and
2086 assign new normal sizes. */
2088 wset_combination (p
, horflag
, child
);
2091 wset_prev (c
, w
->prev
);
2092 wset_next (XWINDOW (w
->prev
), child
);
2097 wset_parent (c
, parent
);
2100 wset_normal_cols (c
,
2101 make_float ((double) c
->total_cols
2102 / (double) p
->total_cols
));
2104 wset_normal_lines (c
,
2105 make_float ((double) c
->total_lines
2106 / (double) p
->total_lines
));
2110 if (!NILP (w
->next
))
2112 wset_next (c
, w
->next
);
2113 wset_prev (XWINDOW (c
->next
), child
);
2121 c
= XWINDOW (child
);
2125 /* WINDOW can be deleted now. */
2126 wset_combination (w
, 0, Qnil
);
2131 /* If WINDOW can be deleted, delete it. */
2133 delete_deletable_window (Lisp_Object window
)
2135 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2136 call1 (Qdelete_window
, window
);
2139 /***********************************************************************
2141 ***********************************************************************/
2143 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2144 pointer. This is a callback function for foreach_window, used in
2145 the window_list function. */
2148 add_window_to_list (struct window
*w
, void *user_data
)
2150 Lisp_Object
*list
= user_data
;
2152 XSETWINDOW (window
, w
);
2153 *list
= Fcons (window
, *list
);
2158 /* Return a list of all windows, for use by next_window. If
2159 Vwindow_list is a list, return that list. Otherwise, build a new
2160 list, cache it in Vwindow_list, and return that. */
2165 if (!CONSP (Vwindow_list
))
2167 Lisp_Object tail
, frame
;
2169 Vwindow_list
= Qnil
;
2170 FOR_EACH_FRAME (tail
, frame
)
2172 Lisp_Object args
[2];
2174 /* We are visiting windows in canonical order, and add
2175 new windows at the front of args[1], which means we
2176 have to reverse this list at the end. */
2178 foreach_window (XFRAME (frame
), add_window_to_list
, &args
[1]);
2179 args
[0] = Vwindow_list
;
2180 args
[1] = Fnreverse (args
[1]);
2181 Vwindow_list
= Fnconc (2, args
);
2185 return Vwindow_list
;
2189 /* Value is non-zero if WINDOW satisfies the constraints given by
2190 OWINDOW, MINIBUF and ALL_FRAMES.
2192 MINIBUF t means WINDOW may be minibuffer windows.
2193 `lambda' means WINDOW may not be a minibuffer window.
2194 a window means a specific minibuffer window
2196 ALL_FRAMES t means search all frames,
2197 nil means search just current frame,
2198 `visible' means search just visible frames on the
2200 0 means search visible and iconified frames on the
2202 a window means search the frame that window belongs to,
2203 a frame means consider windows on that frame, only. */
2206 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
,
2207 Lisp_Object minibuf
, Lisp_Object all_frames
)
2209 struct window
*w
= XWINDOW (window
);
2210 struct frame
*f
= XFRAME (w
->frame
);
2211 bool candidate_p
= 1;
2213 if (!BUFFERP (w
->contents
))
2215 else if (MINI_WINDOW_P (w
)
2216 && (EQ (minibuf
, Qlambda
)
2217 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2219 /* If MINIBUF is `lambda' don't consider any mini-windows.
2220 If it is a window, consider only that one. */
2223 else if (EQ (all_frames
, Qt
))
2225 else if (NILP (all_frames
))
2227 eassert (WINDOWP (owindow
));
2228 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2230 else if (EQ (all_frames
, Qvisible
))
2232 candidate_p
= FRAME_VISIBLE_P (f
)
2233 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2234 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2237 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2239 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2240 #ifdef HAVE_X_WINDOWS
2241 /* Yuck!! If we've just created the frame and the
2242 window-manager requested the user to place it
2243 manually, the window may still not be considered
2244 `visible'. I'd argue it should be at least
2245 something like `iconified', but don't know how to do
2247 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2248 && !f
->output_data
.x
->has_been_visible
)
2251 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2252 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2254 else if (WINDOWP (all_frames
))
2255 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2256 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2257 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2258 else if (FRAMEP (all_frames
))
2259 candidate_p
= EQ (all_frames
, w
->frame
);
2265 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2266 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2267 MINIBUF, and ALL_FRAMES. */
2270 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2272 struct window
*w
= decode_live_window (*window
);
2274 XSETWINDOW (*window
, w
);
2275 /* MINIBUF nil may or may not include minibuffers. Decide if it
2277 if (NILP (*minibuf
))
2278 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2279 else if (!EQ (*minibuf
, Qt
))
2282 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2283 => count none of them, or a specific minibuffer window (the
2284 active one) to count. */
2286 /* ALL_FRAMES nil doesn't specify which frames to include. */
2287 if (NILP (*all_frames
))
2289 = (!EQ (*minibuf
, Qlambda
)
2290 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2292 else if (EQ (*all_frames
, Qvisible
))
2294 else if (EQ (*all_frames
, make_number (0)))
2296 else if (FRAMEP (*all_frames
))
2298 else if (!EQ (*all_frames
, Qt
))
2303 /* Return the next or previous window of WINDOW in cyclic ordering
2304 of windows. NEXT_P non-zero means return the next window. See the
2305 documentation string of next-window for the meaning of MINIBUF and
2309 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2311 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2313 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2314 return the first window on the frame. */
2315 if (FRAMEP (all_frames
)
2316 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2317 return Fframe_first_window (all_frames
);
2323 /* Find WINDOW in the list of all windows. */
2324 list
= Fmemq (window
, window_list ());
2326 /* Scan forward from WINDOW to the end of the window list. */
2328 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2329 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2332 /* Scan from the start of the window list up to WINDOW. */
2334 for (list
= Vwindow_list
;
2335 CONSP (list
) && !EQ (XCAR (list
), window
);
2337 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2341 window
= XCAR (list
);
2345 Lisp_Object candidate
, list
;
2347 /* Scan through the list of windows for candidates. If there are
2348 candidate windows in front of WINDOW, the last one of these
2349 is the one we want. If there are candidates following WINDOW
2350 in the list, again the last one of these is the one we want. */
2352 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2354 if (EQ (XCAR (list
), window
))
2356 if (WINDOWP (candidate
))
2359 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2361 candidate
= XCAR (list
);
2364 if (WINDOWP (candidate
))
2372 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2373 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2374 WINDOW must be a live window and defaults to the selected one. The
2375 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2378 MINIBUF nil or omitted means consider the minibuffer window only if the
2379 minibuffer is active. MINIBUF t means consider the minibuffer window
2380 even if the minibuffer is not active. Any other value means do not
2381 consider the minibuffer window even if the minibuffer is active.
2383 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2384 plus the minibuffer window if specified by the MINIBUF argument. If the
2385 minibuffer counts, consider all windows on all frames that share that
2386 minibuffer too. The following non-nil values of ALL-FRAMES have special
2389 - t means consider all windows on all existing frames.
2391 - `visible' means consider all windows on all visible frames.
2393 - 0 (the number zero) means consider all windows on all visible and
2396 - A frame means consider all windows on that frame only.
2398 Anything else means consider all windows on WINDOW's frame and no
2401 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2402 `next-window' to iterate through the entire cycle of acceptable
2403 windows, eventually ending up back at the window you started with.
2404 `previous-window' traverses the same cycle, in the reverse order. */)
2405 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2407 return next_window (window
, minibuf
, all_frames
, 1);
2411 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2412 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2413 WINDOW must be a live window and defaults to the selected one. The
2414 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2417 MINIBUF nil or omitted means consider the minibuffer window only if the
2418 minibuffer is active. MINIBUF t means consider the minibuffer window
2419 even if the minibuffer is not active. Any other value means do not
2420 consider the minibuffer window even if the minibuffer is active.
2422 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2423 plus the minibuffer window if specified by the MINIBUF argument. If the
2424 minibuffer counts, consider all windows on all frames that share that
2425 minibuffer too. The following non-nil values of ALL-FRAMES have special
2428 - t means consider all windows on all existing frames.
2430 - `visible' means consider all windows on all visible frames.
2432 - 0 (the number zero) means consider all windows on all visible and
2435 - A frame means consider all windows on that frame only.
2437 Anything else means consider all windows on WINDOW's frame and no
2440 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2441 use `previous-window' to iterate through the entire cycle of
2442 acceptable windows, eventually ending up back at the window you
2443 started with. `next-window' traverses the same cycle, in the
2445 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2447 return next_window (window
, minibuf
, all_frames
, 0);
2451 /* Return a list of windows in cyclic ordering. Arguments are like
2452 for `next-window'. */
2455 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2457 Lisp_Object tail
, list
, rest
;
2459 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2462 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2463 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2464 list
= Fcons (XCAR (tail
), list
);
2466 /* Rotate the list to start with WINDOW. */
2467 list
= Fnreverse (list
);
2468 rest
= Fmemq (window
, list
);
2469 if (!NILP (rest
) && !EQ (rest
, list
))
2471 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2473 XSETCDR (tail
, Qnil
);
2474 list
= nconc2 (rest
, list
);
2480 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2481 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2482 FRAME nil or omitted means use the selected frame.
2483 WINDOW nil or omitted means use the window selected within FRAME.
2484 MINIBUF t means include the minibuffer window, even if it isn't active.
2485 MINIBUF nil or omitted means include the minibuffer window only
2487 MINIBUF neither nil nor t means never include the minibuffer window. */)
2488 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2491 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2492 CHECK_WINDOW (window
);
2494 frame
= selected_frame
;
2496 if (!EQ (frame
, XWINDOW (window
)->frame
))
2497 error ("Window is on a different frame");
2499 return window_list_1 (window
, minibuf
, frame
);
2503 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2504 doc
: /* Return a list of all live windows.
2505 WINDOW specifies the first window to list and defaults to the selected
2508 Optional argument MINIBUF nil or omitted means consider the minibuffer
2509 window only if the minibuffer is active. MINIBUF t means consider the
2510 minibuffer window even if the minibuffer is not active. Any other value
2511 means do not consider the minibuffer window even if the minibuffer is
2514 Optional argument ALL-FRAMES nil or omitted means consider all windows
2515 on WINDOW's frame, plus the minibuffer window if specified by the
2516 MINIBUF argument. If the minibuffer counts, consider all windows on all
2517 frames that share that minibuffer too. The following non-nil values of
2518 ALL-FRAMES have special meanings:
2520 - t means consider all windows on all existing frames.
2522 - `visible' means consider all windows on all visible frames.
2524 - 0 (the number zero) means consider all windows on all visible and
2527 - A frame means consider all windows on that frame only.
2529 Anything else means consider all windows on WINDOW's frame and no
2532 If WINDOW is not on the list of windows returned, some other window will
2533 be listed first but no error is signaled. */)
2534 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2536 return window_list_1 (window
, minibuf
, all_frames
);
2539 /* Look at all windows, performing an operation specified by TYPE
2541 If FRAMES is Qt, look at all frames;
2542 Qnil, look at just the selected frame;
2543 Qvisible, look at visible frames;
2544 a frame, just look at windows on that frame.
2545 If MINI is non-zero, perform the operation on minibuffer windows too. */
2550 GET_BUFFER_WINDOW
, /* Arg is buffer */
2551 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2552 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2553 CHECK_ALL_WINDOWS
/* Arg is ignored */
2557 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2559 Lisp_Object window
, windows
, best_window
, frame_arg
;
2560 int frame_best_window_flag
= 0;
2562 struct gcpro gcpro1
;
2564 /* If we're only looping through windows on a particular frame,
2565 frame points to that frame. If we're looping through windows
2566 on all frames, frame is 0. */
2567 if (FRAMEP (frames
))
2568 f
= XFRAME (frames
);
2569 else if (NILP (frames
))
2570 f
= SELECTED_FRAME ();
2575 frame_arg
= Qlambda
;
2576 else if (EQ (frames
, make_number (0)))
2578 else if (EQ (frames
, Qvisible
))
2583 /* frame_arg is Qlambda to stick to one frame,
2584 Qvisible to consider all visible frames,
2587 /* Pick a window to start with. */
2591 window
= FRAME_SELECTED_WINDOW (f
);
2593 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2595 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2599 for (; CONSP (windows
); windows
= XCDR (windows
))
2603 window
= XCAR (windows
);
2604 w
= XWINDOW (window
);
2606 /* Note that we do not pay attention here to whether the frame
2607 is visible, since Fwindow_list skips non-visible frames if
2608 that is desired, under the control of frame_arg. */
2609 if (!MINI_WINDOW_P (w
)
2610 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2611 consider all windows. */
2612 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2613 || (mini
&& minibuf_level
> 0))
2616 case GET_BUFFER_WINDOW
:
2617 if (EQ (w
->contents
, obj
)
2618 /* Don't find any minibuffer window except the one that
2619 is currently in use. */
2620 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2622 if (EQ (window
, selected_window
))
2623 /* Preferably return the selected window. */
2624 RETURN_UNGCPRO (window
);
2625 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2626 && !frame_best_window_flag
)
2627 /* Prefer windows on the current frame (but don't
2628 choose another one if we have one already). */
2630 best_window
= window
;
2631 frame_best_window_flag
= 1;
2633 else if (NILP (best_window
))
2634 best_window
= window
;
2638 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2639 /* We could simply check whether the buffer shown by window
2640 is live, and show another buffer in case it isn't. */
2641 if (EQ (w
->contents
, obj
))
2643 /* Undedicate WINDOW. */
2644 wset_dedicated (w
, Qnil
);
2645 /* Make WINDOW show the buffer returned by
2646 other_buffer_safely, don't run any hooks. */
2648 (window
, other_buffer_safely (w
->contents
), 0, 0);
2649 /* If WINDOW is the selected window, make its buffer
2650 current. But do so only if the window shows the
2651 current buffer (Bug#6454). */
2652 if (EQ (window
, selected_window
)
2653 && XBUFFER (w
->contents
) == current_buffer
)
2654 Fset_buffer (w
->contents
);
2658 case REDISPLAY_BUFFER_WINDOWS
:
2659 if (EQ (w
->contents
, obj
))
2661 mark_window_display_accurate (window
, 0);
2662 w
->update_mode_line
= 1;
2663 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2664 ++update_mode_lines
;
2665 best_window
= window
;
2669 /* Check for a leaf window that has a killed buffer
2670 or broken markers. */
2671 case CHECK_ALL_WINDOWS
:
2672 if (BUFFERP (w
->contents
))
2674 struct buffer
*b
= XBUFFER (w
->contents
);
2676 if (!BUFFER_LIVE_P (b
))
2678 if (!MARKERP (w
->start
) || XMARKER (w
->start
)->buffer
!= b
)
2680 if (!MARKERP (w
->pointm
) || XMARKER (w
->pointm
)->buffer
!= b
)
2685 case WINDOW_LOOP_UNUSED
:
2694 /* Used for debugging. Abort if any window has a dead buffer. */
2696 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2698 check_all_windows (void)
2700 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2703 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2704 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2705 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2708 The optional argument ALL-FRAMES specifies the frames to consider:
2710 - t means consider all windows on all existing frames.
2712 - `visible' means consider all windows on all visible frames.
2714 - 0 (the number zero) means consider all windows on all visible
2715 and iconified frames.
2717 - A frame means consider all windows on that frame only.
2719 Any other value of ALL-FRAMES means consider all windows on the
2720 selected frame and no others. */)
2721 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2725 if (NILP (buffer_or_name
))
2726 buffer
= Fcurrent_buffer ();
2728 buffer
= Fget_buffer (buffer_or_name
);
2730 if (BUFFERP (buffer
))
2731 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2737 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2739 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2743 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2744 Sdelete_other_windows_internal
, 0, 2, "",
2745 doc
: /* Make WINDOW fill its frame.
2746 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2747 and defaults to the selected one.
2749 Optional argument ROOT, if non-nil, must specify an internal window such
2750 that WINDOW is in its window subtree. If this is the case, replace ROOT
2751 by WINDOW and leave alone any windows not part of ROOT's subtree.
2753 When WINDOW is live try to reduce display jumps by keeping the text
2754 previously visible in WINDOW in the same place on the frame. Doing this
2755 depends on the value of (window-start WINDOW), so if calling this
2756 function in a program gives strange scrolling, make sure the
2757 window-start value is reasonable when this function is called. */)
2758 (Lisp_Object window
, Lisp_Object root
)
2760 struct window
*w
, *r
, *s
;
2762 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2763 ptrdiff_t startpos
IF_LINT (= 0), startbyte
IF_LINT (= 0);
2764 int top
IF_LINT (= 0), new_top
, resize_failed
;
2766 w
= decode_valid_window (window
);
2767 XSETWINDOW (window
, w
);
2768 f
= XFRAME (w
->frame
);
2771 /* ROOT is the frame's root window. */
2773 root
= FRAME_ROOT_WINDOW (f
);
2777 /* ROOT must be an ancestor of WINDOW. */
2779 r
= decode_valid_window (root
);
2780 pwindow
= XWINDOW (window
)->parent
;
2781 while (!NILP (pwindow
))
2782 if (EQ (pwindow
, root
))
2785 pwindow
= XWINDOW (pwindow
)->parent
;
2786 if (!EQ (pwindow
, root
))
2787 error ("Specified root is not an ancestor of specified window");
2790 if (EQ (window
, root
))
2793 /* I don't understand the "top > 0" part below. If we deal with a
2794 standalone minibuffer it would have been caught by the preceding
2796 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2797 error ("Can't expand minibuffer to full frame");
2799 if (BUFFERP (w
->contents
))
2801 startpos
= marker_position (w
->start
);
2802 startbyte
= marker_byte_position (w
->start
);
2803 top
= WINDOW_TOP_EDGE_LINE (w
)
2804 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2805 /* Make sure WINDOW is the frame's selected window. */
2806 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2808 if (EQ (selected_frame
, w
->frame
))
2809 Fselect_window (window
, Qnil
);
2811 fset_selected_window (f
, window
);
2816 /* See if the frame's selected window is a part of the window
2817 subtree rooted at WINDOW, by finding all the selected window's
2818 parents and comparing each one with WINDOW. If it isn't we
2819 need a new selected window for this frame. */
2820 swindow
= FRAME_SELECTED_WINDOW (f
);
2824 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2825 pwindow
= XWINDOW (pwindow
)->parent
;
2827 if (EQ (window
, pwindow
))
2828 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2829 as the new selected window. */
2832 /* Else try the previous window of SWINDOW. */
2833 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2836 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2838 if (EQ (selected_frame
, w
->frame
))
2839 Fselect_window (swindow
, Qnil
);
2841 fset_selected_window (f
, swindow
);
2846 if (!FRAME_INITIAL_P (f
))
2848 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2850 /* We are going to free the glyph matrices of WINDOW, and with
2851 that we might lose any information about glyph rows that have
2852 some of their glyphs highlighted in mouse face. (These rows
2853 are marked with a non-zero mouse_face_p flag.) If WINDOW
2854 indeed has some glyphs highlighted in mouse face, signal to
2855 frame's up-to-date hook that mouse highlight was overwritten,
2856 so that it will arrange for redisplaying the highlight. */
2857 if (EQ (hlinfo
->mouse_face_window
, window
))
2858 reset_mouse_highlight (hlinfo
);
2860 free_window_matrices (r
);
2862 windows_or_buffers_changed
++;
2863 Vwindow_list
= Qnil
;
2864 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2867 if (!WINDOW_LEAF_P (w
))
2869 /* Resize child windows vertically. */
2870 XSETINT (delta
, r
->total_lines
- w
->total_lines
);
2871 w
->top_line
= r
->top_line
;
2872 resize_root_window (window
, delta
, Qnil
, Qnil
);
2873 if (window_resize_check (w
, 0))
2874 window_resize_apply (w
, 0);
2877 resize_root_window (window
, delta
, Qnil
, Qt
);
2878 if (window_resize_check (w
, 0))
2879 window_resize_apply (w
, 0);
2884 /* Resize child windows horizontally. */
2887 w
->left_col
= r
->left_col
;
2888 XSETINT (delta
, r
->total_cols
- w
->total_cols
);
2889 resize_root_window (window
, delta
, Qt
, Qnil
);
2890 if (window_resize_check (w
, 1))
2891 window_resize_apply (w
, 1);
2894 resize_root_window (window
, delta
, Qt
, Qt
);
2895 if (window_resize_check (w
, 1))
2896 window_resize_apply (w
, 1);
2903 /* Play safe, if we still can ... */
2906 w
= XWINDOW (window
);
2910 /* Cleanly unlink WINDOW from window-tree. */
2911 if (!NILP (w
->prev
))
2912 /* Get SIBLING above (on the left of) WINDOW. */
2915 s
= XWINDOW (sibling
);
2916 wset_next (s
, w
->next
);
2917 if (!NILP (s
->next
))
2918 wset_prev (XWINDOW (s
->next
), sibling
);
2921 /* Get SIBLING below (on the right of) WINDOW. */
2924 s
= XWINDOW (sibling
);
2925 wset_prev (s
, Qnil
);
2926 wset_combination (XWINDOW (w
->parent
),
2927 XWINDOW (w
->parent
)->horizontal
, sibling
);
2930 /* Delete ROOT and all child windows of ROOT. */
2931 if (WINDOWP (r
->contents
))
2933 delete_all_child_windows (r
->contents
);
2934 wset_combination (r
, 0, Qnil
);
2937 replace_window (root
, window
, 1);
2939 /* This must become SWINDOW anyway ....... */
2940 if (BUFFERP (w
->contents
) && !resize_failed
)
2942 /* Try to minimize scrolling, by setting the window start to the
2943 point will cause the text at the old window start to be at the
2944 same place on the frame. But don't try to do this if the
2945 window start is outside the visible portion (as might happen
2946 when the display is not current, due to typeahead). */
2947 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2949 && startpos
>= BUF_BEGV (XBUFFER (w
->contents
))
2950 && startpos
<= BUF_ZV (XBUFFER (w
->contents
)))
2952 struct position pos
;
2953 struct buffer
*obuf
= current_buffer
;
2955 Fset_buffer (w
->contents
);
2956 /* This computation used to temporarily move point, but that
2957 can have unwanted side effects due to text properties. */
2958 pos
= *vmotion (startpos
, startbyte
, -top
, w
);
2960 set_marker_both (w
->start
, w
->contents
, pos
.bufpos
, pos
.bytepos
);
2961 w
->window_end_valid
= 0;
2962 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2963 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2964 /* We need to do this, so that the window-scroll-functions
2966 w
->optional_new_start
= 1;
2968 set_buffer_internal (obuf
);
2975 run_window_configuration_change_hook (f
);
2982 replace_buffer_in_windows (Lisp_Object buffer
)
2984 call1 (Qreplace_buffer_in_windows
, buffer
);
2987 /* If BUFFER is shown in a window, safely replace it with some other
2988 buffer in all windows of all frames, even those on other keyboards. */
2991 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2993 if (buffer_window_count (XBUFFER (buffer
)))
2995 Lisp_Object tail
, frame
;
2997 /* A single call to window_loop won't do the job because it only
2998 considers frames on the current keyboard. So loop manually over
2999 frames, and handle each one. */
3000 FOR_EACH_FRAME (tail
, frame
)
3001 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
3005 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
3006 minimum allowable size. */
3009 check_frame_size (struct frame
*frame
, int *rows
, int *cols
)
3011 /* For height, we have to see:
3012 how many windows the frame has at minimum (one or two),
3013 and whether it has a menu bar or other special stuff at the top. */
3015 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
3016 ? MIN_SAFE_WINDOW_HEIGHT
3017 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
3019 if (FRAME_TOP_MARGIN (frame
) > 0)
3020 min_height
+= FRAME_TOP_MARGIN (frame
);
3022 if (*rows
< min_height
)
3024 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
3025 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3028 /* Adjust the margins of window W if text area is too small.
3029 Return 1 if window width is ok after adjustment; 0 if window
3030 is still too narrow. */
3033 adjust_window_margins (struct window
*w
)
3035 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3036 - WINDOW_FRINGE_COLS (w
)
3037 - WINDOW_SCROLL_BAR_COLS (w
));
3038 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3039 + WINDOW_RIGHT_MARGIN_COLS (w
));
3041 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3044 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3047 /* Window's text area is too narrow, but reducing the window
3048 margins will fix that. */
3049 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3050 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3052 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3053 w
->left_margin_cols
= w
->right_margin_cols
= margin_cols
/ 2;
3055 w
->right_margin_cols
= margin_cols
;
3058 w
->left_margin_cols
= margin_cols
;
3062 /* The following three routines are needed for running a window's
3063 configuration change hook. */
3065 run_funs (Lisp_Object funs
)
3067 for (; CONSP (funs
); funs
= XCDR (funs
))
3068 if (!EQ (XCAR (funs
), Qt
))
3069 call0 (XCAR (funs
));
3073 select_window_norecord (Lisp_Object window
)
3075 if (WINDOW_LIVE_P (window
))
3076 Fselect_window (window
, Qt
);
3080 select_frame_norecord (Lisp_Object frame
)
3082 if (FRAME_LIVE_P (XFRAME (frame
)))
3083 Fselect_frame (frame
, Qt
);
3087 run_window_configuration_change_hook (struct frame
*f
)
3089 ptrdiff_t count
= SPECPDL_INDEX ();
3090 Lisp_Object frame
, global_wcch
3091 = Fdefault_value (Qwindow_configuration_change_hook
);
3092 XSETFRAME (frame
, f
);
3094 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3097 /* Use the right buffer. Matters when running the local hooks. */
3098 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3100 record_unwind_current_buffer ();
3101 Fset_buffer (Fwindow_buffer (Qnil
));
3104 if (SELECTED_FRAME () != f
)
3106 record_unwind_protect (select_frame_norecord
, selected_frame
);
3107 select_frame_norecord (frame
);
3110 /* Look for buffer-local values. */
3112 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3113 for (; CONSP (windows
); windows
= XCDR (windows
))
3115 Lisp_Object window
= XCAR (windows
);
3116 Lisp_Object buffer
= Fwindow_buffer (window
);
3117 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3120 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3121 record_unwind_protect (select_window_norecord
, selected_window
);
3122 select_window_norecord (window
);
3123 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3125 unbind_to (inner_count
, Qnil
);
3130 run_funs (global_wcch
);
3131 unbind_to (count
, Qnil
);
3134 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3135 Srun_window_configuration_change_hook
, 0, 1, 0,
3136 doc
: /* Run `window-configuration-change-hook' for FRAME.
3137 If FRAME is omitted or nil, it defaults to the selected frame. */)
3140 run_window_configuration_change_hook (decode_live_frame (frame
));
3144 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3145 means it's allowed to run hooks. See make_frame for a case where
3146 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3147 margins, fringes, and scroll-bar settings of the window are not
3148 reset from the buffer's local settings. */
3151 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
,
3152 bool run_hooks_p
, bool keep_margins_p
)
3154 struct window
*w
= XWINDOW (window
);
3155 struct buffer
*b
= XBUFFER (buffer
);
3156 ptrdiff_t count
= SPECPDL_INDEX ();
3157 int samebuf
= EQ (buffer
, w
->contents
);
3159 wset_buffer (w
, buffer
);
3161 if (EQ (window
, selected_window
))
3162 bset_last_selected_window (b
, window
);
3164 /* Let redisplay errors through. */
3165 b
->display_error_modiff
= 0;
3167 /* Update time stamps of buffer display. */
3168 if (INTEGERP (BVAR (b
, display_count
)))
3169 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3170 bset_display_time (b
, Fcurrent_time ());
3172 w
->window_end_pos
= 0;
3173 w
->window_end_vpos
= 0;
3174 w
->last_cursor_vpos
= 0;
3176 if (!(keep_margins_p
&& samebuf
))
3177 { /* If we're not actually changing the buffer, don't reset hscroll and
3178 vscroll. This case happens for example when called from
3179 change_frame_size_1, where we use a dummy call to
3180 Fset_window_buffer on the frame's selected window (and no other)
3181 just in order to run window-configuration-change-hook.
3182 Resetting hscroll and vscroll here is problematic for things like
3183 image-mode and doc-view-mode since it resets the image's position
3184 whenever we resize the frame. */
3185 w
->hscroll
= w
->min_hscroll
= 0;
3187 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3188 set_marker_restricted (w
->start
,
3189 make_number (b
->last_window_start
),
3191 w
->start_at_line_beg
= 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. */
3212 set_window_fringes (w
, BVAR (b
, left_fringe_width
),
3213 BVAR (b
, right_fringe_width
),
3214 BVAR (b
, fringes_outside_margins
));
3215 set_window_scroll_bars (w
, BVAR (b
, scroll_bar_width
),
3216 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3217 set_window_margins (w
, BVAR (b
, left_margin_cols
),
3218 BVAR (b
, right_margin_cols
));
3219 apply_window_adjustment (w
);
3224 if (! NILP (Vwindow_scroll_functions
))
3225 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3226 Fmarker_position (w
->start
));
3227 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3230 unbind_to (count
, Qnil
);
3233 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3234 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3235 WINDOW must be a live window and defaults to the selected one.
3236 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3238 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3239 display margins, fringe widths, and scroll bar settings are preserved;
3240 the default is to reset these from the local settings for BUFFER-OR-NAME
3241 or the frame defaults. Return nil.
3243 This function throws an error when WINDOW is strongly dedicated to its
3244 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3245 already display BUFFER-OR-NAME.
3247 This function runs `window-scroll-functions' before running
3248 `window-configuration-change-hook'. */)
3249 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3251 register Lisp_Object tem
, buffer
;
3252 register struct window
*w
= decode_live_window (window
);
3254 XSETWINDOW (window
, w
);
3255 buffer
= Fget_buffer (buffer_or_name
);
3256 CHECK_BUFFER (buffer
);
3257 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3258 error ("Attempt to display deleted buffer");
3262 error ("Window is deleted");
3265 if (!EQ (tem
, buffer
))
3267 if (EQ (w
->dedicated
, Qt
))
3268 /* WINDOW is strongly dedicated to its buffer, signal an
3270 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3272 /* WINDOW is weakly dedicated to its buffer, reset
3274 wset_dedicated (w
, Qnil
);
3276 call1 (Qrecord_window_buffer
, window
);
3282 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3288 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3290 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3293 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3295 doc
: /* Force all windows to be updated on next redisplay.
3296 If optional arg OBJECT is a window, force redisplay of that window only.
3297 If OBJECT is a buffer or buffer name, force redisplay of all windows
3298 displaying that buffer. */)
3299 (Lisp_Object object
)
3303 windows_or_buffers_changed
++;
3304 update_mode_lines
++;
3308 if (WINDOWP (object
))
3310 struct window
*w
= XWINDOW (object
);
3311 mark_window_display_accurate (object
, 0);
3312 w
->update_mode_line
= 1;
3313 if (BUFFERP (w
->contents
))
3314 XBUFFER (w
->contents
)->prevent_redisplay_optimizations_p
= 1;
3315 ++update_mode_lines
;
3319 if (STRINGP (object
))
3320 object
= Fget_buffer (object
);
3321 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
))
3322 && buffer_window_count (XBUFFER (object
)))
3324 /* If buffer is live and shown in at least one window, find
3325 all windows showing this buffer and force update of them. */
3326 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3327 return NILP (object
) ? Qnil
: Qt
;
3330 /* If nothing suitable was found, just return.
3331 We could signal an error, but this feature will typically be used
3332 asynchronously in timers or process sentinels, so we don't. */
3336 /* Obsolete since 24.3. */
3338 temp_output_buffer_show (register Lisp_Object buf
)
3340 register struct buffer
*old
= current_buffer
;
3341 register Lisp_Object window
;
3342 register struct window
*w
;
3344 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3347 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3351 set_buffer_internal (old
);
3353 if (!NILP (Vtemp_buffer_show_function
))
3354 call1 (Vtemp_buffer_show_function
, buf
);
3357 window
= display_buffer (buf
, Qnil
, Qnil
);
3359 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3360 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3361 Vminibuf_scroll_window
= window
;
3362 w
= XWINDOW (window
);
3365 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3366 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3368 /* Run temp-buffer-show-hook, with the chosen window selected
3369 and its buffer current. */
3371 ptrdiff_t count
= SPECPDL_INDEX ();
3372 Lisp_Object prev_window
, prev_buffer
;
3373 prev_window
= selected_window
;
3374 XSETBUFFER (prev_buffer
, old
);
3376 /* Select the window that was chosen, for running the hook.
3377 Note: Both Fselect_window and select_window_norecord may
3378 set-buffer to the buffer displayed in the window,
3379 so we need to save the current buffer. --stef */
3380 record_unwind_protect (restore_buffer
, prev_buffer
);
3381 record_unwind_protect (select_window_norecord
, prev_window
);
3382 Fselect_window (window
, Qt
);
3383 Fset_buffer (w
->contents
);
3384 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3385 unbind_to (count
, Qnil
);
3390 /* Make new window, have it replace WINDOW in window-tree, and make
3391 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3392 horizontal child). */
3394 make_parent_window (Lisp_Object window
, bool horflag
)
3397 register struct window
*o
, *p
;
3399 o
= XWINDOW (window
);
3400 p
= allocate_window ();
3401 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3402 (char *) o
+ sizeof (struct vectorlike_header
),
3403 word_size
* VECSIZE (struct window
));
3404 /* P's buffer slot may change from nil to a buffer... */
3405 adjust_window_count (p
, 1);
3406 XSETWINDOW (parent
, p
);
3408 replace_window (window
, parent
, 1);
3410 wset_next (o
, Qnil
);
3411 wset_prev (o
, Qnil
);
3412 wset_parent (o
, parent
);
3413 /* ...but now P becomes an internal window. */
3414 wset_start (p
, Qnil
);
3415 wset_pointm (p
, Qnil
);
3416 wset_buffer (p
, Qnil
);
3417 wset_combination (p
, horflag
, window
);
3418 wset_combination_limit (p
, Qnil
);
3419 wset_window_parameters (p
, Qnil
);
3422 /* Make new window from scratch. */
3427 register struct window
*w
;
3429 w
= allocate_window ();
3430 /* Initialize Lisp data. Note that allocate_window initializes all
3431 Lisp data to nil, so do it only for slots which should not be nil. */
3432 wset_normal_lines (w
, make_float (1.0));
3433 wset_normal_cols (w
, make_float (1.0));
3434 wset_new_total (w
, make_number (0));
3435 wset_new_normal (w
, make_number (0));
3436 wset_start (w
, Fmake_marker ());
3437 wset_pointm (w
, Fmake_marker ());
3438 wset_vertical_scroll_bar_type (w
, Qt
);
3439 /* These Lisp fields are marked specially so they're not set to nil by
3441 wset_prev_buffers (w
, Qnil
);
3442 wset_next_buffers (w
, Qnil
);
3444 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3445 non-Lisp data, so do it only for slots which should not be zero. */
3446 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3447 w
->left_fringe_width
= w
->right_fringe_width
= -1;
3448 w
->phys_cursor_type
= -1;
3449 w
->phys_cursor_width
= -1;
3450 w
->scroll_bar_width
= -1;
3451 w
->column_number_displayed
= -1;
3453 /* Reset window_list. */
3454 Vwindow_list
= Qnil
;
3455 /* Return window. */
3456 XSETWINDOW (window
, w
);
3460 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3461 doc
: /* Set new total size of WINDOW to SIZE.
3462 WINDOW must be a valid window and defaults to the selected one.
3465 Optional argument ADD non-nil means add SIZE to the new total size of
3466 WINDOW and return the sum.
3468 Note: This function does not operate on any child windows of WINDOW. */)
3469 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3471 struct window
*w
= decode_valid_window (window
);
3473 CHECK_NUMBER (size
);
3475 wset_new_total (w
, size
);
3477 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3479 return w
->new_total
;
3482 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3483 doc
: /* Set new normal size of WINDOW to SIZE.
3484 WINDOW must be a valid window and defaults to the selected one.
3487 Note: This function does not operate on any child windows of WINDOW. */)
3488 (Lisp_Object window
, Lisp_Object size
)
3490 wset_new_normal (decode_valid_window (window
), size
);
3494 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3495 non-zero) to w->new_total would result in correct heights (widths)
3496 for window W and recursively all child windows of W.
3498 Note: This function does not check any of `window-fixed-size-p',
3499 `window-min-height' or `window-min-width'. It does check that window
3500 sizes do not drop below one line (two columns). */
3502 window_resize_check (struct window
*w
, bool horflag
)
3506 if (WINDOW_VERTICAL_COMBINATION_P (w
))
3507 /* W is a vertical combination. */
3509 c
= XWINDOW (w
->contents
);
3511 /* All child windows of W must have the same width as W. */
3515 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3516 || !window_resize_check (c
, horflag
))
3518 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3523 /* The sum of the heights of the child windows of W must equal
3526 int sum_of_sizes
= 0;
3529 if (!window_resize_check (c
, horflag
))
3531 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3532 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3534 return (sum_of_sizes
== XINT (w
->new_total
));
3537 else if (WINDOW_HORIZONTAL_COMBINATION_P (w
))
3538 /* W is a horizontal combination. */
3540 c
= XWINDOW (w
->contents
);
3542 /* The sum of the widths of the child windows of W must equal W's
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 /* All child windows of W must have the same height as W. */
3560 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3561 || !window_resize_check (c
, horflag
))
3563 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3569 /* A leaf window. Make sure it's not too small. The following
3570 hardcodes the values of `window-safe-min-width' (2) and
3571 `window-safe-min-height' (1) which are defined in window.el. */
3572 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3575 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3576 w->new_total for window W and recursively all child windows of W.
3577 Also calculate and assign the new vertical (horizontal) start
3578 positions of each of these windows.
3580 This function does not perform any error checks. Make sure you have
3581 run window_resize_check on W before applying this function. */
3583 window_resize_apply (struct window
*w
, bool horflag
)
3588 /* Note: Assigning new_normal requires that the new total size of the
3589 parent window has been set *before*. */
3592 w
->total_cols
= XFASTINT (w
->new_total
);
3593 if (NUMBERP (w
->new_normal
))
3594 wset_normal_cols (w
, w
->new_normal
);
3600 w
->total_lines
= XFASTINT (w
->new_total
);
3601 if (NUMBERP (w
->new_normal
))
3602 wset_normal_lines (w
, w
->new_normal
);
3607 if (WINDOW_VERTICAL_COMBINATION_P (w
))
3608 /* W is a vertical combination. */
3610 c
= XWINDOW (w
->contents
);
3617 window_resize_apply (c
, horflag
);
3619 pos
= pos
+ c
->total_lines
;
3620 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3623 else if (WINDOW_HORIZONTAL_COMBINATION_P (w
))
3624 /* W is a horizontal combination. */
3626 c
= XWINDOW (w
->contents
);
3633 window_resize_apply (c
, horflag
);
3635 pos
= pos
+ c
->total_cols
;
3636 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3642 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3643 doc
: /* Apply requested size values for window-tree of FRAME.
3644 If FRAME is omitted or nil, it defaults to the selected frame.
3646 Optional argument HORIZONTAL omitted or nil means apply requested
3647 height values. HORIZONTAL non-nil means apply requested width values.
3649 This function checks whether the requested values sum up to a valid
3650 window layout, recursively assigns the new sizes of all child windows
3651 and calculates and assigns the new start positions of these windows.
3653 Note: This function does not check any of `window-fixed-size-p',
3654 `window-min-height' or `window-min-width'. All these checks have to
3655 be applied on the Elisp level. */)
3656 (Lisp_Object frame
, Lisp_Object horizontal
)
3658 struct frame
*f
= decode_live_frame (frame
);
3659 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3660 bool horflag
= !NILP (horizontal
);
3662 if (!window_resize_check (r
, horflag
)
3663 || (XINT (r
->new_total
)
3664 != (horflag
? r
->total_cols
: r
->total_lines
)))
3668 window_resize_apply (r
, horflag
);
3670 windows_or_buffers_changed
++;
3671 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3676 run_window_configuration_change_hook (f
);
3682 /* Resize frame F's windows when number of lines of F is set to SIZE.
3683 HORFLAG 1 means resize windows when number of columns of F is set to
3686 This function can delete all windows but the selected one in order to
3687 satisfy the request. The result will be meaningful if and only if
3688 F's windows have meaningful sizes when you call this. */
3690 resize_frame_windows (struct frame
*f
, int size
, bool horflag
)
3692 Lisp_Object root
= f
->root_window
;
3693 struct window
*r
= XWINDOW (root
);
3694 Lisp_Object mini
= f
->minibuffer_window
;
3696 /* new_size is the new size of the frame's root window. */
3697 int new_size
= (horflag
3700 - FRAME_TOP_MARGIN (f
)
3701 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3704 r
->top_line
= FRAME_TOP_MARGIN (f
);
3705 if (WINDOW_LEAF_P (r
))
3706 /* For a leaf root window just set the size. */
3708 r
->total_cols
= new_size
;
3710 r
->total_lines
= new_size
;
3713 /* old_size is the old size of the frame's root window. */
3714 int old_size
= horflag
? r
->total_cols
: r
->total_lines
;
3717 XSETINT (delta
, new_size
- old_size
);
3718 /* Try a "normal" resize first. */
3719 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3720 if (window_resize_check (r
, horflag
)
3721 && new_size
== XINT (r
->new_total
))
3722 window_resize_apply (r
, horflag
);
3725 /* Try with "reasonable" minimum sizes next. */
3726 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3727 if (window_resize_check (r
, horflag
)
3728 && new_size
== XINT (r
->new_total
))
3729 window_resize_apply (r
, horflag
);
3732 /* Finally, try with "safe" minimum sizes. */
3733 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3734 if (window_resize_check (r
, horflag
)
3735 && new_size
== XINT (r
->new_total
))
3736 window_resize_apply (r
, horflag
);
3739 /* We lost. Delete all windows but the frame's
3741 root
= f
->selected_window
;
3742 Fdelete_other_windows_internal (root
, Qnil
);
3744 XWINDOW (root
)->total_cols
= new_size
;
3746 XWINDOW (root
)->total_lines
= new_size
;
3752 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3756 m
->total_cols
= size
;
3759 /* Are we sure we always want 1 line here? */
3761 m
->top_line
= r
->top_line
+ r
->total_lines
;
3765 windows_or_buffers_changed
++;
3769 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3770 doc
: /* Split window OLD.
3771 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3772 new window. In any case TOTAL-SIZE must be a positive integer.
3774 Third argument SIDE nil (or `below') specifies that the new window shall
3775 be located below WINDOW. SIDE `above' means the new window shall be
3776 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3777 lines of the new window including space reserved for the mode and/or
3780 SIDE t (or `right') specifies that the new window shall be located on
3781 the right side of WINDOW. SIDE `left' means the new window shall be
3782 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3783 number of columns of the new window including space reserved for fringes
3784 and the scrollbar or a divider column.
3786 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3787 according to the SIDE argument.
3789 The new total and normal sizes of all involved windows must have been
3790 set correctly. See the code of `split-window' for how this is done. */)
3791 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3793 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3794 parent window or an internal window we have to install as OLD's new
3795 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3796 provided OLD is a leaf window, or to the frame's selected window.
3797 NEW (*n) is the new window created with some parameters taken from
3799 register Lisp_Object
new, frame
, reference
;
3800 register struct window
*o
, *p
, *n
, *r
;
3803 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3804 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3805 int combination_limit
= 0;
3809 frame
= WINDOW_FRAME (o
);
3812 CHECK_NUMBER (total_size
);
3814 /* Set combination_limit to 1 if we have to make a new parent window.
3815 We do that if either `window-combination-limit' is t, or OLD has no
3816 parent, or OLD is ortho-combined. */
3818 EQ (Vwindow_combination_limit
, Qt
)
3821 ? WINDOW_VERTICAL_COMBINATION_P (XWINDOW (o
->parent
))
3822 : WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (o
->parent
)));
3824 /* We need a live reference window to initialize some parameters. */
3825 if (WINDOW_LIVE_P (old
))
3826 /* OLD is live, use it as reference window. */
3829 /* Use the frame's selected window as reference window. */
3830 reference
= FRAME_SELECTED_WINDOW (f
);
3831 r
= XWINDOW (reference
);
3833 /* The following bugs are caught by `split-window'. */
3834 if (MINI_WINDOW_P (o
))
3835 error ("Attempt to split minibuffer window");
3836 else if (XINT (total_size
) < (horflag
? 2 : 1))
3837 error ("Size of new window too small (after split)");
3838 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3839 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3842 p
= XWINDOW (o
->parent
);
3843 /* Temporarily pretend we split the parent window. */
3845 (p
, make_number ((horflag
? p
->total_cols
: p
->total_lines
)
3846 - XINT (total_size
)));
3847 if (!window_resize_check (p
, horflag
))
3848 error ("Window sizes don't fit");
3850 /* Undo the temporary pretension. */
3851 wset_new_total (p
, make_number
3852 (horflag
? p
->total_cols
: p
->total_lines
));
3856 if (!window_resize_check (o
, horflag
))
3857 error ("Resizing old window failed");
3858 else if (XINT (total_size
) + XINT (o
->new_total
)
3859 != (horflag
? o
->total_cols
: o
->total_lines
))
3860 error ("Sum of sizes of old and new window don't fit");
3863 /* This is our point of no return. */
3864 if (combination_limit
)
3866 /* Save the old value of o->normal_cols/lines. It gets corrupted
3867 by make_parent_window and we need it below for assigning it to
3869 Lisp_Object new_normal
3870 = horflag
? o
->normal_cols
: o
->normal_lines
;
3872 make_parent_window (old
, horflag
);
3873 p
= XWINDOW (o
->parent
);
3874 if (EQ (Vwindow_combination_limit
, Qt
))
3875 /* Store t in the new parent's combination_limit slot to avoid
3876 that its children get merged into another window. */
3877 wset_combination_limit (p
, Qt
);
3878 /* These get applied below. */
3879 wset_new_total (p
, make_number
3880 (horflag
? o
->total_cols
: o
->total_lines
));
3881 wset_new_normal (p
, new_normal
);
3884 p
= XWINDOW (o
->parent
);
3886 windows_or_buffers_changed
++;
3887 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3888 new = make_window ();
3890 wset_frame (n
, frame
);
3891 wset_parent (n
, o
->parent
);
3893 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3895 wset_prev (n
, o
->prev
);
3897 wset_combination (p
, horflag
, new);
3899 wset_next (XWINDOW (n
->prev
), new);
3905 wset_next (n
, o
->next
);
3906 if (!NILP (n
->next
))
3907 wset_prev (XWINDOW (n
->next
), new);
3912 n
->window_end_valid
= 0;
3913 n
->last_cursor_vpos
= 0;
3915 /* Get special geometry settings from reference window. */
3916 n
->left_margin_cols
= r
->left_margin_cols
;
3917 n
->right_margin_cols
= r
->right_margin_cols
;
3918 n
->left_fringe_width
= r
->left_fringe_width
;
3919 n
->right_fringe_width
= r
->right_fringe_width
;
3920 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3921 n
->scroll_bar_width
= r
->scroll_bar_width
;
3922 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3924 /* Directly assign orthogonal coordinates and sizes. */
3927 n
->top_line
= o
->top_line
;
3928 n
->total_lines
= o
->total_lines
;
3932 n
->left_col
= o
->left_col
;
3933 n
->total_cols
= o
->total_cols
;
3936 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3937 get them ready here. */
3938 wset_new_total (n
, total_size
);
3939 wset_new_normal (n
, normal_size
);
3942 window_resize_apply (p
, horflag
);
3944 /* Set buffer of NEW to buffer of reference window. Don't run
3946 set_window_buffer (new, r
->contents
, 0, 1);
3949 /* Maybe we should run the scroll functions in Elisp (which already
3950 runs the configuration change hook). */
3951 if (! NILP (Vwindow_scroll_functions
))
3952 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3953 Fmarker_position (n
->start
));
3959 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3960 doc
: /* Remove WINDOW from its frame.
3961 WINDOW defaults to the selected window. Return nil.
3962 Signal an error when WINDOW is the only window on its frame. */)
3963 (register Lisp_Object window
)
3965 register Lisp_Object parent
, sibling
, frame
, root
;
3966 struct window
*w
, *p
, *s
, *r
;
3968 bool horflag
, before_sibling
= 0;
3970 w
= decode_any_window (window
);
3971 XSETWINDOW (window
, w
);
3972 if (NILP (w
->contents
))
3973 /* It's a no-op to delete an already deleted window. */
3978 /* Never delete a minibuffer or frame root window. */
3979 error ("Attempt to delete minibuffer or sole ordinary window");
3980 else if (NILP (w
->prev
) && NILP (w
->next
))
3981 /* Rather bow out here, this case should be handled on the Elisp
3983 error ("Attempt to delete sole window of parent");
3985 p
= XWINDOW (parent
);
3986 horflag
= WINDOW_HORIZONTAL_COMBINATION_P (p
);
3988 frame
= WINDOW_FRAME (w
);
3991 root
= FRAME_ROOT_WINDOW (f
);
3994 /* Unlink WINDOW from window tree. */
3996 /* Get SIBLING below (on the right of) WINDOW. */
3998 /* before_sibling 1 means WINDOW is the first child of its
3999 parent and thus before the sibling. */
4002 s
= XWINDOW (sibling
);
4003 wset_prev (s
, Qnil
);
4004 wset_combination (p
, horflag
, sibling
);
4007 /* Get SIBLING above (on the left of) WINDOW. */
4010 s
= XWINDOW (sibling
);
4011 wset_next (s
, w
->next
);
4012 if (!NILP (s
->next
))
4013 wset_prev (XWINDOW (s
->next
), sibling
);
4016 if (window_resize_check (r
, horflag
)
4017 && (XINT (r
->new_total
)
4018 == (horflag
? r
->total_cols
: r
->total_lines
)))
4019 /* We can delete WINDOW now. */
4024 #ifdef HAVE_XWIDGETS
4025 xwidget_view_delete_all_in_window(w
);
4027 window_resize_apply (p
, horflag
);
4029 /* If this window is referred to by the dpyinfo's mouse
4030 highlight, invalidate that slot to be safe (Bug#9904). */
4031 if (!FRAME_INITIAL_P (f
))
4033 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4035 if (EQ (hlinfo
->mouse_face_window
, window
))
4036 hlinfo
->mouse_face_window
= Qnil
;
4039 windows_or_buffers_changed
++;
4040 Vwindow_list
= Qnil
;
4041 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4043 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4044 free_window_matrices (w
);
4046 if (WINDOWP (w
->contents
))
4048 delete_all_child_windows (w
->contents
);
4049 wset_combination (w
, 0, Qnil
);
4054 unchain_marker (XMARKER (w
->pointm
));
4055 unchain_marker (XMARKER (w
->start
));
4056 wset_buffer (w
, Qnil
);
4059 if (NILP (s
->prev
) && NILP (s
->next
))
4060 /* A matrjoshka where SIBLING has become the only child of
4063 /* Put SIBLING into PARENT's place. */
4064 replace_window (parent
, sibling
, 0);
4065 /* Have SIBLING inherit the following three slot values from
4066 PARENT (the combination_limit slot is not inherited). */
4067 wset_normal_cols (s
, p
->normal_cols
);
4068 wset_normal_lines (s
, p
->normal_lines
);
4069 /* Mark PARENT as deleted. */
4070 wset_combination (p
, 0, Qnil
);
4071 /* Try to merge SIBLING into its new parent. */
4072 recombine_windows (sibling
);
4077 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4078 /* We deleted the frame's selected window. */
4080 /* Use the frame's first window as fallback ... */
4081 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4082 /* ... but preferably use its most recently used window. */
4083 Lisp_Object mru_window
;
4085 /* `get-mru-window' might fail for some reason so play it safe
4086 - promote the first window _without recording it_ first. */
4087 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4088 Fselect_window (new_selected_window
, Qt
);
4090 fset_selected_window (f
, new_selected_window
);
4094 /* Now look whether `get-mru-window' gets us something. */
4095 mru_window
= call1 (Qget_mru_window
, frame
);
4096 if (WINDOW_LIVE_P (mru_window
)
4097 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4098 new_selected_window
= mru_window
;
4100 /* If all ended up well, we now promote the mru window. */
4101 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4102 Fselect_window (new_selected_window
, Qnil
);
4104 fset_selected_window (f
, new_selected_window
);
4109 /* Must be run by the caller:
4110 run_window_configuration_change_hook (f); */
4113 /* We failed: Relink WINDOW into window tree. */
4117 wset_prev (s
, window
);
4118 wset_combination (p
, horflag
, window
);
4122 wset_next (s
, window
);
4123 if (!NILP (w
->next
))
4124 wset_prev (XWINDOW (w
->next
), window
);
4126 error ("Deletion failed");
4132 /***********************************************************************
4133 Resizing Mini-Windows
4134 ***********************************************************************/
4136 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4139 grow_mini_window (struct window
*w
, int delta
)
4141 struct frame
*f
= XFRAME (w
->frame
);
4143 Lisp_Object root
, value
;
4145 eassert (MINI_WINDOW_P (w
));
4146 eassert (delta
>= 0);
4148 root
= FRAME_ROOT_WINDOW (f
);
4150 value
= call2 (Qwindow_resize_root_window_vertically
,
4151 root
, make_number (- delta
));
4152 if (INTEGERP (value
) && window_resize_check (r
, 0))
4155 window_resize_apply (r
, 0);
4157 /* Grow the mini-window. */
4158 w
->top_line
= r
->top_line
+ r
->total_lines
;
4159 w
->total_lines
-= XINT (value
);
4160 /* Enforce full redisplay. FIXME: make it more selective. */
4161 windows_or_buffers_changed
++;
4168 /* Shrink mini-window W. */
4170 shrink_mini_window (struct window
*w
)
4172 struct frame
*f
= XFRAME (w
->frame
);
4174 Lisp_Object root
, value
;
4177 eassert (MINI_WINDOW_P (w
));
4179 size
= w
->total_lines
;
4182 root
= FRAME_ROOT_WINDOW (f
);
4184 value
= call2 (Qwindow_resize_root_window_vertically
,
4185 root
, make_number (size
- 1));
4186 if (INTEGERP (value
) && window_resize_check (r
, 0))
4189 window_resize_apply (r
, 0);
4191 /* Shrink the mini-window. */
4192 w
->top_line
= r
->top_line
+ r
->total_lines
;
4194 /* Enforce full redisplay. FIXME: make it more selective. */
4195 windows_or_buffers_changed
++;
4199 /* If the above failed for whatever strange reason we must make a
4200 one window frame here. The same routine will be needed when
4201 shrinking the frame (and probably when making the initial
4202 *scratch* window). For the moment leave things as they are. */
4206 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4207 doc
: /* Resize minibuffer window WINDOW. */)
4208 (Lisp_Object window
)
4210 struct window
*w
= XWINDOW (window
);
4215 CHECK_WINDOW (window
);
4216 f
= XFRAME (w
->frame
);
4218 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4219 error ("Not a valid minibuffer window");
4220 else if (FRAME_MINIBUF_ONLY_P (f
))
4221 error ("Cannot resize a minibuffer-only frame");
4223 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4224 height
= r
->total_lines
+ w
->total_lines
;
4225 if (window_resize_check (r
, 0)
4226 && XINT (w
->new_total
) > 0
4227 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4230 window_resize_apply (r
, 0);
4232 w
->total_lines
= XFASTINT (w
->new_total
);
4233 w
->top_line
= r
->top_line
+ r
->total_lines
;
4235 windows_or_buffers_changed
++;
4236 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4240 run_window_configuration_change_hook (f
);
4243 else error ("Failed to resize minibuffer window");
4246 /* Mark window cursors off for all windows in the window tree rooted
4247 at W by setting their phys_cursor_on_p flag to zero. Called from
4248 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4249 the frame are cleared. */
4252 mark_window_cursors_off (struct window
*w
)
4256 if (WINDOWP (w
->contents
))
4257 mark_window_cursors_off (XWINDOW (w
->contents
));
4259 w
->phys_cursor_on_p
= 0;
4261 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4266 /* Return number of lines of text (not counting mode lines) in W. */
4269 window_internal_height (struct window
*w
)
4271 int ht
= w
->total_lines
;
4273 if (!MINI_WINDOW_P (w
))
4275 if (!NILP (w
->parent
)
4276 || WINDOWP (w
->contents
)
4279 || WINDOW_WANTS_MODELINE_P (w
))
4282 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4289 /************************************************************************
4291 ***********************************************************************/
4293 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4294 N screen-fulls, which is defined as the height of the window minus
4295 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4296 instead. Negative values of N mean scroll down. NOERROR non-zero
4297 means don't signal an error if we try to move over BEGV or ZV,
4301 window_scroll (Lisp_Object window
, EMACS_INT n
, bool whole
, int noerror
)
4304 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4306 /* If we must, use the pixel-based version which is much slower than
4307 the line-based one but can handle varying line heights. */
4308 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4309 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4311 window_scroll_line_based (window
, n
, whole
, noerror
);
4317 /* Implementation of window_scroll that works based on pixel line
4318 heights. See the comment of window_scroll for parameter
4322 window_scroll_pixel_based (Lisp_Object window
, int n
, bool whole
, int noerror
)
4325 struct window
*w
= XWINDOW (window
);
4326 struct text_pos start
;
4327 int this_scroll_margin
;
4328 /* True if we fiddled the window vscroll field without really scrolling. */
4330 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4331 void *itdata
= NULL
;
4332 int window_total_lines
;
4333 int frame_line_height
= default_line_pixel_height (w
);
4335 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4336 /* Scrolling a minibuffer window via scroll bar when the echo area
4337 shows long text sometimes resets the minibuffer contents behind
4339 if (CHARPOS (start
) > ZV
)
4340 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4342 /* If PT is not visible in WINDOW, move back one half of
4343 the screen. Allow PT to be partially visible, otherwise
4344 something like (scroll-down 1) with PT in the line before
4345 the partially visible one would recenter. */
4347 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4349 itdata
= bidi_shelve_cache ();
4350 /* Move backward half the height of the window. Performance note:
4351 vmotion used here is about 10% faster, but would give wrong
4352 results for variable height lines. */
4353 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4354 it
.current_y
= it
.last_visible_y
;
4355 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4357 /* The function move_iterator_vertically may move over more than
4358 the specified y-distance. If it->w is small, e.g. a
4359 mini-buffer window, we may end up in front of the window's
4360 display area. This is the case when Start displaying at the
4361 start of the line containing PT in this case. */
4362 if (it
.current_y
<= 0)
4364 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4365 move_it_vertically_backward (&it
, 0);
4369 start
= it
.current
.pos
;
4370 bidi_unshelve_cache (itdata
, 0);
4372 else if (auto_window_vscroll_p
)
4374 if (rtop
|| rbot
) /* partially visible */
4377 int dy
= frame_line_height
;
4379 dy
= max ((window_box_height (w
)
4380 - next_screen_context_lines
* dy
),
4386 /* Only vscroll backwards if already vscrolled forwards. */
4387 if (w
->vscroll
< 0 && rtop
> 0)
4389 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4390 Fset_window_vscroll (window
, make_number (px
), Qt
);
4396 /* Do vscroll if already vscrolled or only display line. */
4397 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4399 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4400 Fset_window_vscroll (window
, make_number (px
), Qt
);
4404 /* Maybe modify window start instead of scrolling. */
4405 if (rbot
> 0 || w
->vscroll
< 0)
4409 Fset_window_vscroll (window
, make_number (0), Qt
);
4410 /* If there are other text lines above the current row,
4411 move window start to current row. Else to next row. */
4413 spos
= XINT (Fline_beginning_position (Qnil
));
4415 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4416 set_marker_restricted (w
->start
, make_number (spos
),
4418 w
->start_at_line_beg
= 1;
4419 w
->update_mode_line
= 1;
4420 /* Set force_start so that redisplay_window will run the
4421 window-scroll-functions. */
4427 /* Cancel previous vscroll. */
4428 Fset_window_vscroll (window
, make_number (0), Qt
);
4431 itdata
= bidi_shelve_cache ();
4432 /* If scroll_preserve_screen_position is non-nil, we try to set
4433 point in the same window line as it is now, so get that line. */
4434 if (!NILP (Vscroll_preserve_screen_position
))
4436 /* We preserve the goal pixel coordinate across consecutive
4437 calls to scroll-up, scroll-down and other commands that
4438 have the `scroll-command' property. This avoids the
4439 possibility of point becoming "stuck" on a tall line when
4440 scrolling by one line. */
4441 if (window_scroll_pixel_based_preserve_y
< 0
4442 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4443 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4445 start_display (&it
, w
, start
);
4446 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4447 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4448 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4452 window_scroll_pixel_based_preserve_y
4453 = window_scroll_pixel_based_preserve_x
= -1;
4455 /* Move iterator it from start the specified distance forward or
4456 backward. The result is the new window start. */
4457 start_display (&it
, w
, start
);
4460 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4461 int dy
= frame_line_height
;
4462 dy
= max ((window_box_height (w
)
4463 - next_screen_context_lines
* dy
),
4466 /* Note that move_it_vertically always moves the iterator to the
4467 start of a line. So, if the last line doesn't have a newline,
4468 we would end up at the start of the line ending at ZV. */
4471 move_it_vertically_backward (&it
, -dy
);
4472 /* Ensure we actually do move, e.g. in case we are currently
4473 looking at an image that is taller that the window height. */
4474 while (start_pos
== IT_CHARPOS (it
)
4475 && start_pos
> BEGV
)
4476 move_it_by_lines (&it
, -1);
4480 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4481 MOVE_TO_POS
| MOVE_TO_Y
);
4482 /* Ensure we actually do move, e.g. in case we are currently
4483 looking at an image that is taller that the window height. */
4484 while (start_pos
== IT_CHARPOS (it
)
4486 move_it_by_lines (&it
, 1);
4490 move_it_by_lines (&it
, n
);
4492 /* We failed if we find ZV is already on the screen (scrolling up,
4493 means there's nothing past the end), or if we can't start any
4494 earlier (scrolling down, means there's nothing past the top). */
4495 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4496 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4498 if (IT_CHARPOS (it
) == ZV
)
4500 if (it
.current_y
< it
.last_visible_y
4501 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4502 > it
.last_visible_y
))
4504 /* The last line was only partially visible, make it fully
4506 w
->vscroll
= (it
.last_visible_y
4507 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4508 adjust_glyphs (it
.f
);
4512 bidi_unshelve_cache (itdata
, 0);
4515 else if (n
< 0) /* could happen with empty buffers */
4516 xsignal0 (Qbeginning_of_buffer
);
4518 xsignal0 (Qend_of_buffer
);
4523 if (w
->vscroll
!= 0)
4524 /* The first line was only partially visible, make it fully
4529 bidi_unshelve_cache (itdata
, 0);
4533 xsignal0 (Qbeginning_of_buffer
);
4537 /* If control gets here, then we vscrolled. */
4539 XBUFFER (w
->contents
)->prevent_redisplay_optimizations_p
= 1;
4541 /* Don't try to change the window start below. */
4547 ptrdiff_t pos
= IT_CHARPOS (it
);
4550 /* If in the middle of a multi-glyph character move forward to
4551 the next character. */
4552 if (in_display_vector_p (&it
))
4555 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4558 /* Set the window start, and set up the window for redisplay. */
4559 set_marker_restricted_both (w
->start
, w
->contents
, IT_CHARPOS (it
),
4561 bytepos
= marker_byte_position (w
->start
);
4562 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4563 w
->update_mode_line
= 1;
4564 /* Set force_start so that redisplay_window will run the
4565 window-scroll-functions. */
4569 /* The rest of this function uses current_y in a nonstandard way,
4570 not including the height of the header line if any. */
4571 it
.current_y
= it
.vpos
= 0;
4573 /* Move PT out of scroll margins.
4574 This code wants current_y to be zero at the window start position
4575 even if there is a header line. */
4577 = w
->total_lines
* WINDOW_FRAME_LINE_HEIGHT (w
) / frame_line_height
;
4578 this_scroll_margin
= max (0, scroll_margin
);
4580 = min (this_scroll_margin
, window_total_lines
/ 4);
4581 this_scroll_margin
*= frame_line_height
;
4585 /* We moved the window start towards ZV, so PT may be now
4586 in the scroll margin at the top. */
4587 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4588 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4589 && (NILP (Vscroll_preserve_screen_position
)
4590 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4591 /* We found PT at a legitimate height. Leave it alone. */
4593 else if (window_scroll_pixel_based_preserve_y
>= 0)
4595 /* If we have a header line, take account of it.
4596 This is necessary because we set it.current_y to 0, above. */
4597 move_it_to (&it
, -1,
4598 window_scroll_pixel_based_preserve_x
,
4599 window_scroll_pixel_based_preserve_y
4600 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4601 -1, MOVE_TO_Y
| MOVE_TO_X
);
4602 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4606 while (it
.current_y
< this_scroll_margin
)
4608 int prev
= it
.current_y
;
4609 move_it_by_lines (&it
, 1);
4610 if (prev
== it
.current_y
)
4613 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4618 ptrdiff_t charpos
, bytepos
;
4621 /* Save our position, for the
4622 window_scroll_pixel_based_preserve_y case. */
4623 charpos
= IT_CHARPOS (it
);
4624 bytepos
= IT_BYTEPOS (it
);
4626 /* We moved the window start towards BEGV, so PT may be now
4627 in the scroll margin at the bottom. */
4628 move_it_to (&it
, PT
, -1,
4629 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4630 - this_scroll_margin
- 1),
4632 MOVE_TO_POS
| MOVE_TO_Y
);
4634 /* Save our position, in case it's correct. */
4635 charpos
= IT_CHARPOS (it
);
4636 bytepos
= IT_BYTEPOS (it
);
4638 /* See if point is on a partially visible line at the end. */
4639 if (it
.what
== IT_EOB
)
4640 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4643 move_it_by_lines (&it
, 1);
4644 partial_p
= it
.current_y
> it
.last_visible_y
;
4647 if (charpos
== PT
&& !partial_p
4648 && (NILP (Vscroll_preserve_screen_position
)
4649 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4650 /* We found PT before we found the display margin, so PT is ok. */
4652 else if (window_scroll_pixel_based_preserve_y
>= 0)
4654 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4655 start_display (&it
, w
, start
);
4656 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4657 here because we called start_display again and did not
4658 alter it.current_y this time. */
4659 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4660 window_scroll_pixel_based_preserve_y
, -1,
4661 MOVE_TO_Y
| MOVE_TO_X
);
4662 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4667 /* The last line was only partially visible, so back up two
4668 lines to make sure we're on a fully visible line. */
4670 move_it_by_lines (&it
, -2);
4671 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4674 /* No, the position we saved is OK, so use it. */
4675 SET_PT_BOTH (charpos
, bytepos
);
4678 bidi_unshelve_cache (itdata
, 0);
4682 /* Implementation of window_scroll that works based on screen lines.
4683 See the comment of window_scroll for parameter descriptions. */
4686 window_scroll_line_based (Lisp_Object window
, int n
, bool whole
, int noerror
)
4688 register struct window
*w
= XWINDOW (window
);
4689 /* Fvertical_motion enters redisplay, which can trigger
4690 fontification, which in turn can modify buffer text (e.g., if the
4691 fontification functions replace escape sequences with faces, as
4692 in `grep-mode-font-lock-keywords'). So we use a marker to record
4693 the old point position, to prevent crashes in SET_PT_BOTH. */
4694 Lisp_Object opoint_marker
= Fpoint_marker ();
4695 register ptrdiff_t pos
, pos_byte
;
4696 register int ht
= window_internal_height (w
);
4697 register Lisp_Object tem
;
4700 ptrdiff_t startpos
= marker_position (w
->start
);
4701 ptrdiff_t startbyte
= marker_byte_position (w
->start
);
4702 Lisp_Object original_pos
= Qnil
;
4704 /* If scrolling screen-fulls, compute the number of lines to
4705 scroll from the window's height. */
4707 n
*= max (1, ht
- next_screen_context_lines
);
4709 if (!NILP (Vscroll_preserve_screen_position
))
4711 if (window_scroll_preserve_vpos
<= 0
4712 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4713 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4715 struct position posit
4716 = *compute_motion (startpos
, startbyte
, 0, 0, 0,
4717 PT
, ht
, 0, -1, w
->hscroll
, 0, w
);
4718 window_scroll_preserve_vpos
= posit
.vpos
;
4719 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4722 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4723 make_number (window_scroll_preserve_vpos
));
4726 XSETFASTINT (tem
, PT
);
4727 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4731 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4733 startbyte
= PT_BYTE
;
4736 SET_PT_BOTH (startpos
, startbyte
);
4737 lose
= n
< 0 && PT
== BEGV
;
4738 Fvertical_motion (make_number (n
), window
);
4742 SET_PT_BOTH (marker_position (opoint_marker
),
4743 marker_byte_position (opoint_marker
));
4750 xsignal0 (Qbeginning_of_buffer
);
4755 /* Don't use a scroll margin that is negative or too large. */
4756 int this_scroll_margin
=
4757 max (0, min (scroll_margin
, w
->total_lines
/ 4));
4759 set_marker_restricted_both (w
->start
, w
->contents
, pos
, pos_byte
);
4760 w
->start_at_line_beg
= !NILP (bolp
);
4761 w
->update_mode_line
= 1;
4762 /* Set force_start so that redisplay_window will run
4763 the window-scroll-functions. */
4766 if (!NILP (Vscroll_preserve_screen_position
)
4767 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4769 SET_PT_BOTH (pos
, pos_byte
);
4770 Fvertical_motion (original_pos
, window
);
4772 /* If we scrolled forward, put point enough lines down
4773 that it is outside the scroll margin. */
4778 if (this_scroll_margin
> 0)
4780 SET_PT_BOTH (pos
, pos_byte
);
4781 Fvertical_motion (make_number (this_scroll_margin
), window
);
4787 if (top_margin
<= marker_position (opoint_marker
))
4788 SET_PT_BOTH (marker_position (opoint_marker
),
4789 marker_byte_position (opoint_marker
));
4790 else if (!NILP (Vscroll_preserve_screen_position
))
4792 SET_PT_BOTH (pos
, pos_byte
);
4793 Fvertical_motion (original_pos
, window
);
4796 SET_PT (top_margin
);
4802 /* If we scrolled backward, put point near the end of the window
4803 but not within the scroll margin. */
4804 SET_PT_BOTH (pos
, pos_byte
);
4805 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4806 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4809 bottom_margin
= PT
+ 1;
4811 if (bottom_margin
> marker_position (opoint_marker
))
4812 SET_PT_BOTH (marker_position (opoint_marker
),
4813 marker_byte_position (opoint_marker
));
4816 if (!NILP (Vscroll_preserve_screen_position
))
4818 SET_PT_BOTH (pos
, pos_byte
);
4819 Fvertical_motion (original_pos
, window
);
4822 Fvertical_motion (make_number (-1), window
);
4831 xsignal0 (Qend_of_buffer
);
4836 /* Scroll selected_window up or down. If N is nil, scroll a
4837 screen-full which is defined as the height of the window minus
4838 next_screen_context_lines. If N is the symbol `-', scroll.
4839 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4840 up. This is the guts of Fscroll_up and Fscroll_down. */
4843 scroll_command (Lisp_Object n
, int direction
)
4845 ptrdiff_t count
= SPECPDL_INDEX ();
4847 eassert (eabs (direction
) == 1);
4849 /* If selected window's buffer isn't current, make it current for
4850 the moment. But don't screw up if window_scroll gets an error. */
4851 if (XBUFFER (XWINDOW (selected_window
)->contents
) != current_buffer
)
4853 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4854 Fset_buffer (XWINDOW (selected_window
)->contents
);
4856 /* Make redisplay consider other windows than just selected_window. */
4857 ++windows_or_buffers_changed
;
4861 window_scroll (selected_window
, direction
, 1, 0);
4862 else if (EQ (n
, Qminus
))
4863 window_scroll (selected_window
, -direction
, 1, 0);
4866 n
= Fprefix_numeric_value (n
);
4867 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4870 unbind_to (count
, Qnil
);
4873 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4874 doc
: /* Scroll text of selected window upward ARG lines.
4875 If ARG is omitted or nil, scroll upward by a near full screen.
4876 A near full screen is `next-screen-context-lines' less than a full screen.
4877 Negative ARG means scroll downward.
4878 If ARG is the atom `-', scroll downward by nearly full screen.
4879 When calling from a program, supply as argument a number, nil, or `-'. */)
4882 scroll_command (arg
, 1);
4886 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4887 doc
: /* Scroll text of selected window down ARG lines.
4888 If ARG is omitted or nil, scroll down by a near full screen.
4889 A near full screen is `next-screen-context-lines' less than a full screen.
4890 Negative ARG means scroll upward.
4891 If ARG is the atom `-', scroll upward by nearly full screen.
4892 When calling from a program, supply as argument a number, nil, or `-'. */)
4895 scroll_command (arg
, -1);
4899 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4900 doc
: /* Return the other window for \"other window scroll\" commands.
4901 If `other-window-scroll-buffer' is non-nil, a window
4902 showing that buffer is used.
4903 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4904 specifies the window. This takes precedence over
4905 `other-window-scroll-buffer'. */)
4910 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4911 && !NILP (Vminibuf_scroll_window
))
4912 window
= Vminibuf_scroll_window
;
4913 /* If buffer is specified, scroll that buffer. */
4914 else if (!NILP (Vother_window_scroll_buffer
))
4916 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4918 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4922 /* Nothing specified; look for a neighboring window on the same
4924 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4926 if (EQ (window
, selected_window
))
4927 /* That didn't get us anywhere; look for a window on another
4930 window
= Fnext_window (window
, Qnil
, Qt
);
4931 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4932 && ! EQ (window
, selected_window
));
4935 CHECK_LIVE_WINDOW (window
);
4937 if (EQ (window
, selected_window
))
4938 error ("There is no other window");
4943 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4944 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4945 A near full screen is `next-screen-context-lines' less than a full screen.
4946 The next window is the one below the current one; or the one at the top
4947 if the current one is at the bottom. Negative ARG means scroll downward.
4948 If ARG is the atom `-', scroll downward by nearly full screen.
4949 When calling from a program, supply as argument a number, nil, or `-'.
4951 If `other-window-scroll-buffer' is non-nil, scroll the window
4952 showing that buffer, popping the buffer up if necessary.
4953 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4954 specifies the window to scroll. This takes precedence over
4955 `other-window-scroll-buffer'. */)
4960 ptrdiff_t count
= SPECPDL_INDEX ();
4962 window
= Fother_window_for_scrolling ();
4963 w
= XWINDOW (window
);
4965 /* Don't screw up if window_scroll gets an error. */
4966 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4967 ++windows_or_buffers_changed
;
4969 Fset_buffer (w
->contents
);
4970 SET_PT_BOTH (marker_position (w
->pointm
), marker_byte_position (w
->pointm
));
4973 window_scroll (window
, 1, 1, 1);
4974 else if (EQ (arg
, Qminus
))
4975 window_scroll (window
, -1, 1, 1);
4981 window_scroll (window
, XINT (arg
), 0, 1);
4984 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4985 unbind_to (count
, Qnil
);
4990 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
4991 doc
: /* Scroll selected window display ARG columns left.
4992 Default for ARG is window width minus 2.
4993 Value is the total amount of leftward horizontal scrolling in
4994 effect after the change.
4995 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4996 lower bound for automatic scrolling, i.e. automatic scrolling
4997 will not scroll a window to a column less than the value returned
4998 by this function. This happens in an interactive call. */)
4999 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5001 struct window
*w
= XWINDOW (selected_window
);
5002 EMACS_INT requested_arg
= (NILP (arg
)
5003 ? window_body_cols (w
) - 2
5004 : XINT (Fprefix_numeric_value (arg
)));
5005 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5007 if (!NILP (set_minimum
))
5008 w
->min_hscroll
= w
->hscroll
;
5013 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5014 doc
: /* Scroll selected window display ARG columns right.
5015 Default for ARG is window width minus 2.
5016 Value is the total amount of leftward horizontal scrolling in
5017 effect after the change.
5018 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5019 lower bound for automatic scrolling, i.e. automatic scrolling
5020 will not scroll a window to a column less than the value returned
5021 by this function. This happens in an interactive call. */)
5022 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5024 struct window
*w
= XWINDOW (selected_window
);
5025 EMACS_INT requested_arg
= (NILP (arg
)
5026 ? window_body_cols (w
) - 2
5027 : XINT (Fprefix_numeric_value (arg
)));
5028 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5030 if (!NILP (set_minimum
))
5031 w
->min_hscroll
= w
->hscroll
;
5036 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5037 doc
: /* Return the window which was selected when entering the minibuffer.
5038 Returns nil, if selected window is not a minibuffer window. */)
5041 if (minibuf_level
> 0
5042 && MINI_WINDOW_P (XWINDOW (selected_window
))
5043 && WINDOW_LIVE_P (minibuf_selected_window
))
5044 return minibuf_selected_window
;
5049 /* Value is the number of lines actually displayed in window W,
5050 as opposed to its height. */
5053 displayed_window_lines (struct window
*w
)
5056 struct text_pos start
;
5057 ptrdiff_t charpos
= marker_position (w
->start
);
5058 int height
= window_box_height (w
);
5059 struct buffer
*old_buffer
;
5061 void *itdata
= NULL
;
5063 if (XBUFFER (w
->contents
) != current_buffer
)
5065 old_buffer
= current_buffer
;
5066 set_buffer_internal (XBUFFER (w
->contents
));
5071 /* In case W->start is out of the accessible range, do something
5072 reasonable. This happens in Info mode when Info-scroll-down
5073 calls (recenter -1) while W->start is 1. */
5075 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5076 else if (charpos
> ZV
)
5077 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5079 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5081 itdata
= bidi_shelve_cache ();
5082 start_display (&it
, w
, start
);
5083 move_it_vertically (&it
, height
);
5084 bottom_y
= line_bottom_y (&it
);
5085 bidi_unshelve_cache (itdata
, 0);
5087 /* rms: On a non-window display,
5088 the value of it.vpos at the bottom of the screen
5089 seems to be 1 larger than window_box_height (w).
5090 This kludge fixes a bug whereby (move-to-window-line -1)
5091 when ZV is on the last screen line
5092 moves to the previous screen line instead of the last one. */
5093 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5096 /* Add in empty lines at the bottom of the window. */
5097 if (bottom_y
< height
)
5099 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5100 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5104 set_buffer_internal (old_buffer
);
5110 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5111 doc
: /* Center point in selected window and maybe redisplay frame.
5112 With a numeric prefix argument ARG, recenter putting point on screen line ARG
5113 relative to the selected window. If ARG is negative, it counts up from the
5114 bottom of the window. (ARG should be less than the height of the window.)
5116 If ARG is omitted or nil, then recenter with point on the middle line of
5117 the selected window; if the variable `recenter-redisplay' is non-nil,
5118 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5119 is set to `grow-only', this resets the tool-bar's height to the minimum
5120 height needed); if `recenter-redisplay' has the special value `tty',
5121 then only tty frames are redrawn.
5123 Just C-u as prefix means put point in the center of the window
5124 and redisplay normally--don't erase and redraw the frame. */)
5125 (register Lisp_Object arg
)
5127 struct window
*w
= XWINDOW (selected_window
);
5128 struct buffer
*buf
= XBUFFER (w
->contents
);
5129 struct buffer
*obuf
= current_buffer
;
5131 ptrdiff_t charpos
, bytepos
;
5132 EMACS_INT iarg
IF_LINT (= 0);
5133 int this_scroll_margin
;
5135 /* If redisplay is suppressed due to an error, try again. */
5136 obuf
->display_error_modiff
= 0;
5140 if (!NILP (Vrecenter_redisplay
)
5141 && (!EQ (Vrecenter_redisplay
, Qtty
)
5142 || !NILP (Ftty_type (selected_frame
))))
5146 /* Invalidate pixel data calculated for all compositions. */
5147 for (i
= 0; i
< n_compositions
; i
++)
5148 composition_table
[i
]->font
= NULL
;
5150 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5152 Fredraw_frame (WINDOW_FRAME (w
));
5153 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5158 else if (CONSP (arg
)) /* Just C-u. */
5162 arg
= Fprefix_numeric_value (arg
);
5167 set_buffer_internal (buf
);
5169 /* Do this after making BUF current
5170 in case scroll_margin is buffer-local. */
5171 this_scroll_margin
=
5172 max (0, min (scroll_margin
, w
->total_lines
/ 4));
5174 /* Handle centering on a graphical frame specially. Such frames can
5175 have variable-height lines and centering point on the basis of
5176 line counts would lead to strange effects. */
5177 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5183 void *itdata
= bidi_shelve_cache ();
5185 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5186 start_display (&it
, w
, pt
);
5187 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5188 charpos
= IT_CHARPOS (it
);
5189 bytepos
= IT_BYTEPOS (it
);
5190 bidi_unshelve_cache (itdata
, 0);
5196 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5197 int extra_line_spacing
;
5198 int h
= window_box_height (w
);
5199 void *itdata
= bidi_shelve_cache ();
5201 iarg
= - max (-iarg
, this_scroll_margin
);
5203 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5204 start_display (&it
, w
, pt
);
5206 /* Be sure we have the exact height of the full line containing PT. */
5207 move_it_by_lines (&it
, 0);
5209 /* The amount of pixels we have to move back is the window
5210 height minus what's displayed in the line containing PT,
5211 and the lines below. */
5214 move_it_by_lines (&it
, nlines
);
5216 if (it
.vpos
== nlines
)
5220 /* Last line has no newline */
5221 h
-= line_bottom_y (&it
);
5225 /* Don't reserve space for extra line spacing of last line. */
5226 extra_line_spacing
= it
.max_extra_line_spacing
;
5228 /* If we can't move down NLINES lines because we hit
5229 the end of the buffer, count in some empty lines. */
5230 if (it
.vpos
< nlines
)
5233 extra_line_spacing
= it
.extra_line_spacing
;
5234 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5238 bidi_unshelve_cache (itdata
, 0);
5242 /* Now find the new top line (starting position) of the window. */
5243 start_display (&it
, w
, pt
);
5245 move_it_vertically_backward (&it
, h
);
5247 /* If extra line spacing is present, we may move too far
5248 back. This causes the last line to be only partially
5249 visible (which triggers redisplay to recenter that line
5250 in the middle), so move forward.
5251 But ignore extra line spacing on last line, as it is not
5252 considered to be part of the visible height of the line.
5254 h
+= extra_line_spacing
;
5255 while (-it
.current_y
> h
)
5256 move_it_by_lines (&it
, 1);
5258 charpos
= IT_CHARPOS (it
);
5259 bytepos
= IT_BYTEPOS (it
);
5261 bidi_unshelve_cache (itdata
, 0);
5265 struct position pos
;
5267 iarg
= max (iarg
, this_scroll_margin
);
5269 pos
= *vmotion (PT
, PT_BYTE
, -iarg
, w
);
5270 charpos
= pos
.bufpos
;
5271 bytepos
= pos
.bytepos
;
5276 struct position pos
;
5277 int ht
= window_internal_height (w
);
5284 /* Don't let it get into the margin at either top or bottom. */
5285 iarg
= clip_to_bounds (this_scroll_margin
, iarg
,
5286 ht
- this_scroll_margin
- 1);
5288 pos
= *vmotion (PT
, PT_BYTE
, - iarg
, w
);
5289 charpos
= pos
.bufpos
;
5290 bytepos
= pos
.bytepos
;
5293 /* Set the new window start. */
5294 set_marker_both (w
->start
, w
->contents
, charpos
, bytepos
);
5295 w
->window_end_valid
= 0;
5297 w
->optional_new_start
= 1;
5299 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5300 FETCH_BYTE (bytepos
- 1) == '\n');
5302 set_buffer_internal (obuf
);
5306 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5308 doc
: /* Return the height in lines of the text display area of WINDOW.
5309 WINDOW must be a live window and defaults to the selected one.
5311 The returned height does not include the mode line, any header line,
5312 nor any partial-height lines at the bottom of the text area. */)
5313 (Lisp_Object window
)
5315 struct window
*w
= decode_live_window (window
);
5316 int pixel_height
= window_box_height (w
);
5317 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5318 return make_number (line_height
);
5323 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5325 doc
: /* Position point relative to window.
5326 ARG nil means position point at center of window.
5327 Else, ARG specifies vertical position within the window;
5328 zero means top of window, negative means relative to bottom of window. */)
5331 struct window
*w
= XWINDOW (selected_window
);
5335 int this_scroll_margin
;
5338 if (!(BUFFERP (w
->contents
) && XBUFFER (w
->contents
) == current_buffer
))
5339 /* This test is needed to make sure PT/PT_BYTE make sense in w->contents
5340 when passed below to set_marker_both. */
5341 error ("move-to-window-line called from unrelated buffer");
5343 window
= selected_window
;
5344 start
= marker_position (w
->start
);
5345 if (start
< BEGV
|| start
> ZV
)
5347 int height
= window_internal_height (w
);
5348 Fvertical_motion (make_number (- (height
/ 2)), window
);
5349 set_marker_both (w
->start
, w
->contents
, PT
, PT_BYTE
);
5350 w
->start_at_line_beg
= !NILP (Fbolp ());
5354 Fgoto_char (w
->start
);
5356 lines
= displayed_window_lines (w
);
5359 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5363 XSETFASTINT (arg
, lines
/ 2);
5366 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5369 iarg
= iarg
+ lines
;
5371 #if 0 /* This code would prevent move-to-window-line from moving point
5372 to a place inside the scroll margins (which would cause the
5373 next redisplay to scroll). I wrote this code, but then concluded
5374 it is probably better not to install it. However, it is here
5375 inside #if 0 so as not to lose it. -- rms. */
5377 /* Don't let it get into the margin at either top or bottom. */
5378 iarg
= max (iarg
, this_scroll_margin
);
5379 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5382 arg
= make_number (iarg
);
5385 /* Skip past a partially visible first line. */
5387 XSETINT (arg
, XINT (arg
) + 1);
5389 return Fvertical_motion (arg
, window
);
5394 /***********************************************************************
5395 Window Configuration
5396 ***********************************************************************/
5398 struct save_window_data
5400 struct vectorlike_header header
;
5401 Lisp_Object selected_frame
;
5402 Lisp_Object current_window
;
5403 Lisp_Object current_buffer
;
5404 Lisp_Object minibuf_scroll_window
;
5405 Lisp_Object minibuf_selected_window
;
5406 Lisp_Object root_window
;
5407 Lisp_Object focus_frame
;
5408 /* A vector, each of whose elements is a struct saved_window
5410 Lisp_Object saved_windows
;
5412 /* All fields above are traced by the GC.
5413 From `frame-cols' down, the fields are ignored by the GC. */
5415 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5416 int frame_tool_bar_lines
;
5419 /* This is saved as a Lisp_Vector */
5422 struct vectorlike_header header
;
5424 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5425 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5426 Lisp_Object normal_cols
, normal_lines
;
5427 Lisp_Object hscroll
, min_hscroll
;
5428 Lisp_Object parent
, prev
;
5429 Lisp_Object start_at_line_beg
;
5430 Lisp_Object display_table
;
5431 Lisp_Object left_margin_cols
, right_margin_cols
;
5432 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5433 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5434 Lisp_Object combination_limit
, window_parameters
;
5437 #define SAVED_WINDOW_N(swv,n) \
5438 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5440 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5441 doc
: /* Return t if OBJECT is a window-configuration object. */)
5442 (Lisp_Object object
)
5444 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5447 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5448 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5449 (Lisp_Object config
)
5451 register struct save_window_data
*data
;
5452 struct Lisp_Vector
*saved_windows
;
5454 CHECK_WINDOW_CONFIGURATION (config
);
5456 data
= (struct save_window_data
*) XVECTOR (config
);
5457 saved_windows
= XVECTOR (data
->saved_windows
);
5458 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5461 DEFUN ("set-window-configuration", Fset_window_configuration
,
5462 Sset_window_configuration
, 1, 1, 0,
5463 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5464 CONFIGURATION must be a value previously returned
5465 by `current-window-configuration' (which see).
5466 If CONFIGURATION was made from a frame that is now deleted,
5467 only frame-independent values can be restored. In this case,
5468 the return value is nil. Otherwise the value is t. */)
5469 (Lisp_Object configuration
)
5471 register struct save_window_data
*data
;
5472 struct Lisp_Vector
*saved_windows
;
5473 Lisp_Object new_current_buffer
;
5476 ptrdiff_t old_point
= -1;
5478 CHECK_WINDOW_CONFIGURATION (configuration
);
5480 data
= (struct save_window_data
*) XVECTOR (configuration
);
5481 saved_windows
= XVECTOR (data
->saved_windows
);
5483 new_current_buffer
= data
->current_buffer
;
5484 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5485 new_current_buffer
= Qnil
;
5488 if (XBUFFER (new_current_buffer
) == current_buffer
)
5489 /* The code further down "preserves point" by saving here PT in
5490 old_point and then setting it later back into PT. When the
5491 current-selected-window and the final-selected-window both show
5492 the current buffer, this suffers from the problem that the
5493 current PT is the window-point of the current-selected-window,
5494 while the final PT is the point of the final-selected-window, so
5495 this copy from one PT to the other would end up moving the
5496 window-point of the final-selected-window to the window-point of
5497 the current-selected-window. So we have to be careful which
5498 point of the current-buffer we copy into old_point. */
5499 if (EQ (XWINDOW (data
->current_window
)->contents
, new_current_buffer
)
5500 && WINDOWP (selected_window
)
5501 && EQ (XWINDOW (selected_window
)->contents
, new_current_buffer
)
5502 && !EQ (selected_window
, data
->current_window
))
5503 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5507 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5508 point in new_current_buffer as of the last time this buffer was
5509 used. This can be non-deterministic since it can be changed by
5510 things like jit-lock by mere temporary selection of some random
5511 window that happens to show this buffer.
5512 So if possible we want this arbitrary choice of "which point" to
5513 be the one from the to-be-selected-window so as to prevent this
5514 window's cursor from being copied from another window. */
5515 if (EQ (XWINDOW (data
->current_window
)->contents
, new_current_buffer
)
5516 /* If current_window = selected_window, its point is in BUF_PT. */
5517 && !EQ (selected_window
, data
->current_window
))
5518 old_point
= marker_position (XWINDOW (data
->current_window
)->pointm
);
5520 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5523 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5526 /* If f is a dead frame, don't bother rebuilding its window tree.
5527 However, there is other stuff we should still try to do below. */
5528 if (FRAME_LIVE_P (f
))
5531 Lisp_Object dead_windows
= Qnil
;
5532 register Lisp_Object tem
, par
, pers
;
5533 register struct window
*w
;
5534 register struct saved_window
*p
;
5535 struct window
*root_window
;
5536 struct window
**leaf_windows
;
5541 /* If the frame has been resized since this window configuration was
5542 made, we change the frame to the size specified in the
5543 configuration, restore the configuration, and then resize it
5544 back. We keep track of the prevailing height in these variables. */
5545 int previous_frame_lines
= FRAME_LINES (f
);
5546 int previous_frame_cols
= FRAME_COLS (f
);
5547 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5548 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5550 /* Don't do this within the main loop below: This may call Lisp
5551 code and is thus potentially unsafe while input is blocked. */
5552 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5554 p
= SAVED_WINDOW_N (saved_windows
, k
);
5556 w
= XWINDOW (window
);
5557 if (BUFFERP (w
->contents
)
5558 && !EQ (w
->contents
, p
->buffer
)
5559 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5560 /* If a window we restore gets another buffer, record the
5561 window's old buffer. */
5562 call1 (Qrecord_window_buffer
, window
);
5565 /* The mouse highlighting code could get screwed up
5566 if it runs during this. */
5569 if (data
->frame_lines
!= previous_frame_lines
5570 || data
->frame_cols
!= previous_frame_cols
)
5571 change_frame_size (f
, data
->frame_lines
,
5572 data
->frame_cols
, 0, 0, 0);
5573 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5574 if (data
->frame_menu_bar_lines
5575 != previous_frame_menu_bar_lines
)
5576 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5578 #ifdef HAVE_WINDOW_SYSTEM
5579 if (data
->frame_tool_bar_lines
5580 != previous_frame_tool_bar_lines
)
5581 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5586 /* "Swap out" point from the selected window's buffer
5587 into the window itself. (Normally the pointm of the selected
5588 window holds garbage.) We do this now, before
5589 restoring the window contents, and prevent it from
5590 being done later on when we select a new window. */
5591 if (! NILP (XWINDOW (selected_window
)->contents
))
5593 w
= XWINDOW (selected_window
);
5594 set_marker_both (w
->pointm
,
5596 BUF_PT (XBUFFER (w
->contents
)),
5597 BUF_PT_BYTE (XBUFFER (w
->contents
)));
5600 windows_or_buffers_changed
++;
5601 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5603 /* Problem: Freeing all matrices and later allocating them again
5604 is a serious redisplay flickering problem. What we would
5605 really like to do is to free only those matrices not reused
5607 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5608 leaf_windows
= alloca (count_windows (root_window
)
5609 * sizeof *leaf_windows
);
5610 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5613 Mark all windows now on frame as "deleted".
5614 Restoring the new configuration "undeletes" any that are in it.
5616 Save their current buffers in their height fields, since we may
5617 need it later, if a buffer saved in the configuration is now
5619 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5621 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5623 p
= SAVED_WINDOW_N (saved_windows
, k
);
5625 w
= XWINDOW (window
);
5626 wset_next (w
, Qnil
);
5628 if (!NILP (p
->parent
))
5630 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5632 wset_parent (w
, Qnil
);
5634 if (!NILP (p
->prev
))
5637 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5638 wset_next (XWINDOW (w
->prev
), p
->window
);
5642 wset_prev (w
, Qnil
);
5643 if (!NILP (w
->parent
))
5644 wset_combination (XWINDOW (w
->parent
),
5645 (XINT (p
->total_cols
)
5646 != XWINDOW (w
->parent
)->total_cols
),
5650 /* If we squirreled away the buffer, restore it now. */
5651 if (BUFFERP (w
->combination_limit
))
5652 wset_buffer (w
, w
->combination_limit
);
5653 w
->left_col
= XFASTINT (p
->left_col
);
5654 w
->top_line
= XFASTINT (p
->top_line
);
5655 w
->total_cols
= XFASTINT (p
->total_cols
);
5656 w
->total_lines
= XFASTINT (p
->total_lines
);
5657 wset_normal_cols (w
, p
->normal_cols
);
5658 wset_normal_lines (w
, p
->normal_lines
);
5659 w
->hscroll
= XFASTINT (p
->hscroll
);
5660 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5661 wset_display_table (w
, p
->display_table
);
5662 w
->left_margin_cols
= XINT (p
->left_margin_cols
);
5663 w
->right_margin_cols
= XINT (p
->right_margin_cols
);
5664 w
->left_fringe_width
= XINT (p
->left_fringe_width
);
5665 w
->right_fringe_width
= XINT (p
->right_fringe_width
);
5666 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5667 w
->scroll_bar_width
= XINT (p
->scroll_bar_width
);
5668 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5669 wset_dedicated (w
, p
->dedicated
);
5670 wset_combination_limit (w
, p
->combination_limit
);
5671 /* Restore any window parameters that have been saved.
5672 Parameters that have not been saved are left alone. */
5673 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5678 if (NILP (XCDR (pers
)))
5680 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5681 if (CONSP (par
) && !NILP (XCDR (par
)))
5682 /* Reset a parameter to nil if and only if it
5683 has a non-nil association. Don't make new
5685 Fsetcdr (par
, Qnil
);
5688 /* Always restore a non-nil value. */
5689 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5693 if (BUFFERP (p
->buffer
) && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5694 /* If saved buffer is alive, install it. */
5696 wset_buffer (w
, p
->buffer
);
5697 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5698 set_marker_restricted (w
->start
, p
->start
, w
->contents
);
5699 set_marker_restricted (w
->pointm
, p
->pointm
,
5701 Fset_marker (BVAR (XBUFFER (w
->contents
), mark
),
5702 p
->mark
, w
->contents
);
5704 /* As documented in Fcurrent_window_configuration, don't
5705 restore the location of point in the buffer which was
5706 current when the window configuration was recorded. */
5707 if (!EQ (p
->buffer
, new_current_buffer
)
5708 && XBUFFER (p
->buffer
) == current_buffer
)
5709 Fgoto_char (w
->pointm
);
5711 else if (BUFFERP (w
->contents
) && BUFFER_LIVE_P (XBUFFER (w
->contents
)))
5712 /* Keep window's old buffer; make sure the markers are real. */
5714 /* Set window markers at start of visible range. */
5715 if (XMARKER (w
->start
)->buffer
== 0)
5716 set_marker_restricted_both (w
->start
, w
->contents
, 0, 0);
5717 if (XMARKER (w
->pointm
)->buffer
== 0)
5718 set_marker_restricted_both
5719 (w
->pointm
, w
->contents
,
5720 BUF_PT (XBUFFER (w
->contents
)),
5721 BUF_PT_BYTE (XBUFFER (w
->contents
)));
5722 w
->start_at_line_beg
= 1;
5724 else if (!NILP (w
->start
))
5725 /* Leaf window has no live buffer, get one. */
5727 /* Get the buffer via other_buffer_safely in order to
5728 avoid showing an unimportant buffer and, if necessary, to
5729 recreate *scratch* in the course (part of Juanma's bs-show
5730 scenario from March 2011). */
5731 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5732 /* This will set the markers to beginning of visible
5734 set_marker_restricted_both (w
->start
, w
->contents
, 0, 0);
5735 set_marker_restricted_both (w
->pointm
, w
->contents
, 0, 0);
5736 w
->start_at_line_beg
= 1;
5737 if (!NILP (w
->dedicated
))
5738 /* Record this window as dead. */
5739 dead_windows
= Fcons (window
, dead_windows
);
5740 /* Make sure window is no more dedicated. */
5741 wset_dedicated (w
, Qnil
);
5745 fset_root_window (f
, data
->root_window
);
5746 /* Arrange *not* to restore point in the buffer that was
5747 current when the window configuration was saved. */
5748 if (EQ (XWINDOW (data
->current_window
)->contents
, new_current_buffer
))
5749 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5750 make_number (old_point
),
5751 XWINDOW (data
->current_window
)->contents
);
5753 /* In the following call to `select-window', prevent "swapping out
5754 point" in the old selected window using the buffer that has
5755 been restored into it. We already swapped out that point from
5756 that window's old buffer. */
5757 select_window (data
->current_window
, Qnil
, 1);
5758 BVAR (XBUFFER (XWINDOW (selected_window
)->contents
), last_selected_window
)
5761 if (NILP (data
->focus_frame
)
5762 || (FRAMEP (data
->focus_frame
)
5763 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5764 Fredirect_frame_focus (frame
, data
->focus_frame
);
5766 /* Set the screen height to the value it had before this function. */
5767 if (previous_frame_lines
!= FRAME_LINES (f
)
5768 || previous_frame_cols
!= FRAME_COLS (f
))
5769 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5771 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5772 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5773 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5775 #ifdef HAVE_WINDOW_SYSTEM
5776 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5777 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5782 /* Now, free glyph matrices in windows that were not reused. */
5783 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5785 if (NILP (leaf_windows
[i
]->contents
))
5786 free_window_matrices (leaf_windows
[i
]);
5787 else if (EQ (leaf_windows
[i
]->contents
, new_current_buffer
))
5794 /* Scan dead buffer windows. */
5795 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5797 window
= XCAR (dead_windows
);
5798 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5799 delete_deletable_window (window
);
5802 /* Fselect_window will have made f the selected frame, so we
5803 reselect the proper frame here. Fhandle_switch_frame will change the
5804 selected window too, but that doesn't make the call to
5805 Fselect_window above totally superfluous; it still sets f's
5807 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5808 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5810 run_window_configuration_change_hook (f
);
5813 if (!NILP (new_current_buffer
))
5815 Fset_buffer (new_current_buffer
);
5816 /* If the new current buffer doesn't appear in the selected
5817 window, go to its old point (see bug#12208). */
5818 if (!EQ (XWINDOW (data
->current_window
)->contents
, new_current_buffer
))
5819 Fgoto_char (make_number (old_point
));
5822 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5823 minibuf_selected_window
= data
->minibuf_selected_window
;
5825 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5829 restore_window_configuration (Lisp_Object configuration
)
5831 Fset_window_configuration (configuration
);
5835 /* If WINDOW is an internal window, recursively delete all child windows
5836 reachable via the next and contents slots of WINDOW. Otherwise setup
5837 WINDOW to not show any buffer. */
5840 delete_all_child_windows (Lisp_Object window
)
5842 register struct window
*w
;
5844 w
= XWINDOW (window
);
5846 if (!NILP (w
->next
))
5847 /* Delete WINDOW's siblings (we traverse postorderly). */
5848 delete_all_child_windows (w
->next
);
5850 if (WINDOWP (w
->contents
))
5852 delete_all_child_windows (w
->contents
);
5853 wset_combination (w
, 0, Qnil
);
5855 else if (BUFFERP (w
->contents
))
5858 unchain_marker (XMARKER (w
->pointm
));
5859 unchain_marker (XMARKER (w
->start
));
5860 /* Since combination limit makes sense for an internal windows
5861 only, we use this slot to save the buffer for the sake of
5862 possible resurrection in Fset_window_configuration. */
5863 wset_combination_limit (w
, w
->contents
);
5864 wset_buffer (w
, Qnil
);
5867 Vwindow_list
= Qnil
;
5871 count_windows (register struct window
*window
)
5873 register int count
= 1;
5874 if (!NILP (window
->next
))
5875 count
+= count_windows (XWINDOW (window
->next
));
5876 if (WINDOWP (window
->contents
))
5877 count
+= count_windows (XWINDOW (window
->contents
));
5882 /* Fill vector FLAT with leaf windows under W, starting at index I.
5883 Value is last index + 1. */
5885 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5889 if (WINDOWP (w
->contents
))
5890 i
= get_leaf_windows (XWINDOW (w
->contents
), flat
, i
);
5894 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5901 /* Return a pointer to the glyph W's physical cursor is on. Value is
5902 null if W's current matrix is invalid, so that no meaningful glyph
5905 get_phys_cursor_glyph (struct window
*w
)
5907 struct glyph_row
*row
;
5908 struct glyph
*glyph
;
5909 int hpos
= w
->phys_cursor
.hpos
;
5911 if (!(w
->phys_cursor
.vpos
>= 0
5912 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5915 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5916 if (!row
->enabled_p
)
5921 /* When the window is hscrolled, cursor hpos can legitimately be
5922 out of bounds, but we draw the cursor at the corresponding
5923 window margin in that case. */
5924 if (!row
->reversed_p
&& hpos
< 0)
5926 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
5927 hpos
= row
->used
[TEXT_AREA
] - 1;
5930 if (0 <= hpos
&& hpos
< row
->used
[TEXT_AREA
])
5931 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
5940 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
5942 register struct saved_window
*p
;
5943 register struct window
*w
;
5944 register Lisp_Object tem
, pers
, par
;
5946 for (; !NILP (window
); window
= w
->next
)
5948 p
= SAVED_WINDOW_N (vector
, i
);
5949 w
= XWINDOW (window
);
5951 wset_temslot (w
, make_number (i
)); i
++;
5953 p
->buffer
= (WINDOW_LEAF_P (w
) ? w
->contents
: Qnil
);
5954 p
->left_col
= make_number (w
->left_col
);
5955 p
->top_line
= make_number (w
->top_line
);
5956 p
->total_cols
= make_number (w
->total_cols
);
5957 p
->total_lines
= make_number (w
->total_lines
);
5958 p
->normal_cols
= w
->normal_cols
;
5959 p
->normal_lines
= w
->normal_lines
;
5960 XSETFASTINT (p
->hscroll
, w
->hscroll
);
5961 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
5962 p
->display_table
= w
->display_table
;
5963 p
->left_margin_cols
= make_number (w
->left_margin_cols
);
5964 p
->right_margin_cols
= make_number (w
->right_margin_cols
);
5965 p
->left_fringe_width
= make_number (w
->left_fringe_width
);
5966 p
->right_fringe_width
= make_number (w
->right_fringe_width
);
5967 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
5968 p
->scroll_bar_width
= make_number (w
->scroll_bar_width
);
5969 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5970 p
->dedicated
= w
->dedicated
;
5971 p
->combination_limit
= w
->combination_limit
;
5972 p
->window_parameters
= Qnil
;
5974 if (!NILP (Vwindow_persistent_parameters
))
5976 /* Run cycle detection on Vwindow_persistent_parameters. */
5977 Lisp_Object tortoise
, hare
;
5979 hare
= tortoise
= Vwindow_persistent_parameters
;
5980 while (CONSP (hare
))
5987 tortoise
= XCDR (tortoise
);
5989 if (EQ (hare
, tortoise
))
5990 /* Reset Vwindow_persistent_parameters to Qnil. */
5992 Vwindow_persistent_parameters
= Qnil
;
5997 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6001 /* Save values for persistent window parameters. */
6002 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6004 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6006 /* If the window has no value for the parameter,
6008 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6009 p
->window_parameters
);
6011 /* If the window has a value for the parameter,
6013 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6015 p
->window_parameters
);
6020 if (BUFFERP (w
->contents
))
6022 /* Save w's value of point in the window configuration. If w
6023 is the selected window, then get the value of point from
6024 the buffer; pointm is garbage in the selected window. */
6025 if (EQ (window
, selected_window
))
6026 p
->pointm
= build_marker (XBUFFER (w
->contents
),
6027 BUF_PT (XBUFFER (w
->contents
)),
6028 BUF_PT_BYTE (XBUFFER (w
->contents
)));
6030 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6031 XMARKER (p
->pointm
)->insertion_type
6032 = !NILP (Vwindow_point_insertion_type
);
6034 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6035 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6037 tem
= BVAR (XBUFFER (w
->contents
), mark
);
6038 p
->mark
= Fcopy_marker (tem
, Qnil
);
6045 p
->start_at_line_beg
= Qnil
;
6048 if (NILP (w
->parent
))
6051 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6056 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6058 if (WINDOWP (w
->contents
))
6059 i
= save_window_save (w
->contents
, vector
, i
);
6065 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6066 Scurrent_window_configuration
, 0, 1, 0,
6067 doc
: /* Return an object representing the current window configuration of FRAME.
6068 If FRAME is nil or omitted, use the selected frame.
6069 This describes the number of windows, their sizes and current buffers,
6070 and for each displayed buffer, where display starts, and the positions of
6071 point and mark. An exception is made for point in the current buffer:
6072 its value is -not- saved.
6073 This also records the currently selected frame, and FRAME's focus
6074 redirection (see `redirect-frame-focus'). The variable
6075 `window-persistent-parameters' specifies which window parameters are
6076 saved by this function. */)
6079 register Lisp_Object tem
;
6080 register int n_windows
;
6081 register struct save_window_data
*data
;
6083 struct frame
*f
= decode_live_frame (frame
);
6085 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6086 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6087 PVEC_WINDOW_CONFIGURATION
);
6089 data
->frame_cols
= FRAME_COLS (f
);
6090 data
->frame_lines
= FRAME_LINES (f
);
6091 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6092 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6093 data
->selected_frame
= selected_frame
;
6094 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6095 XSETBUFFER (data
->current_buffer
, current_buffer
);
6096 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6097 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6098 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6099 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6100 tem
= make_uninit_vector (n_windows
);
6101 data
->saved_windows
= tem
;
6102 for (i
= 0; i
< n_windows
; i
++)
6104 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6105 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6106 XSETWINDOW_CONFIGURATION (tem
, data
);
6110 /* Called after W's margins, fringes or scroll bars was adjusted. */
6113 apply_window_adjustment (struct window
*w
)
6116 adjust_window_margins (w
);
6117 clear_glyph_matrix (w
->current_matrix
);
6118 w
->window_end_valid
= 0;
6119 windows_or_buffers_changed
++;
6120 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6124 /***********************************************************************
6126 ***********************************************************************/
6128 static struct window
*
6129 set_window_margins (struct window
*w
, Lisp_Object left_width
,
6130 Lisp_Object right_width
)
6134 /* FIXME: what about margins that are too wide? */
6135 left
= (NILP (left_width
) ? 0
6136 : (CHECK_NATNUM (left_width
), XINT (left_width
)));
6137 right
= (NILP (right_width
) ? 0
6138 : (CHECK_NATNUM (right_width
), XINT (right_width
)));
6140 if (w
->left_margin_cols
!= left
|| w
->right_margin_cols
!= right
)
6142 w
->left_margin_cols
= left
;
6143 w
->right_margin_cols
= right
;
6149 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6151 doc
: /* Set width of marginal areas of window WINDOW.
6152 WINDOW must be a live window and defaults to the selected one.
6154 Second arg LEFT-WIDTH specifies the number of character cells to
6155 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6156 does the same for the right marginal area. A nil width parameter
6159 Return t if any margin was actually changed and nil otherwise. */)
6160 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6162 struct window
*w
= set_window_margins (decode_live_window (window
),
6163 left_width
, right_width
);
6164 return w
? (apply_window_adjustment (w
), Qt
) : Qnil
;
6168 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6170 doc
: /* Get width of marginal areas of window WINDOW.
6171 WINDOW must be a live window and defaults to the selected one.
6173 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6174 If a marginal area does not exist, its width will be returned
6176 (Lisp_Object window
)
6178 struct window
*w
= decode_live_window (window
);
6179 return Fcons (w
->left_margin_cols
? make_number (w
->left_margin_cols
) : Qnil
,
6180 w
->right_margin_cols
? make_number (w
->right_margin_cols
) : Qnil
);
6185 /***********************************************************************
6187 ***********************************************************************/
6189 static struct window
*
6190 set_window_fringes (struct window
*w
, Lisp_Object left_width
,
6191 Lisp_Object right_width
, Lisp_Object outside_margins
)
6193 int left
, right
, outside
= !NILP (outside_margins
);
6195 left
= (NILP (left_width
) ? -1
6196 : (CHECK_NATNUM (left_width
), XINT (left_width
)));
6197 right
= (NILP (right_width
) ? -1
6198 : (CHECK_NATNUM (right_width
), XINT (right_width
)));
6200 /* Do nothing on a tty or if nothing to actually change. */
6201 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6202 && (w
->left_fringe_width
!= left
6203 || w
->right_fringe_width
!= right
6204 || w
->fringes_outside_margins
!= outside
))
6206 w
->left_fringe_width
= left
;
6207 w
->right_fringe_width
= right
;
6208 w
->fringes_outside_margins
= outside
;
6214 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6216 doc
: /* Set the fringe widths of window WINDOW.
6217 WINDOW must be a live window and defaults to the selected one.
6219 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6220 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6221 fringe width. If a fringe width arg is nil, that means to use the
6222 frame's default fringe width. Default fringe widths can be set with
6223 the command `set-fringe-style'.
6224 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6225 outside of the display margins. By default, fringes are drawn between
6226 display marginal areas and the text area.
6228 Return t if any fringe was actually changed and nil otherwise. */)
6229 (Lisp_Object window
, Lisp_Object left_width
,
6230 Lisp_Object right_width
, Lisp_Object outside_margins
)
6233 = set_window_fringes (decode_live_window (window
),
6234 left_width
, right_width
, outside_margins
);
6235 return w
? (apply_window_adjustment (w
), Qt
) : Qnil
;
6239 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6241 doc
: /* Get width of fringes of window WINDOW.
6242 WINDOW must be a live window and defaults to the selected one.
6244 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6245 (Lisp_Object window
)
6247 struct window
*w
= decode_live_window (window
);
6249 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6250 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6251 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6256 /***********************************************************************
6258 ***********************************************************************/
6260 static struct window
*
6261 set_window_scroll_bars (struct window
*w
, Lisp_Object width
,
6262 Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6264 int iwidth
= (NILP (width
) ? -1 : (CHECK_NATNUM (width
), XINT (width
)));
6267 vertical_type
= Qnil
;
6269 if (!(NILP (vertical_type
)
6270 || EQ (vertical_type
, Qleft
)
6271 || EQ (vertical_type
, Qright
)
6272 || EQ (vertical_type
, Qt
)))
6273 error ("Invalid type of vertical scroll bar");
6275 if (w
->scroll_bar_width
!= iwidth
6276 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6278 w
->scroll_bar_width
= iwidth
;
6279 wset_vertical_scroll_bar_type (w
, vertical_type
);
6285 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6286 Sset_window_scroll_bars
, 2, 4, 0,
6287 doc
: /* Set width and type of scroll bars of window WINDOW.
6288 WINDOW must be a live window and defaults to the selected one.
6290 Second parameter WIDTH specifies the pixel width for the scroll bar;
6291 this is automatically adjusted to a multiple of the frame column width.
6292 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6293 bar: left, right, or nil.
6294 If WIDTH is nil, use the frame's scroll-bar width.
6295 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6296 Fourth parameter HORIZONTAL-TYPE is currently unused.
6298 Return t if scroll bars was actually changed and nil otherwise. */)
6299 (Lisp_Object window
, Lisp_Object width
,
6300 Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6303 = set_window_scroll_bars (decode_live_window (window
),
6304 width
, vertical_type
, horizontal_type
);
6305 return w
? (apply_window_adjustment (w
), Qt
) : Qnil
;
6309 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6311 doc
: /* Get width and type of scroll bars of window WINDOW.
6312 WINDOW must be a live window and defaults to the selected one.
6314 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6315 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6317 (Lisp_Object window
)
6319 struct window
*w
= decode_live_window (window
);
6321 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6322 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6323 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6324 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6325 w
->vertical_scroll_bar_type
, Qnil
);
6330 /***********************************************************************
6332 ***********************************************************************/
6334 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6335 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6336 If WINDOW is omitted or nil, it defaults to the selected window.
6337 Normally, value is a multiple of the canonical character height of WINDOW;
6338 optional second arg PIXELS-P means value is measured in pixels. */)
6339 (Lisp_Object window
, Lisp_Object pixels_p
)
6342 struct window
*w
= decode_live_window (window
);
6343 struct frame
*f
= XFRAME (w
->frame
);
6345 if (FRAME_WINDOW_P (f
))
6346 result
= (NILP (pixels_p
)
6347 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6348 : make_number (-w
->vscroll
));
6350 result
= make_number (0);
6355 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6357 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6358 WINDOW nil means use the selected window. Normally, VSCROLL is a
6359 non-negative multiple of the canonical character height of WINDOW;
6360 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6361 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6362 corresponds to an integral number of pixels. The return value is the
6363 result of this rounding.
6364 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6365 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6367 struct window
*w
= decode_live_window (window
);
6368 struct frame
*f
= XFRAME (w
->frame
);
6370 CHECK_NUMBER_OR_FLOAT (vscroll
);
6372 if (FRAME_WINDOW_P (f
))
6374 int old_dy
= w
->vscroll
;
6376 w
->vscroll
= - (NILP (pixels_p
)
6377 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6378 : XFLOATINT (vscroll
));
6379 w
->vscroll
= min (w
->vscroll
, 0);
6381 if (w
->vscroll
!= old_dy
)
6383 /* Adjust glyph matrix of the frame if the virtual display
6384 area becomes larger than before. */
6385 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6388 /* Prevent redisplay shortcuts. */
6389 XBUFFER (w
->contents
)->prevent_redisplay_optimizations_p
= 1;
6393 return Fwindow_vscroll (window
, pixels_p
);
6397 /* Call FN for all leaf windows on frame F. FN is called with the
6398 first argument being a pointer to the leaf window, and with
6399 additional argument USER_DATA. Stops when FN returns 0. */
6402 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6405 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6406 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6407 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6411 /* Helper function for foreach_window. Call FN for all leaf windows
6412 reachable from W. FN is called with the first argument being a
6413 pointer to the leaf window, and with additional argument USER_DATA.
6414 Stop when FN returns 0. Value is 0 if stopped by FN. */
6417 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6421 for (cont
= 1; w
&& cont
;)
6423 if (WINDOWP (w
->contents
))
6424 cont
= foreach_window_1 (XWINDOW (w
->contents
), fn
, user_data
);
6426 cont
= fn (w
, user_data
);
6428 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6434 /***********************************************************************
6436 ***********************************************************************/
6438 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6439 describe the same state of affairs. This is used by Fequal.
6441 IGNORE_POSITIONS means ignore non-matching scroll positions
6444 This ignores a couple of things like the dedication status of
6445 window, combination_limit and the like. This might have to be
6449 compare_window_configurations (Lisp_Object configuration1
,
6450 Lisp_Object configuration2
,
6451 bool ignore_positions
)
6453 register struct save_window_data
*d1
, *d2
;
6454 struct Lisp_Vector
*sws1
, *sws2
;
6457 CHECK_WINDOW_CONFIGURATION (configuration1
);
6458 CHECK_WINDOW_CONFIGURATION (configuration2
);
6460 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6461 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6462 sws1
= XVECTOR (d1
->saved_windows
);
6463 sws2
= XVECTOR (d2
->saved_windows
);
6465 /* Frame settings must match. */
6466 if (d1
->frame_cols
!= d2
->frame_cols
6467 || d1
->frame_lines
!= d2
->frame_lines
6468 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6469 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6470 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6471 || (!ignore_positions
6472 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6473 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6474 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6475 /* Verify that the two configurations have the same number of windows. */
6476 || sws1
->header
.size
!= sws2
->header
.size
)
6479 for (i
= 0; i
< sws1
->header
.size
; i
++)
6481 struct saved_window
*sw1
, *sw2
;
6483 sw1
= SAVED_WINDOW_N (sws1
, i
);
6484 sw2
= SAVED_WINDOW_N (sws2
, i
);
6487 /* The "current" windows in the two configurations must
6488 correspond to each other. */
6489 EQ (d1
->current_window
, sw1
->window
)
6490 != EQ (d2
->current_window
, sw2
->window
)
6491 /* Windows' buffers must match. */
6492 || !EQ (sw1
->buffer
, sw2
->buffer
)
6493 || !EQ (sw1
->left_col
, sw2
->left_col
)
6494 || !EQ (sw1
->top_line
, sw2
->top_line
)
6495 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6496 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6497 || !EQ (sw1
->display_table
, sw2
->display_table
)
6498 /* The next two disjuncts check the window structure for
6500 || !EQ (sw1
->parent
, sw2
->parent
)
6501 || !EQ (sw1
->prev
, sw2
->prev
)
6502 || (!ignore_positions
6503 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6504 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6505 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6506 || NILP (Fequal (sw1
->start
, sw2
->start
))
6507 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6508 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6509 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6510 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6511 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6512 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6513 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6514 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6515 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6522 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6523 Scompare_window_configurations
, 2, 2, 0,
6524 doc
: /* Compare two window configurations as regards the structure of windows.
6525 This function ignores details such as the values of point and mark
6526 and scrolling positions. */)
6527 (Lisp_Object x
, Lisp_Object y
)
6529 if (compare_window_configurations (x
, y
, 1))
6535 init_window_once (void)
6537 struct frame
*f
= make_initial_frame ();
6538 XSETFRAME (selected_frame
, f
);
6539 Vterminal_frame
= selected_frame
;
6540 minibuf_window
= f
->minibuffer_window
;
6541 selected_window
= f
->selected_window
;
6542 last_nonminibuf_frame
= f
;
6544 window_initialized
= 1;
6550 Vwindow_list
= Qnil
;
6554 syms_of_window (void)
6556 DEFSYM (Qscroll_up
, "scroll-up");
6557 DEFSYM (Qscroll_down
, "scroll-down");
6558 DEFSYM (Qscroll_command
, "scroll-command");
6560 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6561 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6563 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6564 DEFSYM (Qwindowp
, "windowp");
6565 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6566 DEFSYM (Qwindow_live_p
, "window-live-p");
6567 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6568 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6569 DEFSYM (Qdelete_window
, "delete-window");
6570 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6571 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6572 DEFSYM (Qsafe
, "safe");
6573 DEFSYM (Qdisplay_buffer
, "display-buffer");
6574 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6575 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6576 DEFSYM (Qget_mru_window
, "get-mru-window");
6577 DEFSYM (Qwindow_size
, "window-size");
6578 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6579 DEFSYM (Qabove
, "above");
6580 DEFSYM (Qbelow
, "below");
6581 DEFSYM (Qclone_of
, "clone-of");
6583 staticpro (&Vwindow_list
);
6585 minibuf_selected_window
= Qnil
;
6586 staticpro (&minibuf_selected_window
);
6588 window_scroll_pixel_based_preserve_x
= -1;
6589 window_scroll_pixel_based_preserve_y
= -1;
6590 window_scroll_preserve_hpos
= -1;
6591 window_scroll_preserve_vpos
= -1;
6593 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6594 doc
: /* Non-nil means call as function to display a help buffer.
6595 The function is called with one argument, the buffer to be displayed.
6596 Used by `with-output-to-temp-buffer'.
6597 If this function is used, then it must do the entire job of showing
6598 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6599 Vtemp_buffer_show_function
= Qnil
;
6601 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6602 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6603 Vminibuf_scroll_window
= Qnil
;
6605 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6606 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6607 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6608 is displayed in the `mode-line' face. */);
6609 mode_line_in_non_selected_windows
= 1;
6611 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6612 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6613 Vother_window_scroll_buffer
= Qnil
;
6615 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6616 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6617 auto_window_vscroll_p
= 1;
6619 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6620 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6621 next_screen_context_lines
= 2;
6623 DEFVAR_LISP ("scroll-preserve-screen-position",
6624 Vscroll_preserve_screen_position
,
6625 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6626 A value of nil means point does not keep its screen position except
6627 at the scroll margin or window boundary respectively.
6628 A value of t means point keeps its screen position if the scroll
6629 command moved it vertically out of the window, e.g. when scrolling
6631 Any other value means point always keeps its screen position.
6632 Scroll commands should have the `scroll-command' property
6633 on their symbols to be controlled by this variable. */);
6634 Vscroll_preserve_screen_position
= Qnil
;
6636 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6637 doc
: /* Type of marker to use for `window-point'. */);
6638 Vwindow_point_insertion_type
= Qnil
;
6640 DEFVAR_LISP ("window-configuration-change-hook",
6641 Vwindow_configuration_change_hook
,
6642 doc
: /* Functions to call when window configuration changes.
6643 The buffer-local part is run once per window, with the relevant window
6644 selected; while the global part is run only once for the modified frame,
6645 with the relevant frame selected. */);
6646 Vwindow_configuration_change_hook
= Qnil
;
6648 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6649 doc
: /* Non-nil means `recenter' redraws entire frame.
6650 If this option is non-nil, then the `recenter' command with a nil
6651 argument will redraw the entire frame; the special value `tty' causes
6652 the frame to be redrawn only if it is a tty frame. */);
6653 Vrecenter_redisplay
= Qtty
;
6655 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6656 doc
: /* If t, resize window combinations proportionally.
6657 If this variable is nil, splitting a window gets the entire screen space
6658 for displaying the new window from the window to split. Deleting and
6659 resizing a window preferably resizes one adjacent window only.
6661 If this variable is t, splitting a window tries to get the space
6662 proportionally from all windows in the same combination. This also
6663 allows to split a window that is otherwise too small or of fixed size.
6664 Resizing and deleting a window proportionally resize all windows in the
6667 Other values are reserved for future use.
6669 This variable takes no effect if the variable `window-combination-limit' is
6671 Vwindow_combination_resize
= Qnil
;
6673 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6674 doc
: /* If non-nil, splitting a window makes a new parent window.
6675 The following values are recognized:
6677 nil means splitting a window will create a new parent window only if the
6678 window has no parent window or the window shall become part of a
6679 combination orthogonal to the one it is part of.
6681 `window-size' means that splitting a window for displaying a buffer
6682 makes a new parent window provided `display-buffer' is supposed to
6683 explicitly set the window's size due to the presence of a
6684 `window-height' or `window-width' entry in the alist used by
6685 `display-buffer'. Otherwise, this value is handled like nil.
6687 `temp-buffer' means that splitting a window for displaying a temporary
6688 buffer always makes a new parent window. Otherwise, this value is
6691 `display-buffer' means that splitting a window for displaying a buffer
6692 always makes a new parent window. Since temporary buffers are
6693 displayed by the function `display-buffer', this value is stronger
6694 than `temp-buffer'. Splitting a window for other purpose makes a
6695 new parent window only if needed.
6697 t means that splitting a window always creates a new parent window. If
6698 all splits behave this way, each frame's window tree is a binary
6699 tree and every window but the frame's root window has exactly one
6702 Other values are reserved for future use. */);
6703 Vwindow_combination_limit
= Qwindow_size
;
6705 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6706 doc
: /* Alist of persistent window parameters.
6707 This alist specifies which window parameters shall get saved by
6708 `current-window-configuration' and `window-state-get' and subsequently
6709 restored to their previous values by `set-window-configuration' and
6712 The car of each entry of this alist is the symbol specifying the
6713 parameter. The cdr is one of the following:
6715 nil means the parameter is neither saved by `window-state-get' nor by
6716 `current-window-configuration'.
6718 t means the parameter is saved by `current-window-configuration' and,
6719 provided its WRITABLE argument is nil, by `window-state-get'.
6721 The symbol `writable' means the parameter is saved unconditionally by
6722 both `current-window-configuration' and `window-state-get'. Do not use
6723 this value for parameters without read syntax (like windows or frames).
6725 Parameters not saved by `current-window-configuration' or
6726 `window-state-get' are left alone by `set-window-configuration'
6727 respectively are not installed by `window-state-put'. */);
6728 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6730 defsubr (&Sselected_window
);
6731 defsubr (&Sminibuffer_window
);
6732 defsubr (&Swindow_minibuffer_p
);
6733 defsubr (&Swindowp
);
6734 defsubr (&Swindow_valid_p
);
6735 defsubr (&Swindow_live_p
);
6736 defsubr (&Swindow_frame
);
6737 defsubr (&Sframe_root_window
);
6738 defsubr (&Sframe_first_window
);
6739 defsubr (&Sframe_selected_window
);
6740 defsubr (&Sset_frame_selected_window
);
6741 defsubr (&Spos_visible_in_window_p
);
6742 defsubr (&Swindow_line_height
);
6743 defsubr (&Swindow_buffer
);
6744 defsubr (&Swindow_parent
);
6745 defsubr (&Swindow_top_child
);
6746 defsubr (&Swindow_left_child
);
6747 defsubr (&Swindow_next_sibling
);
6748 defsubr (&Swindow_prev_sibling
);
6749 defsubr (&Swindow_combination_limit
);
6750 defsubr (&Sset_window_combination_limit
);
6751 defsubr (&Swindow_use_time
);
6752 defsubr (&Swindow_top_line
);
6753 defsubr (&Swindow_left_column
);
6754 defsubr (&Swindow_total_height
);
6755 defsubr (&Swindow_total_width
);
6756 defsubr (&Swindow_normal_size
);
6757 defsubr (&Swindow_new_total
);
6758 defsubr (&Swindow_new_normal
);
6759 defsubr (&Sset_window_new_total
);
6760 defsubr (&Sset_window_new_normal
);
6761 defsubr (&Swindow_resize_apply
);
6762 defsubr (&Swindow_body_height
);
6763 defsubr (&Swindow_body_width
);
6764 defsubr (&Swindow_hscroll
);
6765 defsubr (&Sset_window_hscroll
);
6766 defsubr (&Swindow_redisplay_end_trigger
);
6767 defsubr (&Sset_window_redisplay_end_trigger
);
6768 defsubr (&Swindow_edges
);
6769 defsubr (&Swindow_pixel_edges
);
6770 defsubr (&Swindow_absolute_pixel_edges
);
6771 defsubr (&Swindow_inside_edges
);
6772 defsubr (&Swindow_inside_pixel_edges
);
6773 defsubr (&Swindow_inside_absolute_pixel_edges
);
6774 defsubr (&Scoordinates_in_window_p
);
6775 defsubr (&Swindow_at
);
6776 defsubr (&Swindow_point
);
6777 defsubr (&Swindow_start
);
6778 defsubr (&Swindow_end
);
6779 defsubr (&Sset_window_point
);
6780 defsubr (&Sset_window_start
);
6781 defsubr (&Swindow_dedicated_p
);
6782 defsubr (&Sset_window_dedicated_p
);
6783 defsubr (&Swindow_display_table
);
6784 defsubr (&Sset_window_display_table
);
6785 defsubr (&Snext_window
);
6786 defsubr (&Sprevious_window
);
6787 defsubr (&Sget_buffer_window
);
6788 defsubr (&Sdelete_other_windows_internal
);
6789 defsubr (&Sdelete_window_internal
);
6790 defsubr (&Sresize_mini_window_internal
);
6791 defsubr (&Sset_window_buffer
);
6792 defsubr (&Srun_window_configuration_change_hook
);
6793 defsubr (&Sselect_window
);
6794 defsubr (&Sforce_window_update
);
6795 defsubr (&Ssplit_window_internal
);
6796 defsubr (&Sscroll_up
);
6797 defsubr (&Sscroll_down
);
6798 defsubr (&Sscroll_left
);
6799 defsubr (&Sscroll_right
);
6800 defsubr (&Sother_window_for_scrolling
);
6801 defsubr (&Sscroll_other_window
);
6802 defsubr (&Sminibuffer_selected_window
);
6803 defsubr (&Srecenter
);
6804 defsubr (&Swindow_text_height
);
6805 defsubr (&Smove_to_window_line
);
6806 defsubr (&Swindow_configuration_p
);
6807 defsubr (&Swindow_configuration_frame
);
6808 defsubr (&Sset_window_configuration
);
6809 defsubr (&Scurrent_window_configuration
);
6810 defsubr (&Sset_window_margins
);
6811 defsubr (&Swindow_margins
);
6812 defsubr (&Sset_window_fringes
);
6813 defsubr (&Swindow_fringes
);
6814 defsubr (&Sset_window_scroll_bars
);
6815 defsubr (&Swindow_scroll_bars
);
6816 defsubr (&Swindow_vscroll
);
6817 defsubr (&Sset_window_vscroll
);
6818 defsubr (&Scompare_window_configurations
);
6819 defsubr (&Swindow_list
);
6820 defsubr (&Swindow_list_1
);
6821 defsubr (&Swindow_prev_buffers
);
6822 defsubr (&Sset_window_prev_buffers
);
6823 defsubr (&Swindow_next_buffers
);
6824 defsubr (&Sset_window_next_buffers
);
6825 defsubr (&Swindow_parameters
);
6826 defsubr (&Swindow_parameter
);
6827 defsubr (&Sset_window_parameter
);
6831 keys_of_window (void)
6833 initial_define_key (control_x_map
, '<', "scroll-left");
6834 initial_define_key (control_x_map
, '>', "scroll-right");
6836 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6837 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6838 initial_define_key (meta_map
, 'v', "scroll-down-command");