1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2011
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
35 #include "dispextern.h"
36 #include "blockinput.h"
37 #include "intervals.h"
38 #include "termhooks.h" /* For FRAME_TERMINAL. */
42 #endif /* HAVE_X_WINDOWS */
53 Lisp_Object Qwindowp
, Qwindow_live_p
;
54 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
55 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
56 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
57 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
58 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
59 static Lisp_Object Qsafe
, Qabove
, Qbelow
;
60 static Lisp_Object Qauto_buffer_name
;
62 static int displayed_window_lines (struct window
*);
63 static struct window
*decode_window (Lisp_Object
);
64 static int count_windows (struct window
*);
65 static int get_leaf_windows (struct window
*, struct window
**, int);
66 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
67 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
68 static void window_scroll_line_based (Lisp_Object
, int, int, int);
69 static int freeze_window_start (struct window
*, void *);
70 static Lisp_Object
window_list (void);
71 static int add_window_to_list (struct window
*, void *);
72 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
74 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
76 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
78 static void foreach_window (struct frame
*,
79 int (* fn
) (struct window
*, void *),
81 static int foreach_window_1 (struct window
*,
82 int (* fn
) (struct window
*, void *),
84 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
85 static int window_resize_check (struct window
*, int);
86 static void window_resize_apply (struct window
*, int);
87 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
89 /* This is the window in which the terminal's cursor should
90 be left when nothing is being done with it. This must
91 always be a leaf window, and its buffer is selected by
92 the top level editing loop at the end of each command.
94 This value is always the same as
95 FRAME_SELECTED_WINDOW (selected_frame). */
96 Lisp_Object selected_window
;
98 /* A list of all windows for use by next_window and Fwindow_list.
99 Functions creating or deleting windows should invalidate this cache
100 by setting it to nil. */
101 Lisp_Object Vwindow_list
;
103 /* The mini-buffer window of the selected frame.
104 Note that you cannot test for mini-bufferness of an arbitrary window
105 by comparing against this; but you can test for mini-bufferness of
106 the selected window. */
107 Lisp_Object minibuf_window
;
109 /* Non-nil means it is the window whose mode line should be
110 shown as the selected window when the minibuffer is selected. */
111 Lisp_Object minibuf_selected_window
;
113 /* Hook run at end of temp_output_buffer_show. */
114 static Lisp_Object Qtemp_buffer_show_hook
;
116 /* Incremented for each window created. */
117 static int sequence_number
;
119 /* Nonzero after init_window_once has finished. */
120 static int window_initialized
;
122 /* Hook to run when window config changes. */
123 static Lisp_Object Qwindow_configuration_change_hook
;
125 /* Used by the function window_scroll_pixel_based */
126 static int window_scroll_pixel_based_preserve_x
;
127 static int window_scroll_pixel_based_preserve_y
;
129 /* Same for window_scroll_line_based. */
130 static EMACS_INT window_scroll_preserve_hpos
;
131 static EMACS_INT window_scroll_preserve_vpos
;
133 static struct window
*
134 decode_window (register Lisp_Object window
)
137 return XWINDOW (selected_window
);
139 CHECK_LIVE_WINDOW (window
);
140 return XWINDOW (window
);
143 static struct window
*
144 decode_any_window (register Lisp_Object window
)
147 return XWINDOW (selected_window
);
149 CHECK_WINDOW (window
);
150 return XWINDOW (window
);
153 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
154 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
157 return WINDOWP (object
) ? Qt
: Qnil
;
160 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
161 doc
: /* Return t if OBJECT is a live window and nil otherwise.
162 A live window is a window that displays a buffer. */)
165 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
168 /* Frames and windows. */
169 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
170 doc
: /* Return the frame that window WINDOW is on.
171 WINDOW can be any window and defaults to the selected one. */)
174 return decode_any_window (window
)->frame
;
177 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
178 doc
: /* Return the root window of FRAME-OR-WINDOW.
179 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
180 Else if FRAME-OR-WINDOW denotes any window, return the root window of
181 that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
182 the root window of that frame. */)
183 (Lisp_Object frame_or_window
)
187 if (NILP (frame_or_window
))
188 window
= SELECTED_FRAME ()->root_window
;
189 else if (WINDOWP (frame_or_window
))
190 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
193 CHECK_LIVE_FRAME (frame_or_window
);
194 window
= XFRAME (frame_or_window
)->root_window
;
200 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
201 doc
: /* Return the window used now for minibuffers.
202 If the optional argument FRAME is specified, return the minibuffer window
203 used by that frame. */)
207 frame
= selected_frame
;
208 CHECK_LIVE_FRAME (frame
);
209 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
212 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
213 Swindow_minibuffer_p
, 0, 1, 0,
214 doc
: /* Return non-nil if WINDOW is a minibuffer window.
215 WINDOW can be any window and defaults to the selected one. */)
218 return MINI_WINDOW_P (decode_any_window (window
)) ? Qt
: Qnil
;
221 /* Don't move this to window.el - this must be a safe routine. */
222 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
223 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
224 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
225 Else if FRAME-OR-WINDOW denotes any window, return the first window of
226 that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
227 the first window of that frame. */)
228 (Lisp_Object frame_or_window
)
232 if (NILP (frame_or_window
))
233 window
= SELECTED_FRAME ()->root_window
;
234 else if (WINDOWP (frame_or_window
))
235 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
238 CHECK_LIVE_FRAME (frame_or_window
);
239 window
= XFRAME (frame_or_window
)->root_window
;
242 while (NILP (XWINDOW (window
)->buffer
))
244 if (! NILP (XWINDOW (window
)->hchild
))
245 window
= XWINDOW (window
)->hchild
;
246 else if (! NILP (XWINDOW (window
)->vchild
))
247 window
= XWINDOW (window
)->vchild
;
255 DEFUN ("frame-selected-window", Fframe_selected_window
,
256 Sframe_selected_window
, 0, 1, 0,
257 doc
: /* Return the selected window of FRAME-OR-WINDOW.
258 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
259 Else if FRAME-OR-WINDOW denotes any window, return the selected window
260 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
261 the selected window of that frame. */)
262 (Lisp_Object frame_or_window
)
266 if (NILP (frame_or_window
))
267 window
= SELECTED_FRAME ()->selected_window
;
268 else if (WINDOWP (frame_or_window
))
269 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
272 CHECK_LIVE_FRAME (frame_or_window
);
273 window
= XFRAME (frame_or_window
)->selected_window
;
279 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
280 Sset_frame_selected_window
, 2, 3, 0,
281 doc
: /* Set selected window of FRAME to WINDOW.
282 FRAME must be a live frame and defaults to the selected one. If FRAME
283 is the selected frame, this makes WINDOW the selected window. Optional
284 argument NORECORD non-nil means to neither change the order of recently
285 selected windows nor the buffer list. WINDOW must denote a live window.
287 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
290 frame
= selected_frame
;
292 CHECK_LIVE_FRAME (frame
);
293 CHECK_LIVE_WINDOW (window
);
295 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
296 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
298 if (EQ (frame
, selected_frame
))
299 return Fselect_window (window
, norecord
);
301 return XFRAME (frame
)->selected_window
= window
;
304 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
305 doc
: /* Return the selected window.
306 The selected window is the window in which the standard cursor for
307 selected windows appears and to which many commands apply. */)
310 return selected_window
;
313 int window_select_count
;
315 /* If select_window is called with inhibit_point_swap non-zero it will
316 not store point of the old selected window's buffer back into that
317 window's pointm slot. This is needed by Fset_window_configuration to
318 avoid that the display routine is called with selected_window set to
319 Qnil causing a subsequent crash. */
321 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
323 register struct window
*w
;
324 register struct window
*ow
;
327 CHECK_LIVE_WINDOW (window
);
329 w
= XWINDOW (window
);
330 w
->frozen_window_start_p
= 0;
334 ++window_select_count
;
335 XSETFASTINT (w
->use_time
, window_select_count
);
336 record_buffer (w
->buffer
);
339 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
342 sf
= SELECTED_FRAME ();
343 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
345 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
346 /* Use this rather than Fhandle_switch_frame
347 so that FRAME_FOCUS_FRAME is moved appropriately as we
348 move around in the state where a minibuffer in a separate
350 Fselect_frame (WINDOW_FRAME (w
), norecord
);
351 /* Fselect_frame called us back so we've done all the work already. */
352 eassert (EQ (window
, selected_window
));
356 sf
->selected_window
= window
;
358 /* Store the current buffer's actual point into the
359 old selected window. It belongs to that window,
360 and when the window is not selected, must be in the window. */
361 if (!inhibit_point_swap
)
363 ow
= XWINDOW (selected_window
);
364 if (! NILP (ow
->buffer
))
365 set_marker_both (ow
->pointm
, ow
->buffer
,
366 BUF_PT (XBUFFER (ow
->buffer
)),
367 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
370 selected_window
= window
;
372 Fset_buffer (w
->buffer
);
374 BVAR (XBUFFER (w
->buffer
), last_selected_window
) = window
;
376 /* Go to the point recorded in the window.
377 This is important when the buffer is in more
378 than one window. It also matters when
379 redisplay_window has altered point after scrolling,
380 because it makes the change only in the window. */
382 register ptrdiff_t new_point
= marker_position (w
->pointm
);
383 if (new_point
< BEGV
)
385 else if (new_point
> ZV
)
391 windows_or_buffers_changed
++;
395 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
396 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
397 Also make WINDOW's buffer current and make WINDOW the frame's selected
398 window. Return WINDOW.
400 Optional second arg NORECORD non-nil means do not put this buffer at the
401 front of the buffer list and do not make this window the most recently
404 Note that the main editor command loop sets the current buffer to the
405 buffer of the selected window before each command. */)
406 (register Lisp_Object window
, Lisp_Object norecord
)
408 return select_window (window
, norecord
, 0);
411 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
412 doc
: /* Return the buffer that WINDOW is displaying.
413 WINDOW can be any window and defaults to the selected one.
414 If WINDOW is an internal window return nil. */)
417 return decode_any_window (window
)->buffer
;
420 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
421 doc
: /* Return WINDOW's parent window.
422 WINDOW can be any window and defaults to the selected one.
423 Return nil if WINDOW has no parent. */)
426 return decode_any_window (window
)->parent
;
429 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
430 doc
: /* Return WINDOW's topmost child window.
431 WINDOW can be any window and defaults to the selected one.
432 Return nil if WINDOW is not a vertical combination. */)
435 return decode_any_window (window
)->vchild
;
438 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
439 doc
: /* Return WINDOW's leftmost child window.
440 WINDOW can be any window and defaults to the selected one.
441 Return nil if WINDOW is not a horizontal combination. */)
444 return decode_any_window (window
)->hchild
;
447 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
448 doc
: /* Return WINDOW's next sibling window.
449 WINDOW can be any window and defaults to the selected one.
450 Return nil if WINDOW has no next sibling. */)
453 return decode_any_window (window
)->next
;
456 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
457 doc
: /* Return WINDOW's previous sibling window.
458 WINDOW can be any window and defaults to the selected one.
459 Return nil if WINDOW has no previous sibling. */)
462 return decode_any_window (window
)->prev
;
465 DEFUN ("window-splits", Fwindow_splits
, Swindow_splits
, 0, 1, 0,
466 doc
: /* Return splits status for WINDOW.
467 WINDOW can be any window and defaults to the selected one.
469 If the value returned by this function is nil and WINDOW is resized, the
470 corresponding space is preferably taken from (or given to) WINDOW's
471 right sibling. When WINDOW is deleted, its space is given to its left
474 If the value returned by this function is non-nil, resizing and deleting
475 WINDOW may resize all windows in the same combination. */)
478 return decode_any_window (window
)->splits
;
481 DEFUN ("set-window-splits", Fset_window_splits
, Sset_window_splits
, 2, 2, 0,
482 doc
: /* Set splits status of WINDOW to STATUS.
483 WINDOW can be any window and defaults to the selected one. Return
486 If STATUS is nil and WINDOW is later resized, the corresponding space is
487 preferably taken from (or given to) WINDOW's right sibling. When WINDOW
488 is deleted, its space is given to its left sibling.
490 If STATUS is non-nil, resizing and deleting WINDOW may resize all
491 windows in the same combination. */)
492 (Lisp_Object window
, Lisp_Object status
)
494 register struct window
*w
= decode_any_window (window
);
501 DEFUN ("window-nest", Fwindow_nest
, Swindow_nest
, 0, 1, 0,
502 doc
: /* Return nest status of WINDOW.
503 WINDOW can be any window and defaults to the selected one.
505 If the return value is nil, subwindows of WINDOW can be recombined with
506 WINDOW's siblings. A return value of non-nil means that subwindows of
507 WINDOW are never \(re-)combined with WINDOW's siblings. */)
510 return decode_any_window (window
)->nest
;
513 DEFUN ("set-window-nest", Fset_window_nest
, Sset_window_nest
, 2, 2, 0,
514 doc
: /* Set nest status of WINDOW to STATUS.
515 WINDOW can be any window and defaults to the selected one. Return
518 If STATUS is nil, subwindows of WINDOW can be recombined with WINDOW's
519 siblings. STATUS non-nil means that subwindows of WINDOW are never
520 \(re-)combined with WINDOW's siblings. */)
521 (Lisp_Object window
, Lisp_Object status
)
523 register struct window
*w
= decode_any_window (window
);
530 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
531 doc
: /* Return WINDOW's use time.
532 WINDOW defaults to the selected window. The window with the highest use
533 time is the most recently selected one. The window with the lowest use
534 time is the least recently selected one. */)
537 return decode_window (window
)->use_time
;
540 DEFUN ("window-total-size", Fwindow_total_size
, Swindow_total_size
, 0, 2, 0,
541 doc
: /* Return the total number of lines of WINDOW.
542 WINDOW can be any window and defaults to the selected one. The return
543 value includes WINDOW's mode line and header line, if any. If WINDOW
544 is internal, the return value is the sum of the total number of lines
545 of WINDOW's child windows if these are vertically combined and the
546 height of WINDOW's first child otherwise.
548 Optional argument HORIZONTAL non-nil means return the total number of
549 columns of WINDOW. In this case the return value includes any vertical
550 dividers or scrollbars of WINDOW. If WINDOW is internal, the return
551 value is the sum of the total number of columns of WINDOW's child
552 windows if they are horizontally combined and the width of WINDOW's
553 first child otherwise. */)
554 (Lisp_Object window
, Lisp_Object horizontal
)
556 if (NILP (horizontal
))
557 return decode_any_window (window
)->total_lines
;
559 return decode_any_window (window
)->total_cols
;
562 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
563 doc
: /* Return new total size of WINDOW.
564 WINDOW defaults to the selected window. */)
567 return decode_any_window (window
)->new_total
;
570 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
571 doc
: /* Return normal height of WINDOW.
572 WINDOW can be any window and defaults to the selected one. Optional
573 argument HORIZONTAL non-nil means return normal width of WINDOW. */)
574 (Lisp_Object window
, Lisp_Object horizontal
)
576 if (NILP (horizontal
))
577 return decode_any_window (window
)->normal_lines
;
579 return decode_any_window (window
)->normal_cols
;
582 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
583 doc
: /* Return new normal size of WINDOW.
584 WINDOW can be any window and defaults to the selected one. */)
587 return decode_any_window (window
)->new_normal
;
590 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
591 doc
: /* Return left column of WINDOW.
592 WINDOW can be any window and defaults to the selected one. */)
595 return decode_any_window (window
)->left_col
;
598 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
599 doc
: /* Return top line of WINDOW.
600 WINDOW can be any window and defaults to the selected one. */)
603 return decode_any_window (window
)->top_line
;
606 /* Return the number of lines of W's body. Don't count any mode or
610 window_body_lines (struct window
*w
)
612 int height
= XFASTINT (w
->total_lines
);
614 if (!MINI_WINDOW_P (w
))
616 if (WINDOW_WANTS_MODELINE_P (w
))
618 if (WINDOW_WANTS_HEADER_LINE_P (w
))
625 /* Return the number of columns of W's body. Don't count columns
626 occupied by the scroll bar or the vertical bar separating W from its
627 right sibling. On window-systems don't count fringes or display
631 window_body_cols (struct window
*w
)
633 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
634 int width
= XINT (w
->total_cols
);
636 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
637 /* Scroll bars occupy a few columns. */
638 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
639 else if (!FRAME_WINDOW_P (f
)
640 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
641 /* The column of `|' characters separating side-by-side windows
642 occupies one column only. */
645 if (FRAME_WINDOW_P (f
))
646 /* On window-systems, fringes and display margins cannot be
647 used for normal text. */
648 width
-= (WINDOW_FRINGE_COLS (w
)
649 + WINDOW_LEFT_MARGIN_COLS (w
)
650 + WINDOW_RIGHT_MARGIN_COLS (w
));
655 DEFUN ("window-body-size", Fwindow_body_size
, Swindow_body_size
, 0, 2, 0,
656 doc
: /* Return the number of lines of WINDOW's body.
657 WINDOW must be a live window and defaults to the selected one. The
658 return value does not include WINDOW's mode line and header line, if
661 Optional argument HORIZONTAL non-nil means return the number of columns
662 of WINDOW's body. In this case, the return value does not include any
663 vertical dividers or scroll bars owned by WINDOW. On a window-system
664 the return value does not include the number of columns used for
665 WINDOW's fringes or display margins either. */)
666 (Lisp_Object window
, Lisp_Object horizontal
)
668 struct window
*w
= decode_any_window (window
);
670 if (NILP (horizontal
))
671 return make_number (window_body_lines (w
));
673 return make_number (window_body_cols (w
));
676 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
677 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
678 WINDOW must be a live window and defaults to the selected one. */)
681 return decode_window (window
)->hscroll
;
684 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
685 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
686 If WINDOW is nil, the selected window is used.
687 Return NCOL. NCOL should be zero or positive.
689 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
690 window so that the location of point moves off-window. */)
691 (Lisp_Object window
, Lisp_Object ncol
)
693 struct window
*w
= decode_window (window
);
697 hscroll
= clip_to_bounds (0, XINT (ncol
), PTRDIFF_MAX
);
699 /* Prevent redisplay shortcuts when changing the hscroll. */
700 if (XINT (w
->hscroll
) != hscroll
)
701 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
703 w
->hscroll
= make_number (hscroll
);
707 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
708 Swindow_redisplay_end_trigger
, 0, 1, 0,
709 doc
: /* Return WINDOW's redisplay end trigger value.
710 WINDOW defaults to the selected window.
711 See `set-window-redisplay-end-trigger' for more information. */)
714 return decode_window (window
)->redisplay_end_trigger
;
717 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
718 Sset_window_redisplay_end_trigger
, 2, 2, 0,
719 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
720 VALUE should be a buffer position (typically a marker) or nil.
721 If it is a buffer position, then if redisplay in WINDOW reaches a position
722 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
723 with two arguments: WINDOW, and the end trigger value.
724 Afterwards the end-trigger value is reset to nil. */)
725 (register Lisp_Object window
, Lisp_Object value
)
727 register struct window
*w
;
729 w
= decode_window (window
);
730 w
->redisplay_end_trigger
= value
;
734 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
735 doc
: /* Return a list of the edge coordinates of WINDOW.
736 The list has the form (LEFT TOP RIGHT BOTTOM).
737 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
738 all relative to 0, 0 at top left corner of frame.
740 RIGHT is one more than the rightmost column occupied by WINDOW.
741 BOTTOM is one more than the bottommost row occupied by WINDOW.
742 The edges include the space used by WINDOW's scroll bar, display
743 margins, fringes, header line, and/or mode line. For the edges of
744 just the text area, use `window-inside-edges'. */)
747 register struct window
*w
= decode_any_window (window
);
749 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
750 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
751 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
752 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
756 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
757 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
758 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
759 the top left corner of the frame.
761 RIGHT is one more than the rightmost x position occupied by WINDOW.
762 BOTTOM is one more than the bottommost y position occupied by WINDOW.
763 The pixel edges include the space used by WINDOW's scroll bar, display
764 margins, fringes, header line, and/or mode line. For the pixel edges
765 of just the text area, use `window-inside-pixel-edges'. */)
768 register struct window
*w
= decode_any_window (window
);
770 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
771 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
772 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
773 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
778 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
780 struct frame
*f
= XFRAME (w
->frame
);
782 #ifdef FRAME_MENUBAR_HEIGHT
783 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
785 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
786 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
787 #elif FRAME_TOOLBAR_HEIGHT
788 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
790 #ifdef FRAME_NS_TITLEBAR_HEIGHT
791 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
793 *add_x
= f
->left_pos
;
794 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
795 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
799 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
800 Swindow_absolute_pixel_edges
, 0, 1, 0,
801 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
802 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
803 the top left corner of the display.
805 RIGHT is one more than the rightmost x position occupied by WINDOW.
806 BOTTOM is one more than the bottommost y position occupied by WINDOW.
807 The pixel edges include the space used by WINDOW's scroll bar, display
808 margins, fringes, header line, and/or mode line. For the pixel edges
809 of just the text area, use `window-inside-absolute-pixel-edges'. */)
812 register struct window
*w
= decode_any_window (window
);
814 calc_absolute_offset (w
, &add_x
, &add_y
);
816 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
817 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
818 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
819 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
823 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
824 doc
: /* Return a list of the edge coordinates of WINDOW.
825 The list has the form (LEFT TOP RIGHT BOTTOM).
826 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
827 all relative to 0, 0 at top left corner of frame.
829 RIGHT is one more than the rightmost column of WINDOW's text area.
830 BOTTOM is one more than the bottommost row of WINDOW's text area.
831 The inside edges do not include the space used by the WINDOW's scroll
832 bar, display margins, fringes, header line, and/or mode line. */)
835 register struct window
*w
= decode_any_window (window
);
837 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
838 + WINDOW_LEFT_MARGIN_COLS (w
)
839 + WINDOW_LEFT_FRINGE_COLS (w
)),
840 make_number (WINDOW_TOP_EDGE_LINE (w
)
841 + WINDOW_HEADER_LINE_LINES (w
)),
842 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
843 - WINDOW_RIGHT_MARGIN_COLS (w
)
844 - WINDOW_RIGHT_FRINGE_COLS (w
)),
845 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
846 - WINDOW_MODE_LINE_LINES (w
)));
849 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
850 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
851 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
852 the top left corner of the frame.
854 RIGHT is one more than the rightmost x position of WINDOW's text area.
855 BOTTOM is one more than the bottommost y position of WINDOW's text area.
856 The inside edges do not include the space used by WINDOW's scroll bar,
857 display margins, fringes, header line, and/or mode line. */)
860 register struct window
*w
= decode_any_window (window
);
862 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
863 + WINDOW_LEFT_MARGIN_WIDTH (w
)
864 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
865 make_number (WINDOW_TOP_EDGE_Y (w
)
866 + WINDOW_HEADER_LINE_HEIGHT (w
)),
867 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
868 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
869 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
870 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
871 - WINDOW_MODE_LINE_HEIGHT (w
)));
874 DEFUN ("window-inside-absolute-pixel-edges",
875 Fwindow_inside_absolute_pixel_edges
,
876 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
877 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
878 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
879 the top left corner of the display.
881 RIGHT is one more than the rightmost x position of WINDOW's text area.
882 BOTTOM is one more than the bottommost y position of WINDOW's text area.
883 The inside edges do not include the space used by WINDOW's scroll bar,
884 display margins, fringes, header line, and/or mode line. */)
887 register struct window
*w
= decode_any_window (window
);
889 calc_absolute_offset (w
, &add_x
, &add_y
);
891 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
892 + WINDOW_LEFT_MARGIN_WIDTH (w
)
893 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
894 make_number (WINDOW_TOP_EDGE_Y (w
)
895 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
896 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
897 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
898 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
899 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
900 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
903 /* Test if the character at column X, row Y is within window W.
904 If it is not, return ON_NOTHING;
905 if it is in the window's text area, return ON_TEXT;
906 if it is on the window's modeline, return ON_MODE_LINE;
907 if it is on the border between the window and its right sibling,
908 return ON_VERTICAL_BORDER.
909 if it is on a scroll bar, return ON_SCROLL_BAR.
910 if it is on the window's top line, return ON_HEADER_LINE;
911 if it is in left or right fringe of the window,
912 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
913 if it is in the marginal area to the left/right of the window,
914 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
916 X and Y are frame relative pixel coordinates. */
918 static enum window_part
919 coordinates_in_window (register struct window
*w
, int x
, int y
)
921 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
922 enum window_part part
;
923 int ux
= FRAME_COLUMN_WIDTH (f
);
924 int left_x
= WINDOW_LEFT_EDGE_X (w
);
925 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
926 int top_y
= WINDOW_TOP_EDGE_Y (w
);
927 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
928 /* The width of the area where the vertical line can be dragged.
929 (Between mode lines for instance. */
930 int grabbable_width
= ux
;
931 int lmargin_width
, rmargin_width
, text_left
, text_right
;
933 /* Outside any interesting row or column? */
934 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
937 /* On the mode line or header line? */
938 if ((WINDOW_WANTS_MODELINE_P (w
)
939 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
940 && (part
= ON_MODE_LINE
))
941 || (WINDOW_WANTS_HEADER_LINE_P (w
)
942 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
943 && (part
= ON_HEADER_LINE
)))
945 /* If it's under/over the scroll bar portion of the mode/header
946 line, say it's on the vertical line. That's to be able to
947 resize windows horizontally in case we're using toolkit scroll
948 bars. Note: If scrollbars are on the left, the window that
949 must be eventually resized is that on the left of WINDOW. */
950 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
951 && !WINDOW_LEFTMOST_P (w
)
952 && eabs (x
- left_x
) < grabbable_width
)
953 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
954 && !WINDOW_RIGHTMOST_P (w
)
955 && eabs (x
- right_x
) < grabbable_width
))
956 return ON_VERTICAL_BORDER
;
961 /* In what's below, we subtract 1 when computing right_x because we
962 want the rightmost pixel, which is given by left_pixel+width-1. */
963 if (w
->pseudo_window_p
)
966 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
970 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
971 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
974 /* Outside any interesting column? */
975 if (x
< left_x
|| x
> right_x
)
976 return ON_SCROLL_BAR
;
978 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
979 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
981 text_left
= window_box_left (w
, TEXT_AREA
);
982 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
984 if (FRAME_WINDOW_P (f
))
986 if (!w
->pseudo_window_p
987 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
988 && !WINDOW_RIGHTMOST_P (w
)
989 && (eabs (x
- right_x
) < grabbable_width
))
990 return ON_VERTICAL_BORDER
;
992 /* Need to say "x > right_x" rather than >=, since on character
993 terminals, the vertical line's x coordinate is right_x. */
994 else if (!w
->pseudo_window_p
995 && !WINDOW_RIGHTMOST_P (w
)
997 return ON_VERTICAL_BORDER
;
1001 if (lmargin_width
> 0
1002 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1003 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1004 : (x
< left_x
+ lmargin_width
)))
1005 return ON_LEFT_MARGIN
;
1007 return ON_LEFT_FRINGE
;
1010 if (x
>= text_right
)
1012 if (rmargin_width
> 0
1013 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1014 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1015 : (x
>= right_x
- rmargin_width
)))
1016 return ON_RIGHT_MARGIN
;
1018 return ON_RIGHT_FRINGE
;
1021 /* Everything special ruled out - must be on text area */
1025 /* Take X is the frame-relative pixel x-coordinate, and return the
1026 x-coordinate relative to part PART of window W. */
1028 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1030 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1035 return x
- window_box_left (w
, TEXT_AREA
);
1037 case ON_LEFT_FRINGE
:
1040 case ON_RIGHT_FRINGE
:
1041 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1043 case ON_LEFT_MARGIN
:
1045 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1046 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1048 case ON_RIGHT_MARGIN
:
1050 - ((w
->pseudo_window_p
)
1051 ? WINDOW_TOTAL_WIDTH (w
)
1052 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1053 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1054 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1055 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1058 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1063 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1064 Scoordinates_in_window_p
, 2, 2, 0,
1065 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1066 COORDINATES is a cons of the form (X . Y), X and Y being distances
1067 measured in characters from the upper-left corner of the frame.
1068 \(0 . 0) denotes the character in the upper left corner of the
1070 If COORDINATES are in the text portion of WINDOW,
1071 the coordinates relative to the window are returned.
1072 If they are in the mode line of WINDOW, `mode-line' is returned.
1073 If they are in the top mode line of WINDOW, `header-line' is returned.
1074 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1075 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1076 If they are on the border between WINDOW and its right sibling,
1077 `vertical-line' is returned.
1078 If they are in the windows's left or right marginal areas, `left-margin'\n\
1079 or `right-margin' is returned. */)
1080 (register Lisp_Object coordinates
, Lisp_Object window
)
1087 CHECK_WINDOW (window
);
1088 w
= XWINDOW (window
);
1089 f
= XFRAME (w
->frame
);
1090 CHECK_CONS (coordinates
);
1091 lx
= Fcar (coordinates
);
1092 ly
= Fcdr (coordinates
);
1093 CHECK_NUMBER_OR_FLOAT (lx
);
1094 CHECK_NUMBER_OR_FLOAT (ly
);
1095 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1096 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1098 switch (coordinates_in_window (w
, x
, y
))
1104 /* Convert X and Y to window relative pixel coordinates, and
1105 return the canonical char units. */
1106 x
-= window_box_left (w
, TEXT_AREA
);
1107 y
-= WINDOW_TOP_EDGE_Y (w
);
1108 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1109 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1114 case ON_VERTICAL_BORDER
:
1115 return Qvertical_line
;
1117 case ON_HEADER_LINE
:
1118 return Qheader_line
;
1120 case ON_LEFT_FRINGE
:
1121 return Qleft_fringe
;
1123 case ON_RIGHT_FRINGE
:
1124 return Qright_fringe
;
1126 case ON_LEFT_MARGIN
:
1127 return Qleft_margin
;
1129 case ON_RIGHT_MARGIN
:
1130 return Qright_margin
;
1133 /* Historically we are supposed to return nil in this case. */
1142 /* Callback for foreach_window, used in window_from_coordinates.
1143 Check if window W contains coordinates specified by USER_DATA which
1144 is actually a pointer to a struct check_window_data CW.
1146 Check if window W contains coordinates *CW->x and *CW->y. If it
1147 does, return W in *CW->window, as Lisp_Object, and return in
1148 *CW->part the part of the window under coordinates *X,*Y. Return
1149 zero from this function to stop iterating over windows. */
1151 struct check_window_data
1153 Lisp_Object
*window
;
1155 enum window_part
*part
;
1159 check_window_containing (struct window
*w
, void *user_data
)
1161 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1162 enum window_part found
;
1165 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1166 if (found
!= ON_NOTHING
)
1169 XSETWINDOW (*cw
->window
, w
);
1177 /* Find the window containing frame-relative pixel position X/Y and
1178 return it as a Lisp_Object.
1180 If X, Y is on one of the window's special `window_part' elements,
1181 set *PART to the id of that element.
1183 If there is no window under X, Y return nil and leave *PART
1184 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1186 This function was previously implemented with a loop cycling over
1187 windows with Fnext_window, and starting with the frame's selected
1188 window. It turned out that this doesn't work with an
1189 implementation of next_window using Vwindow_list, because
1190 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1191 tree of F when this function is called asynchronously from
1192 note_mouse_highlight. The original loop didn't terminate in this
1196 window_from_coordinates (struct frame
*f
, int x
, int y
,
1197 enum window_part
*part
, int tool_bar_p
)
1200 struct check_window_data cw
;
1201 enum window_part dummy
;
1207 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1208 foreach_window (f
, check_window_containing
, &cw
);
1210 /* If not found above, see if it's in the tool bar window, if a tool
1214 && WINDOWP (f
->tool_bar_window
)
1215 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1216 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1220 window
= f
->tool_bar_window
;
1226 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1227 doc
: /* Return window containing coordinates X and Y on FRAME.
1228 FRAME must be a live frame and defaults to the selected one.
1229 The top left corner of the frame is considered to be row 0,
1231 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1236 frame
= selected_frame
;
1237 CHECK_LIVE_FRAME (frame
);
1240 /* Check that arguments are integers or floats. */
1241 CHECK_NUMBER_OR_FLOAT (x
);
1242 CHECK_NUMBER_OR_FLOAT (y
);
1244 return window_from_coordinates (f
,
1245 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1246 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1247 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1248 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1252 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1253 doc
: /* Return current value of point in WINDOW.
1254 WINDOW must be a live window and defaults to the selected one.
1256 For a nonselected window, this is the value point would have
1257 if that window were selected.
1259 Note that, when WINDOW is the selected window and its buffer
1260 is also currently selected, the value returned is the same as (point).
1261 It would be more strictly correct to return the `top-level' value
1262 of point, outside of any save-excursion forms.
1263 But that is hard to define. */)
1264 (Lisp_Object window
)
1266 register struct window
*w
= decode_window (window
);
1268 if (w
== XWINDOW (selected_window
)
1269 && current_buffer
== XBUFFER (w
->buffer
))
1271 return Fmarker_position (w
->pointm
);
1274 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1275 doc
: /* Return position at which display currently starts in WINDOW.
1276 WINDOW must be a live window and defaults to the selected one.
1277 This is updated by redisplay or by calling `set-window-start'. */)
1278 (Lisp_Object window
)
1280 return Fmarker_position (decode_window (window
)->start
);
1283 /* This is text temporarily removed from the doc string below.
1285 This function returns nil if the position is not currently known.
1286 That happens when redisplay is preempted and doesn't finish.
1287 If in that case you want to compute where the end of the window would
1288 have been if redisplay had finished, do this:
1290 (goto-char (window-start window))
1291 (vertical-motion (1- (window-height window)) window)
1294 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1295 doc
: /* Return position at which display currently ends in WINDOW.
1296 WINDOW must be a live window and defaults to the selected one.
1297 This is updated by redisplay, when it runs to completion.
1298 Simply changing the buffer text or setting `window-start'
1299 does not update this value.
1300 Return nil if there is no recorded value. (This can happen if the
1301 last redisplay of WINDOW was preempted, and did not finish.)
1302 If UPDATE is non-nil, compute the up-to-date position
1303 if it isn't already recorded. */)
1304 (Lisp_Object window
, Lisp_Object update
)
1307 struct window
*w
= decode_window (window
);
1315 #if 0 /* This change broke some things. We should make it later. */
1316 /* If we don't know the end position, return nil.
1317 The user can compute it with vertical-motion if he wants to.
1318 It would be nicer to do it automatically,
1319 but that's so slow that it would probably bother people. */
1320 if (NILP (w
->window_end_valid
))
1325 && ! (! NILP (w
->window_end_valid
)
1326 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1327 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1330 struct text_pos startp
;
1332 struct buffer
*old_buffer
= NULL
;
1333 void *itdata
= NULL
;
1335 /* Cannot use Fvertical_motion because that function doesn't
1336 cope with variable-height lines. */
1337 if (b
!= current_buffer
)
1339 old_buffer
= current_buffer
;
1340 set_buffer_internal (b
);
1343 /* In case W->start is out of the range, use something
1344 reasonable. This situation occurred when loading a file with
1345 `-l' containing a call to `rmail' with subsequent other
1346 commands. At the end, W->start happened to be BEG, while
1347 rmail had already narrowed the buffer. */
1348 if (XMARKER (w
->start
)->charpos
< BEGV
)
1349 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1350 else if (XMARKER (w
->start
)->charpos
> ZV
)
1351 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1353 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1355 itdata
= bidi_shelve_cache ();
1356 start_display (&it
, w
, startp
);
1357 move_it_vertically (&it
, window_box_height (w
));
1358 if (it
.current_y
< it
.last_visible_y
)
1359 move_it_past_eol (&it
);
1360 value
= make_number (IT_CHARPOS (it
));
1361 bidi_unshelve_cache (itdata
, 0);
1364 set_buffer_internal (old_buffer
);
1367 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1372 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1373 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1375 (Lisp_Object window
, Lisp_Object pos
)
1377 register struct window
*w
= decode_window (window
);
1379 CHECK_NUMBER_COERCE_MARKER (pos
);
1380 if (w
== XWINDOW (selected_window
)
1381 && XBUFFER (w
->buffer
) == current_buffer
)
1384 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1386 /* We have to make sure that redisplay updates the window to show
1387 the new value of point. */
1388 if (!EQ (window
, selected_window
))
1389 ++windows_or_buffers_changed
;
1394 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1395 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1396 If WINDOW is nil, the selected window is used. Return POS.
1397 Optional third arg NOFORCE non-nil inhibits next redisplay from
1398 overriding motion of point in order to display at this exact start. */)
1399 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1401 register struct window
*w
= decode_window (window
);
1403 CHECK_NUMBER_COERCE_MARKER (pos
);
1404 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1405 /* this is not right, but much easier than doing what is right. */
1406 w
->start_at_line_beg
= Qnil
;
1408 w
->force_start
= Qt
;
1409 w
->update_mode_line
= Qt
;
1410 XSETFASTINT (w
->last_modified
, 0);
1411 XSETFASTINT (w
->last_overlay_modified
, 0);
1412 if (!EQ (window
, selected_window
))
1413 windows_or_buffers_changed
++;
1418 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1419 Spos_visible_in_window_p
, 0, 3, 0,
1420 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1421 Return nil if that position is scrolled vertically out of view.
1422 If a character is only partially visible, nil is returned, unless the
1423 optional argument PARTIALLY is non-nil.
1424 If POS is only out of view because of horizontal scrolling, return non-nil.
1425 If POS is t, it specifies the position of the last visible glyph in WINDOW.
1426 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
1428 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1429 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1430 where X and Y are the pixel coordinates relative to the top left corner
1431 of the window. The remaining elements are omitted if the character after
1432 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1433 off-window at the top and bottom of the row, ROWH is the height of the
1434 display row, and VPOS is the row number (0-based) containing POS. */)
1435 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1437 register struct window
*w
;
1438 register EMACS_INT posint
;
1439 register struct buffer
*buf
;
1440 struct text_pos top
;
1441 Lisp_Object in_window
= Qnil
;
1442 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1445 w
= decode_window (window
);
1446 buf
= XBUFFER (w
->buffer
);
1447 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1451 else if (!NILP (pos
))
1453 CHECK_NUMBER_COERCE_MARKER (pos
);
1454 posint
= XINT (pos
);
1456 else if (w
== XWINDOW (selected_window
))
1459 posint
= XMARKER (w
->pointm
)->charpos
;
1461 /* If position is above window start or outside buffer boundaries,
1462 or if window start is out of range, position is not visible. */
1464 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1465 && CHARPOS (top
) >= BUF_BEGV (buf
)
1466 && CHARPOS (top
) <= BUF_ZV (buf
)
1467 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1468 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1471 if (!NILP (in_window
) && !NILP (partially
))
1473 Lisp_Object part
= Qnil
;
1475 part
= list4 (make_number (rtop
), make_number (rbot
),
1476 make_number (rowh
), make_number (vpos
));
1477 in_window
= Fcons (make_number (x
),
1478 Fcons (make_number (y
), part
));
1484 DEFUN ("window-line-height", Fwindow_line_height
,
1485 Swindow_line_height
, 0, 2, 0,
1486 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1487 WINDOW defaults to the selected window.
1489 Return height of current line if LINE is omitted or nil. Return height of
1490 header or mode line if LINE is `header-line' or `mode-line'.
1491 Otherwise, LINE is a text line number starting from 0. A negative number
1492 counts from the end of the window.
1494 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1495 in pixels of the visible part of the line, VPOS and YPOS are the
1496 vertical position in lines and pixels of the line, relative to the top
1497 of the first text line, and OFFBOT is the number of off-window pixels at
1498 the bottom of the text line. If there are off-window pixels at the top
1499 of the (first) text line, YPOS is negative.
1501 Return nil if window display is not up-to-date. In that case, use
1502 `pos-visible-in-window-p' to obtain the information. */)
1503 (Lisp_Object line
, Lisp_Object window
)
1505 register struct window
*w
;
1506 register struct buffer
*b
;
1507 struct glyph_row
*row
, *end_row
;
1511 w
= decode_window (window
);
1513 if (noninteractive
|| w
->pseudo_window_p
)
1516 CHECK_BUFFER (w
->buffer
);
1517 b
= XBUFFER (w
->buffer
);
1519 /* Fail if current matrix is not up-to-date. */
1520 if (NILP (w
->window_end_valid
)
1521 || current_buffer
->clip_changed
1522 || current_buffer
->prevent_redisplay_optimizations_p
1523 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
1524 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
1530 if (i
< 0 || i
>= w
->current_matrix
->nrows
1531 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1533 max_y
= window_text_bottom_y (w
);
1537 if (EQ (line
, Qheader_line
))
1539 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1541 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1542 if (!row
->enabled_p
)
1544 return list4 (make_number (row
->height
),
1545 make_number (0), make_number (0),
1549 if (EQ (line
, Qmode_line
))
1551 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1552 if (!row
->enabled_p
)
1554 return list4 (make_number (row
->height
),
1555 make_number (0), /* not accurate */
1556 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
1557 + window_text_bottom_y (w
)),
1561 CHECK_NUMBER (line
);
1564 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1565 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1566 max_y
= window_text_bottom_y (w
);
1569 while ((n
< 0 || i
< n
)
1570 && row
<= end_row
&& row
->enabled_p
1571 && row
->y
+ row
->height
< max_y
)
1574 if (row
> end_row
|| !row
->enabled_p
)
1586 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1587 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
1589 make_number (row
->y
),
1590 make_number (crop
));
1593 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1595 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1596 More precisely, return the value assigned by the last call of
1597 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1598 never called with WINDOW as its argument, or the value set by that
1599 function was internally reset since its last call. WINDOW defaults to
1600 the selected window.
1602 When a window is dedicated to its buffer, `display-buffer' will refrain
1603 from displaying another buffer in it. `get-lru-window' and
1604 `get-largest-window' treat dedicated windows specially.
1605 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1606 `kill-buffer' can delete a dedicated window and the containing frame.
1608 Functions like `set-window-buffer' may change the buffer displayed by a
1609 window, unless that window is "strongly" dedicated to its buffer, that
1610 is the value returned by `window-dedicated-p' is t. */)
1611 (Lisp_Object window
)
1613 return decode_window (window
)->dedicated
;
1616 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1617 Sset_window_dedicated_p
, 2, 2, 0,
1618 doc
: /* Mark WINDOW as dedicated according to FLAG.
1619 WINDOW must be a live window and defaults to the selected one. FLAG
1620 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1621 mark WINDOW as non-dedicated. Return FLAG.
1623 When a window is dedicated to its buffer, `display-buffer' will refrain
1624 from displaying another buffer in it. `get-lru-window' and
1625 `get-largest-window' treat dedicated windows specially.
1626 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1627 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1628 and the containing frame.
1630 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1631 its buffer. Functions like `set-window-buffer' may change the buffer
1632 displayed by a window, unless that window is strongly dedicated to its
1633 buffer. If and when `set-window-buffer' displays another buffer in a
1634 window, it also makes sure that the window is no more dedicated. */)
1635 (Lisp_Object window
, Lisp_Object flag
)
1637 register struct window
*w
= decode_window (window
);
1639 w
->dedicated
= flag
;
1640 return w
->dedicated
;
1643 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1645 doc
: /* Return buffers previously shown in WINDOW.
1646 WINDOW must be a live window and defaults to the selected one.
1648 The return value is a list of elements (BUFFER WINDOW-START POS),
1649 where BUFFER is a buffer, WINDOW-START is the start position of the
1650 window for that buffer, and POS is a window-specific point value. */)
1651 (Lisp_Object window
)
1653 return decode_window (window
)->prev_buffers
;
1656 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1657 Sset_window_prev_buffers
, 2, 2, 0,
1658 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1659 WINDOW must be a live window and defaults to the selected one.
1661 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1662 where BUFFER is a buffer, WINDOW-START is the start position of the
1663 window for that buffer, and POS is a window-specific point value. */)
1664 (Lisp_Object window
, Lisp_Object prev_buffers
)
1666 return decode_window (window
)->prev_buffers
= prev_buffers
;
1669 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1671 doc
: /* Return list of buffers recently re-shown in WINDOW.
1672 WINDOW must be a live window and defaults to the selected one. */)
1673 (Lisp_Object window
)
1675 return decode_window (window
)->next_buffers
;
1678 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1679 Sset_window_next_buffers
, 2, 2, 0,
1680 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1681 WINDOW must be a live window and defaults to the selected one.
1682 NEXT-BUFFERS should be a list of buffers. */)
1683 (Lisp_Object window
, Lisp_Object next_buffers
)
1685 return decode_window (window
)->next_buffers
= next_buffers
;
1688 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1690 doc
: /* Return the parameters of WINDOW and their values.
1691 WINDOW defaults to the selected window. The return value is a list of
1692 elements of the form (PARAMETER . VALUE). */)
1693 (Lisp_Object window
)
1695 return Fcopy_alist (decode_any_window (window
)->window_parameters
);
1698 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1700 doc
: /* Return WINDOW's value for PARAMETER.
1701 WINDOW defaults to the selected window. */)
1702 (Lisp_Object window
, Lisp_Object parameter
)
1706 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1707 return CDR_SAFE (result
);
1710 DEFUN ("set-window-parameter", Fset_window_parameter
,
1711 Sset_window_parameter
, 3, 3, 0,
1712 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1713 WINDOW defaults to the selected window. Return VALUE. */)
1714 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1716 register struct window
*w
= decode_any_window (window
);
1717 Lisp_Object old_alist_elt
;
1719 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1720 if (NILP (old_alist_elt
))
1721 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1723 Fsetcdr (old_alist_elt
, value
);
1727 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1729 doc
: /* Return the display-table that WINDOW is using.
1730 WINDOW defaults to the selected window. */)
1731 (Lisp_Object window
)
1733 return decode_window (window
)->display_table
;
1736 /* Get the display table for use on window W. This is either W's
1737 display table or W's buffer's display table. Ignore the specified
1738 tables if they are not valid; if no valid table is specified,
1741 struct Lisp_Char_Table
*
1742 window_display_table (struct window
*w
)
1744 struct Lisp_Char_Table
*dp
= NULL
;
1746 if (DISP_TABLE_P (w
->display_table
))
1747 dp
= XCHAR_TABLE (w
->display_table
);
1748 else if (BUFFERP (w
->buffer
))
1750 struct buffer
*b
= XBUFFER (w
->buffer
);
1752 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1753 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1754 else if (DISP_TABLE_P (Vstandard_display_table
))
1755 dp
= XCHAR_TABLE (Vstandard_display_table
);
1761 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1762 doc
: /* Set WINDOW's display-table to TABLE. */)
1763 (register Lisp_Object window
, Lisp_Object table
)
1765 register struct window
*w
;
1767 w
= decode_window (window
);
1768 w
->display_table
= table
;
1772 /* Record info on buffer window W is displaying
1773 when it is about to cease to display that buffer. */
1775 unshow_buffer (register struct window
*w
)
1782 if (b
!= XMARKER (w
->pointm
)->buffer
)
1786 if (w
== XWINDOW (selected_window
)
1787 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1788 /* Do this except when the selected window's buffer
1789 is being removed from some other window. */
1791 /* last_window_start records the start position that this buffer
1792 had in the last window to be disconnected from it.
1793 Now that this statement is unconditional,
1794 it is possible for the buffer to be displayed in the
1795 selected window, while last_window_start reflects another
1796 window which was recently showing the same buffer.
1797 Some people might say that might be a good thing. Let's see. */
1798 b
->last_window_start
= marker_position (w
->start
);
1800 /* Point in the selected window's buffer
1801 is actually stored in that buffer, and the window's pointm isn't used.
1802 So don't clobber point in that buffer. */
1803 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1804 /* This line helps to fix Horsley's testbug.el bug. */
1805 && !(WINDOWP (BVAR (b
, last_selected_window
))
1806 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1807 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1808 temp_set_point_both (b
,
1809 clip_to_bounds (BUF_BEGV (b
),
1810 XMARKER (w
->pointm
)->charpos
,
1812 clip_to_bounds (BUF_BEGV_BYTE (b
),
1813 marker_byte_position (w
->pointm
),
1816 if (WINDOWP (BVAR (b
, last_selected_window
))
1817 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1818 BVAR (b
, last_selected_window
) = Qnil
;
1821 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1822 means change window structure only. Otherwise store geometry and
1823 other settings as well. */
1825 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1827 register Lisp_Object tem
;
1828 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1830 /* If OLD is its frame's root window, then NEW is the new
1831 root window for that frame. */
1832 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1833 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = new;
1837 n
->left_col
= o
->left_col
;
1838 n
->top_line
= o
->top_line
;
1839 n
->total_cols
= o
->total_cols
;
1840 n
->total_lines
= o
->total_lines
;
1841 n
->normal_cols
= o
->normal_cols
;
1842 o
->normal_cols
= make_float (1.0);
1843 n
->normal_lines
= o
->normal_lines
;
1844 o
->normal_lines
= make_float (1.0);
1845 n
->desired_matrix
= n
->current_matrix
= 0;
1847 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1848 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1849 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1850 n
->phys_cursor_type
= -1;
1851 n
->phys_cursor_width
= -1;
1852 n
->must_be_updated_p
= 0;
1853 n
->pseudo_window_p
= 0;
1854 XSETFASTINT (n
->window_end_vpos
, 0);
1855 XSETFASTINT (n
->window_end_pos
, 0);
1856 n
->window_end_valid
= Qnil
;
1857 n
->frozen_window_start_p
= 0;
1860 n
->next
= tem
= o
->next
;
1862 XWINDOW (tem
)->prev
= new;
1864 n
->prev
= tem
= o
->prev
;
1866 XWINDOW (tem
)->next
= new;
1868 n
->parent
= tem
= o
->parent
;
1871 if (EQ (XWINDOW (tem
)->vchild
, old
))
1872 XWINDOW (tem
)->vchild
= new;
1873 if (EQ (XWINDOW (tem
)->hchild
, old
))
1874 XWINDOW (tem
)->hchild
= new;
1878 /* If window WINDOW and its parent window are iso-combined, merge
1879 WINDOW's children into those of its parent window and mark WINDOW as
1883 recombine_windows (Lisp_Object window
)
1885 struct window
*w
, *p
, *c
;
1886 Lisp_Object parent
, child
;
1889 w
= XWINDOW (window
);
1891 if (!NILP (parent
) && NILP (w
->nest
))
1893 p
= XWINDOW (parent
);
1894 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
1895 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
1896 /* WINDOW and PARENT are both either a vertical or a horizontal
1899 horflag
= NILP (w
->vchild
);
1900 child
= horflag
? w
->hchild
: w
->vchild
;
1901 c
= XWINDOW (child
);
1903 /* Splice WINDOW's children into its parent's children and
1904 assign new normal sizes. */
1913 XWINDOW (w
->prev
)->next
= child
;
1922 = make_float (XFLOATINT (c
->total_cols
)
1923 / XFLOATINT (p
->total_cols
));
1926 = make_float (XFLOATINT (c
->total_lines
)
1927 / XFLOATINT (p
->total_lines
));
1931 if (!NILP (w
->next
))
1934 XWINDOW (c
->next
)->prev
= child
;
1942 c
= XWINDOW (child
);
1946 /* WINDOW can be deleted now. */
1947 w
->vchild
= w
->hchild
= Qnil
;
1952 /* If WINDOW can be deleted, delete it. */
1954 delete_deletable_window (Lisp_Object window
)
1956 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
1957 call1 (Qdelete_window
, window
);
1960 /***********************************************************************
1962 ***********************************************************************/
1964 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1965 pointer. This is a callback function for foreach_window, used in
1966 the window_list function. */
1969 add_window_to_list (struct window
*w
, void *user_data
)
1971 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1973 XSETWINDOW (window
, w
);
1974 *list
= Fcons (window
, *list
);
1979 /* Return a list of all windows, for use by next_window. If
1980 Vwindow_list is a list, return that list. Otherwise, build a new
1981 list, cache it in Vwindow_list, and return that. */
1986 if (!CONSP (Vwindow_list
))
1990 Vwindow_list
= Qnil
;
1991 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1993 Lisp_Object args
[2];
1995 /* We are visiting windows in canonical order, and add
1996 new windows at the front of args[1], which means we
1997 have to reverse this list at the end. */
1999 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
2000 args
[0] = Vwindow_list
;
2001 args
[1] = Fnreverse (args
[1]);
2002 Vwindow_list
= Fnconc (2, args
);
2006 return Vwindow_list
;
2010 /* Value is non-zero if WINDOW satisfies the constraints given by
2011 OWINDOW, MINIBUF and ALL_FRAMES.
2013 MINIBUF t means WINDOW may be minibuffer windows.
2014 `lambda' means WINDOW may not be a minibuffer window.
2015 a window means a specific minibuffer window
2017 ALL_FRAMES t means search all frames,
2018 nil means search just current frame,
2019 `visible' means search just visible frames on the
2021 0 means search visible and iconified frames on the
2023 a window means search the frame that window belongs to,
2024 a frame means consider windows on that frame, only. */
2027 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2029 struct window
*w
= XWINDOW (window
);
2030 struct frame
*f
= XFRAME (w
->frame
);
2031 int candidate_p
= 1;
2033 if (!BUFFERP (w
->buffer
))
2035 else if (MINI_WINDOW_P (w
)
2036 && (EQ (minibuf
, Qlambda
)
2037 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2039 /* If MINIBUF is `lambda' don't consider any mini-windows.
2040 If it is a window, consider only that one. */
2043 else if (EQ (all_frames
, Qt
))
2045 else if (NILP (all_frames
))
2047 xassert (WINDOWP (owindow
));
2048 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2050 else if (EQ (all_frames
, Qvisible
))
2052 FRAME_SAMPLE_VISIBILITY (f
);
2053 candidate_p
= FRAME_VISIBLE_P (f
)
2054 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2055 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2058 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2060 FRAME_SAMPLE_VISIBILITY (f
);
2061 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2062 #ifdef HAVE_X_WINDOWS
2063 /* Yuck!! If we've just created the frame and the
2064 window-manager requested the user to place it
2065 manually, the window may still not be considered
2066 `visible'. I'd argue it should be at least
2067 something like `iconified', but don't know how to do
2069 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2070 && !f
->output_data
.x
->has_been_visible
)
2073 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2074 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2076 else if (WINDOWP (all_frames
))
2077 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2078 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2079 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2080 else if (FRAMEP (all_frames
))
2081 candidate_p
= EQ (all_frames
, w
->frame
);
2087 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2088 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2089 MINIBUF, and ALL_FRAMES. */
2092 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2095 *window
= selected_window
;
2097 CHECK_LIVE_WINDOW (*window
);
2099 /* MINIBUF nil may or may not include minibuffers. Decide if it
2101 if (NILP (*minibuf
))
2102 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2103 else if (!EQ (*minibuf
, Qt
))
2106 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2107 => count none of them, or a specific minibuffer window (the
2108 active one) to count. */
2110 /* ALL_FRAMES nil doesn't specify which frames to include. */
2111 if (NILP (*all_frames
))
2112 *all_frames
= (!EQ (*minibuf
, Qlambda
)
2113 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
2115 else if (EQ (*all_frames
, Qvisible
))
2117 else if (EQ (*all_frames
, make_number (0)))
2119 else if (FRAMEP (*all_frames
))
2121 else if (!EQ (*all_frames
, Qt
))
2126 /* Return the next or previous window of WINDOW in cyclic ordering
2127 of windows. NEXT_P non-zero means return the next window. See the
2128 documentation string of next-window for the meaning of MINIBUF and
2132 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2134 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2136 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2137 return the first window on the frame. */
2138 if (FRAMEP (all_frames
)
2139 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2140 return Fframe_first_window (all_frames
);
2146 /* Find WINDOW in the list of all windows. */
2147 list
= Fmemq (window
, window_list ());
2149 /* Scan forward from WINDOW to the end of the window list. */
2151 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2152 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2155 /* Scan from the start of the window list up to WINDOW. */
2157 for (list
= Vwindow_list
;
2158 CONSP (list
) && !EQ (XCAR (list
), window
);
2160 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2164 window
= XCAR (list
);
2168 Lisp_Object candidate
, list
;
2170 /* Scan through the list of windows for candidates. If there are
2171 candidate windows in front of WINDOW, the last one of these
2172 is the one we want. If there are candidates following WINDOW
2173 in the list, again the last one of these is the one we want. */
2175 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2177 if (EQ (XCAR (list
), window
))
2179 if (WINDOWP (candidate
))
2182 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2184 candidate
= XCAR (list
);
2187 if (WINDOWP (candidate
))
2195 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2196 doc
: /* Return window following WINDOW in cyclic ordering of windows.
2197 WINDOW must be a live window and defaults to the selected one. The
2198 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2201 MINIBUF nil or omitted means consider the minibuffer window only if the
2202 minibuffer is active. MINIBUF t means consider the minibuffer window
2203 even if the minibuffer is not active. Any other value means do not
2204 consider the minibuffer window even if the minibuffer is active.
2206 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2207 plus the minibuffer window if specified by the MINIBUF argument. If the
2208 minibuffer counts, consider all windows on all frames that share that
2209 minibuffer too. The following non-nil values of ALL-FRAMES have special
2212 - t means consider all windows on all existing frames.
2214 - `visible' means consider all windows on all visible frames.
2216 - 0 (the number zero) means consider all windows on all visible and
2219 - A frame means consider all windows on that frame only.
2221 Anything else means consider all windows on WINDOW's frame and no
2224 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2225 `next-window' to iterate through the entire cycle of acceptable
2226 windows, eventually ending up back at the window you started with.
2227 `previous-window' traverses the same cycle, in the reverse order. */)
2228 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2230 return next_window (window
, minibuf
, all_frames
, 1);
2234 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2235 doc
: /* Return window preceding WINDOW in cyclic ordering of windows.
2236 WINDOW must be a live window and defaults to the selected one. The
2237 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2240 MINIBUF nil or omitted means consider the minibuffer window only if the
2241 minibuffer is active. MINIBUF t means consider the minibuffer window
2242 even if the minibuffer is not active. Any other value means do not
2243 consider the minibuffer window even if the minibuffer is active.
2245 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2246 plus the minibuffer window if specified by the MINIBUF argument. If the
2247 minibuffer counts, consider all windows on all frames that share that
2248 minibuffer too. The following non-nil values of ALL-FRAMES have special
2251 - t means consider all windows on all existing frames.
2253 - `visible' means consider all windows on all visible frames.
2255 - 0 (the number zero) means consider all windows on all visible and
2258 - A frame means consider all windows on that frame only.
2260 Anything else means consider all windows on WINDOW's frame and no
2263 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2264 use `previous-window' to iterate through the entire cycle of
2265 acceptable windows, eventually ending up back at the window you
2266 started with. `next-window' traverses the same cycle, in the
2268 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2270 return next_window (window
, minibuf
, all_frames
, 0);
2274 /* Return a list of windows in cyclic ordering. Arguments are like
2275 for `next-window'. */
2278 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2280 Lisp_Object tail
, list
, rest
;
2282 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2285 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2286 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2287 list
= Fcons (XCAR (tail
), list
);
2289 /* Rotate the list to start with WINDOW. */
2290 list
= Fnreverse (list
);
2291 rest
= Fmemq (window
, list
);
2292 if (!NILP (rest
) && !EQ (rest
, list
))
2294 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2296 XSETCDR (tail
, Qnil
);
2297 list
= nconc2 (rest
, list
);
2303 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2304 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2305 FRAME nil or omitted means use the selected frame.
2306 WINDOW nil or omitted means use the selected window.
2307 MINIBUF t means include the minibuffer window, even if it isn't active.
2308 MINIBUF nil or omitted means include the minibuffer window only
2310 MINIBUF neither nil nor t means never include the minibuffer window. */)
2311 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2314 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2315 CHECK_WINDOW (window
);
2317 frame
= selected_frame
;
2319 if (!EQ (frame
, XWINDOW (window
)->frame
))
2320 error ("Window is on a different frame");
2322 return window_list_1 (window
, minibuf
, frame
);
2326 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2327 doc
: /* Return a list of all live windows.
2328 WINDOW specifies the first window to list and defaults to the selected
2331 Optional argument MINIBUF nil or omitted means consider the minibuffer
2332 window only if the minibuffer is active. MINIBUF t means consider the
2333 minibuffer window even if the minibuffer is not active. Any other value
2334 means do not consider the minibuffer window even if the minibuffer is
2337 Optional argument ALL-FRAMES nil or omitted means consider all windows
2338 on WINDOW's frame, plus the minibuffer window if specified by the
2339 MINIBUF argument. If the minibuffer counts, consider all windows on all
2340 frames that share that minibuffer too. The following non-nil values of
2341 ALL-FRAMES have special meanings:
2343 - t means consider all windows on all existing frames.
2345 - `visible' means consider all windows on all visible frames.
2347 - 0 (the number zero) means consider all windows on all visible and
2350 - A frame means consider all windows on that frame only.
2352 Anything else means consider all windows on WINDOW's frame and no
2355 If WINDOW is not on the list of windows returned, some other window will
2356 be listed first but no error is signalled. */)
2357 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2359 return window_list_1 (window
, minibuf
, all_frames
);
2362 /* Look at all windows, performing an operation specified by TYPE
2364 If FRAMES is Qt, look at all frames;
2365 Qnil, look at just the selected frame;
2366 Qvisible, look at visible frames;
2367 a frame, just look at windows on that frame.
2368 If MINI is non-zero, perform the operation on minibuffer windows too. */
2373 GET_BUFFER_WINDOW
, /* Arg is buffer */
2374 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2375 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2380 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2382 Lisp_Object window
, windows
, best_window
, frame_arg
;
2383 int frame_best_window_flag
= 0;
2385 struct gcpro gcpro1
;
2387 /* If we're only looping through windows on a particular frame,
2388 frame points to that frame. If we're looping through windows
2389 on all frames, frame is 0. */
2390 if (FRAMEP (frames
))
2391 f
= XFRAME (frames
);
2392 else if (NILP (frames
))
2393 f
= SELECTED_FRAME ();
2398 frame_arg
= Qlambda
;
2399 else if (EQ (frames
, make_number (0)))
2401 else if (EQ (frames
, Qvisible
))
2406 /* frame_arg is Qlambda to stick to one frame,
2407 Qvisible to consider all visible frames,
2410 /* Pick a window to start with. */
2414 window
= FRAME_SELECTED_WINDOW (f
);
2416 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2418 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2422 for (; CONSP (windows
); windows
= XCDR (windows
))
2426 window
= XCAR (windows
);
2427 w
= XWINDOW (window
);
2429 /* Note that we do not pay attention here to whether the frame
2430 is visible, since Fwindow_list skips non-visible frames if
2431 that is desired, under the control of frame_arg. */
2432 if (!MINI_WINDOW_P (w
)
2433 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2434 consider all windows. */
2435 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2436 || (mini
&& minibuf_level
> 0))
2439 case GET_BUFFER_WINDOW
:
2440 if (EQ (w
->buffer
, obj
)
2441 /* Don't find any minibuffer window except the one that
2442 is currently in use. */
2443 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2445 if (EQ (window
, selected_window
))
2446 /* Preferably return the selected window. */
2447 RETURN_UNGCPRO (window
);
2448 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2449 && !frame_best_window_flag
)
2450 /* Prefer windows on the current frame (but don't
2451 choose another one if we have one already). */
2453 best_window
= window
;
2454 frame_best_window_flag
= 1;
2456 else if (NILP (best_window
))
2457 best_window
= window
;
2461 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2462 /* We could simply check whether the buffer shown by window
2463 is live, and show another buffer in case it isn't. */
2464 if (EQ (w
->buffer
, obj
))
2466 /* Undedicate WINDOW. */
2467 w
->dedicated
= Qnil
;
2468 /* Make WINDOW show the buffer returned by
2469 other_buffer_safely, don't run any hooks. */
2471 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2472 /* If WINDOW is the selected window, make its buffer
2473 current. But do so only if the window shows the
2474 current buffer (Bug#6454). */
2475 if (EQ (window
, selected_window
)
2476 && XBUFFER (w
->buffer
) == current_buffer
)
2477 Fset_buffer (w
->buffer
);
2481 case REDISPLAY_BUFFER_WINDOWS
:
2482 if (EQ (w
->buffer
, obj
))
2484 mark_window_display_accurate (window
, 0);
2485 w
->update_mode_line
= Qt
;
2486 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2487 ++update_mode_lines
;
2488 best_window
= window
;
2492 /* Check for a window that has a killed buffer. */
2493 case CHECK_ALL_WINDOWS
:
2494 if (! NILP (w
->buffer
)
2495 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2499 case WINDOW_LOOP_UNUSED
:
2508 /* Used for debugging. Abort if any window has a dead buffer. */
2510 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2512 check_all_windows (void)
2514 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2517 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2518 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2519 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2522 The optional argument ALL-FRAMES specifies the frames to consider:
2524 - t means consider all windows on all existing frames.
2526 - `visible' means consider all windows on all visible frames.
2528 - 0 (the number zero) means consider all windows on all visible
2529 and iconified frames.
2531 - A frame means consider all windows on that frame only.
2533 Any other value of ALL-FRAMES means consider all windows on the
2534 selected frame and no others. */)
2535 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2539 if (NILP (buffer_or_name
))
2540 buffer
= Fcurrent_buffer ();
2542 buffer
= Fget_buffer (buffer_or_name
);
2544 if (BUFFERP (buffer
))
2545 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2551 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2553 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2557 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2558 Sdelete_other_windows_internal
, 0, 2, "",
2559 doc
: /* Make WINDOW fill its frame.
2560 Only the frame WINDOW is on is affected. WINDOW may be any window and
2561 defaults to the selected one.
2563 Optional argument ROOT, if non-nil, must specify an internal window
2564 containing WINDOW as a subwindow. If this is the case, replace ROOT by
2565 WINDOW and leave alone any windows not contained in ROOT.
2567 When WINDOW is live try to reduce display jumps by keeping the text
2568 previously visible in WINDOW in the same place on the frame. Doing this
2569 depends on the value of (window-start WINDOW), so if calling this
2570 function in a program gives strange scrolling, make sure the
2571 window-start value is reasonable when this function is called. */)
2572 (Lisp_Object window
, Lisp_Object root
)
2574 struct window
*w
, *r
, *s
;
2576 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2577 ptrdiff_t startpos
IF_LINT (= 0);
2578 int top
IF_LINT (= 0), new_top
, resize_failed
;
2580 w
= decode_any_window (window
);
2581 XSETWINDOW (window
, w
);
2582 f
= XFRAME (w
->frame
);
2585 /* ROOT is the frame's root window. */
2587 root
= FRAME_ROOT_WINDOW (f
);
2591 /* ROOT must be an ancestor of WINDOW. */
2593 r
= decode_any_window (root
);
2594 pwindow
= XWINDOW (window
)->parent
;
2595 while (!NILP (pwindow
))
2596 if (EQ (pwindow
, root
))
2599 pwindow
= XWINDOW (pwindow
)->parent
;
2600 if (!EQ (pwindow
, root
))
2601 error ("Specified root is not an ancestor of specified window");
2604 if (EQ (window
, root
))
2607 /* I don't understand the "top > 0" part below. If we deal with a
2608 standalone minibuffer it would have been caught by the preceding
2610 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2611 error ("Can't expand minibuffer to full frame");
2613 if (!NILP (w
->buffer
))
2615 startpos
= marker_position (w
->start
);
2616 top
= WINDOW_TOP_EDGE_LINE (w
)
2617 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2618 /* Make sure WINDOW is the frame's selected window. */
2619 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2621 if (EQ (selected_frame
, w
->frame
))
2622 Fselect_window (window
, Qnil
);
2624 FRAME_SELECTED_WINDOW (f
) = window
;
2629 /* See if the frame's selected window is a subwindow of WINDOW, by
2630 finding all the selected window's parents and comparing each
2631 one with WINDOW. If it isn't we need a new selected window for
2633 swindow
= FRAME_SELECTED_WINDOW (f
);
2637 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2638 pwindow
= XWINDOW (pwindow
)->parent
;
2640 if (EQ (window
, pwindow
))
2641 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2642 as the new selected window. */
2645 /* Else try the previous window of SWINDOW. */
2646 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2649 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2651 if (EQ (selected_frame
, w
->frame
))
2652 Fselect_window (swindow
, Qnil
);
2654 FRAME_SELECTED_WINDOW (f
) = swindow
;
2659 free_window_matrices (r
);
2661 windows_or_buffers_changed
++;
2662 Vwindow_list
= Qnil
;
2663 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2666 if (NILP (w
->buffer
))
2668 /* Resize subwindows vertically. */
2669 XSETINT (delta
, XINT (r
->total_lines
) - XINT (w
->total_lines
));
2670 w
->top_line
= r
->top_line
;
2671 resize_root_window (window
, delta
, Qnil
, Qnil
);
2672 if (window_resize_check (w
, 0))
2673 window_resize_apply (w
, 0);
2676 resize_root_window (window
, delta
, Qnil
, Qt
);
2677 if (window_resize_check (w
, 0))
2678 window_resize_apply (w
, 0);
2683 /* Resize subwindows horizontally. */
2686 w
->left_col
= r
->left_col
;
2687 XSETINT (delta
, XINT (r
->total_cols
) - XINT (w
->total_cols
));
2688 w
->left_col
= r
->left_col
;
2689 resize_root_window (window
, delta
, Qt
, Qnil
);
2690 if (window_resize_check (w
, 1))
2691 window_resize_apply (w
, 1);
2694 resize_root_window (window
, delta
, Qt
, Qt
);
2695 if (window_resize_check (w
, 1))
2696 window_resize_apply (w
, 1);
2703 /* Play safe, if we still can ... */
2706 w
= XWINDOW (window
);
2710 /* Cleanly unlink WINDOW from window-tree. */
2711 if (!NILP (w
->prev
))
2712 /* Get SIBLING above (on the left of) WINDOW. */
2715 s
= XWINDOW (sibling
);
2717 if (!NILP (s
->next
))
2718 XWINDOW (s
->next
)->prev
= sibling
;
2721 /* Get SIBLING below (on the right of) WINDOW. */
2724 s
= XWINDOW (sibling
);
2726 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2727 XWINDOW (w
->parent
)->vchild
= sibling
;
2729 XWINDOW (w
->parent
)->hchild
= sibling
;
2732 /* Delete ROOT and all subwindows of ROOT. */
2733 if (!NILP (r
->vchild
))
2735 delete_all_subwindows (r
->vchild
);
2738 else if (!NILP (r
->hchild
))
2740 delete_all_subwindows (r
->hchild
);
2744 replace_window (root
, window
, 1);
2746 /* Reset WINDOW's splits status. */
2749 /* This must become SWINDOW anyway ....... */
2750 if (!NILP (w
->buffer
) && !resize_failed
)
2752 /* Try to minimize scrolling, by setting the window start to the
2753 point will cause the text at the old window start to be at the
2754 same place on the frame. But don't try to do this if the
2755 window start is outside the visible portion (as might happen
2756 when the display is not current, due to typeahead). */
2757 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2759 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2760 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2762 struct position pos
;
2763 struct buffer
*obuf
= current_buffer
;
2765 Fset_buffer (w
->buffer
);
2766 /* This computation used to temporarily move point, but that
2767 can have unwanted side effects due to text properties. */
2768 pos
= *vmotion (startpos
, -top
, w
);
2770 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2771 w
->window_end_valid
= Qnil
;
2772 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2773 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2775 /* We need to do this, so that the window-scroll-functions
2777 w
->optional_new_start
= Qt
;
2779 set_buffer_internal (obuf
);
2786 run_window_configuration_change_hook (f
);
2793 replace_buffer_in_windows (Lisp_Object buffer
)
2795 call1 (Qreplace_buffer_in_windows
, buffer
);
2799 /* Safely replace BUFFER with some other buffer in all windows of all
2800 frames, even those on other keyboards. */
2803 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2805 Lisp_Object tail
, frame
;
2807 /* A single call to window_loop won't do the job because it only
2808 considers frames on the current keyboard. So loop manually over
2809 frames, and handle each one. */
2810 FOR_EACH_FRAME (tail
, frame
)
2811 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2814 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2815 minimum allowable size. */
2818 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2820 /* For height, we have to see:
2821 how many windows the frame has at minimum (one or two),
2822 and whether it has a menu bar or other special stuff at the top. */
2824 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2825 ? MIN_SAFE_WINDOW_HEIGHT
2826 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2828 if (FRAME_TOP_MARGIN (frame
) > 0)
2829 min_height
+= FRAME_TOP_MARGIN (frame
);
2831 if (*rows
< min_height
)
2833 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2834 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2837 /* Adjust the margins of window W if text area is too small.
2838 Return 1 if window width is ok after adjustment; 0 if window
2839 is still too narrow. */
2842 adjust_window_margins (struct window
*w
)
2844 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2845 - WINDOW_FRINGE_COLS (w
)
2846 - WINDOW_SCROLL_BAR_COLS (w
));
2847 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2848 + WINDOW_RIGHT_MARGIN_COLS (w
));
2850 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2853 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2856 /* Window's text area is too narrow, but reducing the window
2857 margins will fix that. */
2858 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2859 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2861 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2862 w
->left_margin_cols
= w
->right_margin_cols
2863 = make_number (margin_cols
/2);
2865 w
->right_margin_cols
= make_number (margin_cols
);
2868 w
->left_margin_cols
= make_number (margin_cols
);
2872 static Lisp_Object
Fset_window_margins (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2873 static Lisp_Object
Fset_window_fringes (Lisp_Object
, Lisp_Object
, Lisp_Object
,
2875 static Lisp_Object
Fset_window_scroll_bars (Lisp_Object
, Lisp_Object
,
2876 Lisp_Object
, Lisp_Object
);
2877 static Lisp_Object
Fset_window_vscroll (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2879 /* The following three routines are needed for running a window's
2880 configuration change hook. */
2882 run_funs (Lisp_Object funs
)
2884 for (; CONSP (funs
); funs
= XCDR (funs
))
2885 if (!EQ (XCAR (funs
), Qt
))
2886 call0 (XCAR (funs
));
2890 select_window_norecord (Lisp_Object window
)
2892 return WINDOW_LIVE_P (window
)
2893 ? Fselect_window (window
, Qt
) : selected_window
;
2897 select_frame_norecord (Lisp_Object frame
)
2899 return FRAME_LIVE_P (XFRAME (frame
))
2900 ? Fselect_frame (frame
, Qt
) : selected_frame
;
2904 run_window_configuration_change_hook (struct frame
*f
)
2906 ptrdiff_t count
= SPECPDL_INDEX ();
2907 Lisp_Object frame
, global_wcch
2908 = Fdefault_value (Qwindow_configuration_change_hook
);
2909 XSETFRAME (frame
, f
);
2911 if (NILP (Vrun_hooks
))
2914 /* Use the right buffer. Matters when running the local hooks. */
2915 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
2917 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2918 Fset_buffer (Fwindow_buffer (Qnil
));
2921 if (SELECTED_FRAME () != f
)
2923 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
2924 select_frame_norecord (frame
);
2927 /* Look for buffer-local values. */
2929 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
2930 for (; CONSP (windows
); windows
= XCDR (windows
))
2932 Lisp_Object window
= XCAR (windows
);
2933 Lisp_Object buffer
= Fwindow_buffer (window
);
2934 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
2937 ptrdiff_t inner_count
= SPECPDL_INDEX ();
2938 record_unwind_protect (select_window_norecord
, Fselected_window ());
2939 select_window_norecord (window
);
2940 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
2942 unbind_to (inner_count
, Qnil
);
2947 run_funs (global_wcch
);
2948 unbind_to (count
, Qnil
);
2951 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
2952 Srun_window_configuration_change_hook
, 1, 1, 0,
2953 doc
: /* Run `window-configuration-change-hook' for FRAME. */)
2956 CHECK_LIVE_FRAME (frame
);
2957 run_window_configuration_change_hook (XFRAME (frame
));
2961 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2962 means it's allowed to run hooks. See make_frame for a case where
2963 it's not allowed. KEEP_MARGINS_P non-zero means that the current
2964 margins, fringes, and scroll-bar settings of the window are not
2965 reset from the buffer's local settings. */
2968 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
2970 struct window
*w
= XWINDOW (window
);
2971 struct buffer
*b
= XBUFFER (buffer
);
2972 ptrdiff_t count
= SPECPDL_INDEX ();
2973 int samebuf
= EQ (buffer
, w
->buffer
);
2977 if (EQ (window
, selected_window
))
2978 BVAR (b
, last_selected_window
) = window
;
2980 /* Let redisplay errors through. */
2981 b
->display_error_modiff
= 0;
2983 /* Update time stamps of buffer display. */
2984 if (INTEGERP (BVAR (b
, display_count
)))
2985 XSETINT (BVAR (b
, display_count
), XINT (BVAR (b
, display_count
)) + 1);
2986 BVAR (b
, display_time
) = Fcurrent_time ();
2988 XSETFASTINT (w
->window_end_pos
, 0);
2989 XSETFASTINT (w
->window_end_vpos
, 0);
2990 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
2991 w
->window_end_valid
= Qnil
;
2992 if (!(keep_margins_p
&& samebuf
))
2993 { /* If we're not actually changing the buffer, don't reset hscroll and
2994 vscroll. This case happens for example when called from
2995 change_frame_size_1, where we use a dummy call to
2996 Fset_window_buffer on the frame's selected window (and no other)
2997 just in order to run window-configuration-change-hook.
2998 Resetting hscroll and vscroll here is problematic for things like
2999 image-mode and doc-view-mode since it resets the image's position
3000 whenever we resize the frame. */
3001 w
->hscroll
= w
->min_hscroll
= make_number (0);
3003 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3004 set_marker_restricted (w
->start
,
3005 make_number (b
->last_window_start
),
3007 w
->start_at_line_beg
= Qnil
;
3008 w
->force_start
= Qnil
;
3009 XSETFASTINT (w
->last_modified
, 0);
3010 XSETFASTINT (w
->last_overlay_modified
, 0);
3012 /* Maybe we could move this into the `if' but it's not obviously safe and
3013 I doubt it's worth the trouble. */
3014 windows_or_buffers_changed
++;
3016 /* We must select BUFFER for running the window-scroll-functions. */
3017 /* We can't check ! NILP (Vwindow_scroll_functions) here
3018 because that might itself be a local variable. */
3019 if (window_initialized
)
3021 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3022 Fset_buffer (buffer
);
3025 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3027 if (!keep_margins_p
)
3029 /* Set left and right marginal area width etc. from buffer. */
3031 /* This may call adjust_window_margins three times, so
3032 temporarily disable window margins. */
3033 Lisp_Object save_left
= w
->left_margin_cols
;
3034 Lisp_Object save_right
= w
->right_margin_cols
;
3036 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3038 Fset_window_fringes (window
,
3039 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3040 BVAR (b
, fringes_outside_margins
));
3042 Fset_window_scroll_bars (window
,
3043 BVAR (b
, scroll_bar_width
),
3044 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3046 w
->left_margin_cols
= save_left
;
3047 w
->right_margin_cols
= save_right
;
3049 Fset_window_margins (window
,
3050 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3055 if (! NILP (Vwindow_scroll_functions
))
3056 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3057 Fmarker_position (w
->start
));
3058 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3061 unbind_to (count
, Qnil
);
3064 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3065 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3066 WINDOW has to be a live window and defaults to the selected one.
3067 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3069 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3070 display margins, fringe widths, and scroll bar settings are preserved;
3071 the default is to reset these from the local settings for BUFFER-OR-NAME
3072 or the frame defaults. Return nil.
3074 This function throws an error when WINDOW is strongly dedicated to its
3075 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3076 already display BUFFER-OR-NAME.
3078 This function runs `window-scroll-functions' before running
3079 `window-configuration-change-hook'. */)
3080 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3082 register Lisp_Object tem
, buffer
;
3083 register struct window
*w
= decode_window (window
);
3085 XSETWINDOW (window
, w
);
3086 buffer
= Fget_buffer (buffer_or_name
);
3087 CHECK_BUFFER (buffer
);
3088 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3089 error ("Attempt to display deleted buffer");
3093 error ("Window is deleted");
3094 else if (!EQ (tem
, Qt
))
3095 /* w->buffer is t when the window is first being set up. */
3097 if (!EQ (tem
, buffer
))
3099 if (EQ (w
->dedicated
, Qt
))
3100 /* WINDOW is strongly dedicated to its buffer, signal an
3102 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3104 /* WINDOW is weakly dedicated to its buffer, reset
3106 w
->dedicated
= Qnil
;
3108 call1 (Qrecord_window_buffer
, window
);
3114 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3120 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3122 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3125 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3127 doc
: /* Force all windows to be updated on next redisplay.
3128 If optional arg OBJECT is a window, force redisplay of that window only.
3129 If OBJECT is a buffer or buffer name, force redisplay of all windows
3130 displaying that buffer. */)
3131 (Lisp_Object object
)
3135 windows_or_buffers_changed
++;
3136 update_mode_lines
++;
3140 if (WINDOWP (object
))
3142 struct window
*w
= XWINDOW (object
);
3143 mark_window_display_accurate (object
, 0);
3144 w
->update_mode_line
= Qt
;
3145 if (BUFFERP (w
->buffer
))
3146 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3147 ++update_mode_lines
;
3151 if (STRINGP (object
))
3152 object
= Fget_buffer (object
);
3153 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3155 /* Walk all windows looking for buffer, and force update
3156 of each of those windows. */
3158 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3159 return NILP (object
) ? Qnil
: Qt
;
3162 /* If nothing suitable was found, just return.
3163 We could signal an error, but this feature will typically be used
3164 asynchronously in timers or process sentinels, so we don't. */
3170 temp_output_buffer_show (register Lisp_Object buf
)
3172 register struct buffer
*old
= current_buffer
;
3173 register Lisp_Object window
;
3174 register struct window
*w
;
3176 BVAR (XBUFFER (buf
), directory
) = BVAR (current_buffer
, directory
);
3179 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3183 set_buffer_internal (old
);
3185 if (!NILP (Vtemp_buffer_show_function
))
3186 call1 (Vtemp_buffer_show_function
, buf
);
3189 window
= display_buffer (buf
, Vtemp_buffer_show_specifiers
, Qnil
);
3190 /* Reset Vtemp_buffer_show_specifiers immediately so it won't
3191 affect subsequent calls. */
3192 Vtemp_buffer_show_specifiers
= Qnil
;
3194 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3195 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3196 Vminibuf_scroll_window
= window
;
3197 w
= XWINDOW (window
);
3198 XSETFASTINT (w
->hscroll
, 0);
3199 XSETFASTINT (w
->min_hscroll
, 0);
3200 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3201 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3203 /* Run temp-buffer-show-hook, with the chosen window selected
3204 and its buffer current. */
3206 ptrdiff_t count
= SPECPDL_INDEX ();
3207 Lisp_Object prev_window
, prev_buffer
;
3208 prev_window
= selected_window
;
3209 XSETBUFFER (prev_buffer
, old
);
3211 /* Select the window that was chosen, for running the hook.
3212 Note: Both Fselect_window and select_window_norecord may
3213 set-buffer to the buffer displayed in the window,
3214 so we need to save the current buffer. --stef */
3215 record_unwind_protect (Fset_buffer
, prev_buffer
);
3216 record_unwind_protect (select_window_norecord
, prev_window
);
3217 Fselect_window (window
, Qt
);
3218 Fset_buffer (w
->buffer
);
3219 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3220 unbind_to (count
, Qnil
);
3225 DEFUN ("internal-temp-output-buffer-show",
3226 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3228 doc
: /* Internal function for `with-output-to-temp-buffer'. */)
3231 temp_output_buffer_show (buf
);
3235 /* Make new window, have it replace WINDOW in window-tree, and make
3236 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3237 horizontal child). */
3239 make_parent_window (Lisp_Object window
, int horflag
)
3242 register struct window
*o
, *p
;
3245 o
= XWINDOW (window
);
3246 p
= allocate_window ();
3247 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3248 ((struct Lisp_Vector
*) p
)->contents
[i
]
3249 = ((struct Lisp_Vector
*) o
)->contents
[i
];
3250 XSETWINDOW (parent
, p
);
3253 XSETFASTINT (p
->sequence_number
, sequence_number
);
3255 replace_window (window
, parent
, 1);
3261 p
->hchild
= horflag
? window
: Qnil
;
3262 p
->vchild
= horflag
? Qnil
: window
;
3268 p
->window_parameters
= Qnil
;
3271 /* Make new window from scratch. */
3276 register struct window
*w
;
3278 w
= allocate_window ();
3279 /* Initialize all Lisp data. */
3280 w
->frame
= w
->mini_p
= Qnil
;
3281 w
->next
= w
->prev
= w
->hchild
= w
->vchild
= w
->parent
= Qnil
;
3282 XSETFASTINT (w
->left_col
, 0);
3283 XSETFASTINT (w
->top_line
, 0);
3284 XSETFASTINT (w
->total_lines
, 0);
3285 XSETFASTINT (w
->total_cols
, 0);
3286 w
->normal_lines
= make_float (1.0);
3287 w
->normal_cols
= make_float (1.0);
3288 XSETFASTINT (w
->new_total
, 0);
3289 XSETFASTINT (w
->new_normal
, 0);
3291 w
->start
= Fmake_marker ();
3292 w
->pointm
= Fmake_marker ();
3293 w
->force_start
= w
->optional_new_start
= Qnil
;
3294 XSETFASTINT (w
->hscroll
, 0);
3295 XSETFASTINT (w
->min_hscroll
, 0);
3296 XSETFASTINT (w
->use_time
, 0);
3298 XSETFASTINT (w
->sequence_number
, sequence_number
);
3299 w
->temslot
= w
->last_modified
= w
->last_overlay_modified
= Qnil
;
3300 XSETFASTINT (w
->last_point
, 0);
3301 w
->last_had_star
= w
->vertical_scroll_bar
= Qnil
;
3302 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3303 w
->left_fringe_width
= w
->right_fringe_width
= Qnil
;
3304 w
->fringes_outside_margins
= Qnil
;
3305 w
->scroll_bar_width
= Qnil
;
3306 w
->vertical_scroll_bar_type
= Qt
;
3307 w
->last_mark_x
= w
->last_mark_y
= Qnil
;
3308 XSETFASTINT (w
->window_end_pos
, 0);
3309 XSETFASTINT (w
->window_end_vpos
, 0);
3310 w
->window_end_valid
= w
->update_mode_line
= Qnil
;
3311 w
->start_at_line_beg
= w
->display_table
= w
->dedicated
= Qnil
;
3312 w
->base_line_number
= w
->base_line_pos
= w
->region_showing
= Qnil
;
3313 w
->column_number_displayed
= w
->redisplay_end_trigger
= Qnil
;
3314 w
->splits
= w
->nest
= w
->window_parameters
= Qnil
;
3315 w
->prev_buffers
= w
->next_buffers
= Qnil
;
3316 /* Initialize non-Lisp data. */
3317 w
->desired_matrix
= w
->current_matrix
= 0;
3318 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3319 memset (&w
->cursor
, 0, sizeof (w
->cursor
));
3320 memset (&w
->last_cursor
, 0, sizeof (w
->last_cursor
));
3321 memset (&w
->phys_cursor
, 0, sizeof (w
->phys_cursor
));
3322 w
->phys_cursor_type
= -1;
3323 w
->phys_cursor_width
= -1;
3324 w
->last_cursor_off_p
= w
->cursor_off_p
= 0;
3325 w
->must_be_updated_p
= 0;
3326 w
->pseudo_window_p
= 0;
3327 w
->frozen_window_start_p
= 0;
3329 /* Reset window_list. */
3330 Vwindow_list
= Qnil
;
3331 /* Return window. */
3332 XSETWINDOW (window
, w
);
3336 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3337 doc
: /* Set new total size of WINDOW to SIZE.
3340 Optional argument ADD non-nil means add SIZE to the new total size of
3341 WINDOW and return the sum.
3343 Note: This function does not operate on any subwindows of WINDOW. */)
3344 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3346 struct window
*w
= decode_any_window (window
);
3348 CHECK_NUMBER (size
);
3350 XSETINT (w
->new_total
, XINT (size
));
3352 XSETINT (w
->new_total
, XINT (w
->new_total
) + XINT (size
));
3354 return w
->new_total
;
3357 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3358 doc
: /* Set new normal size of WINDOW to SIZE.
3361 Note: This function does not operate on any subwindows of WINDOW. */)
3362 (Lisp_Object window
, Lisp_Object size
)
3364 struct window
*w
= decode_any_window (window
);
3366 w
->new_normal
= size
;
3367 return w
->new_normal
;
3370 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3371 non-zero) to w->new_total would result in correct heights (widths)
3372 for window W and recursively all subwindows of W.
3374 Note: This function does not check any of `window-fixed-size-p',
3375 `window-min-height' or `window-min-width'. It does check that window
3376 sizes do not drop below one line (two columns). */
3378 window_resize_check (struct window
*w
, int horflag
)
3382 if (!NILP (w
->vchild
))
3383 /* W is a vertical combination. */
3385 c
= XWINDOW (w
->vchild
);
3387 /* All subwindows of W must have the same width as W. */
3391 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3392 || !window_resize_check (c
, horflag
))
3394 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3399 /* The sum of the heights of the subwindows of W must equal W's
3402 int sum_of_sizes
= 0;
3405 if (!window_resize_check (c
, horflag
))
3407 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3408 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3410 return (sum_of_sizes
== XINT (w
->new_total
));
3413 else if (!NILP (w
->hchild
))
3414 /* W is a horizontal combination. */
3416 c
= XWINDOW (w
->hchild
);
3418 /* The sum of the widths of the subwindows of W must equal W's
3421 int sum_of_sizes
= 0;
3424 if (!window_resize_check (c
, horflag
))
3426 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3427 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3429 return (sum_of_sizes
== XINT (w
->new_total
));
3432 /* All subwindows of W must have the same height as W. */
3436 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3437 || !window_resize_check (c
, horflag
))
3439 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3445 /* A leaf window. Make sure it's not too small. The following
3446 hardcodes the values of `window-safe-min-width' (2) and
3447 `window-safe-min-height' (1) which are defined in window.el. */
3448 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3451 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3452 w->new_total for window W and recursively all subwindows of W. Also
3453 calculate and assign the new vertical (horizontal) start positions of
3454 each of these windows.
3456 This function does not perform any error checks. Make sure you have
3457 run window_resize_check on W before applying this function. */
3459 window_resize_apply (struct window
*w
, int horflag
)
3464 /* Note: Assigning new_normal requires that the new total size of the
3465 parent window has been set *before*. */
3468 w
->total_cols
= w
->new_total
;
3469 if (NUMBERP (w
->new_normal
))
3470 w
->normal_cols
= w
->new_normal
;
3472 pos
= XINT (w
->left_col
);
3476 w
->total_lines
= w
->new_total
;
3477 if (NUMBERP (w
->new_normal
))
3478 w
->normal_lines
= w
->new_normal
;
3480 pos
= XINT (w
->top_line
);
3483 if (!NILP (w
->vchild
))
3484 /* W is a vertical combination. */
3486 c
= XWINDOW (w
->vchild
);
3490 XSETFASTINT (c
->left_col
, pos
);
3492 XSETFASTINT (c
->top_line
, pos
);
3493 window_resize_apply (c
, horflag
);
3495 pos
= pos
+ XINT (c
->total_lines
);
3496 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3499 else if (!NILP (w
->hchild
))
3500 /* W is a horizontal combination. */
3502 c
= XWINDOW (w
->hchild
);
3506 XSETFASTINT (c
->left_col
, pos
);
3508 XSETFASTINT (c
->top_line
, pos
);
3509 window_resize_apply (c
, horflag
);
3511 pos
= pos
+ XINT (c
->total_cols
);
3512 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3516 /* Clear out some redisplay caches. */
3517 XSETFASTINT (w
->last_modified
, 0);
3518 XSETFASTINT (w
->last_overlay_modified
, 0);
3522 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 1, 2, 0,
3523 doc
: /* Apply requested size values for window-tree of FRAME.
3524 Optional argument HORIZONTAL omitted or nil means apply requested height
3525 values. HORIZONTAL non-nil means apply requested width values.
3527 This function checks whether the requested values sum up to a valid
3528 window layout, recursively assigns the new sizes of all subwindows and
3529 calculates and assigns the new start positions of these windows.
3531 Note: This function does not check any of `window-fixed-size-p',
3532 `window-min-height' or `window-min-width'. All these checks have to
3533 be applied on the Elisp level. */)
3534 (Lisp_Object frame
, Lisp_Object horizontal
)
3538 int horflag
= !NILP (horizontal
);
3541 frame
= selected_frame
;
3542 CHECK_LIVE_FRAME (frame
);
3545 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3547 if (!window_resize_check (r
, horflag
)
3548 || ! EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3552 window_resize_apply (r
, horflag
);
3554 windows_or_buffers_changed
++;
3555 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3560 run_window_configuration_change_hook (f
);
3566 /* Resize frame F's windows when number of lines of F is set to SIZE.
3567 HORFLAG 1 means resize windows when number of columns of F is set to
3570 This function can delete all windows but the selected one in order to
3571 satisfy the request. The result will be meaningful if and only if
3572 F's windows have meaningful sizes when you call this. */
3574 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3576 Lisp_Object root
= f
->root_window
;
3577 struct window
*r
= XWINDOW (root
);
3578 Lisp_Object mini
= f
->minibuffer_window
;
3580 /* new_size is the new size of the frame's root window. */
3581 int new_size
= (horflag
3584 - FRAME_TOP_MARGIN (f
)
3585 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3588 XSETFASTINT (r
->top_line
, FRAME_TOP_MARGIN (f
));
3589 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3590 /* For a leaf root window just set the size. */
3592 XSETFASTINT (r
->total_cols
, new_size
);
3594 XSETFASTINT (r
->total_lines
, new_size
);
3597 /* old_size is the old size of the frame's root window. */
3598 int old_size
= XFASTINT (horflag
? r
->total_cols
: r
->total_lines
);
3601 XSETINT (delta
, new_size
- old_size
);
3602 /* Try a "normal" resize first. */
3603 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3604 if (window_resize_check (r
, horflag
) && new_size
== XINT (r
->new_total
))
3605 window_resize_apply (r
, horflag
);
3608 /* Try with "reasonable" minimum sizes next. */
3609 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3610 if (window_resize_check (r
, horflag
)
3611 && new_size
== XINT (r
->new_total
))
3612 window_resize_apply (r
, horflag
);
3615 /* Finally, try with "safe" minimum sizes. */
3616 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3617 if (window_resize_check (r
, horflag
)
3618 && new_size
== XINT (r
->new_total
))
3619 window_resize_apply (r
, horflag
);
3622 /* We lost. Delete all windows but the frame's
3624 root
= f
->selected_window
;
3625 Fdelete_other_windows_internal (root
, Qnil
);
3627 XSETFASTINT (XWINDOW (root
)->total_cols
, new_size
);
3629 XSETFASTINT (XWINDOW (root
)->total_lines
, new_size
);
3635 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3639 XSETFASTINT (m
->total_cols
, size
);
3642 /* Are we sure we always want 1 line here? */
3643 XSETFASTINT (m
->total_lines
, 1);
3644 XSETFASTINT (m
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
3650 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3651 doc
: /* Split window OLD.
3652 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3653 new window. In any case TOTAL-SIZE must be a positive integer.
3655 Third argument SIDE nil (or `below') specifies that the new window shall
3656 be located below WINDOW. SIDE `above' means the new window shall be
3657 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3658 lines of the new window including space reserved for the mode and/or
3661 SIDE t (or `right') specifies that the new window shall be located on
3662 the right side of WINDOW. SIDE `left' means the new window shall be
3663 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3664 number of columns of the new window including space reserved for fringes
3665 and the scrollbar or a divider column.
3667 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3668 according to the SIDE argument.
3670 The new total and normal sizes of all involved windows must have been
3671 set correctly. See the code of `split-window' for how this is done. */)
3672 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3674 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3675 parent window or an internal window we have to install as OLD's new
3676 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3677 provided OLD is a leaf window, or to the frame's selected window.
3678 NEW (*n) is the new window created with some parameters taken from
3680 register Lisp_Object
new, frame
, reference
;
3681 register struct window
*o
, *p
, *n
, *r
;
3684 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3685 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3690 frame
= WINDOW_FRAME (o
);
3693 CHECK_NUMBER (total_size
);
3695 /* Set do_nest to 1 if we have to make a new parent window. We do
3696 that if either `window-nest' is non-nil, or OLD has no parent, or
3697 OLD is ortho-combined. */
3699 !NILP (Vwindow_nest
)
3702 ? (XWINDOW (o
->parent
)->hchild
)
3703 : (XWINDOW (o
->parent
)->vchild
));
3705 /* We need a live reference window to initialize some parameters. */
3706 if (WINDOW_LIVE_P (old
))
3707 /* OLD is live, use it as reference window. */
3710 /* Use the frame's selected window as reference window. */
3711 reference
= FRAME_SELECTED_WINDOW (f
);
3712 r
= XWINDOW (reference
);
3714 /* The following bugs are caught by `split-window'. */
3715 if (MINI_WINDOW_P (o
))
3716 error ("Attempt to split minibuffer window");
3717 else if (XINT (total_size
) < (horflag
? 2 : 1))
3718 error ("Size of new window too small (after split)");
3719 else if (!do_nest
&& !NILP (Vwindow_splits
))
3720 /* `window-splits' non-nil means try to resize OLD's siblings
3723 p
= XWINDOW (o
->parent
);
3724 /* Temporarily pretend we split the parent window. */
3725 XSETINT (p
->new_total
,
3726 XINT (horflag
? p
->total_cols
: p
->total_lines
)
3727 - XINT (total_size
));
3728 if (!window_resize_check (p
, horflag
))
3729 error ("Window sizes don't fit");
3731 /* Undo the temporary pretension. */
3732 p
->new_total
= horflag
? p
->total_cols
: p
->total_lines
;
3736 if (!window_resize_check (o
, horflag
))
3737 error ("Resizing old window failed");
3738 else if (XINT (total_size
) + XINT (o
->new_total
)
3739 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3740 error ("Sum of sizes of old and new window don't fit");
3743 /* This is our point of no return. */
3746 /* Save the old value of o->normal_cols/lines. It gets corrupted
3747 by make_parent_window and we need it below for assigning it to
3749 Lisp_Object new_normal
= horflag
? o
->normal_cols
: o
->normal_lines
;
3751 make_parent_window (old
, horflag
);
3752 p
= XWINDOW (o
->parent
);
3753 /* Store value of `window-nest' in new parent's nest slot. */
3754 p
->nest
= Vwindow_nest
;
3755 /* Have PARENT inherit splits slot value from OLD. */
3756 p
->splits
= o
->splits
;
3757 /* Store value of `window-splits' in OLD's splits slot. */
3758 o
->splits
= Vwindow_splits
;
3759 /* These get applied below. */
3760 p
->new_total
= horflag
? o
->total_cols
: o
->total_lines
;
3761 p
->new_normal
= new_normal
;
3764 p
= XWINDOW (o
->parent
);
3766 windows_or_buffers_changed
++;
3767 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3768 new = make_window ();
3771 n
->parent
= o
->parent
;
3772 n
->vchild
= n
->hchild
= Qnil
;
3774 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3783 XWINDOW (n
->prev
)->next
= new;
3790 if (!NILP (n
->next
))
3791 XWINDOW (n
->next
)->prev
= new;
3797 n
->window_end_valid
= Qnil
;
3798 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3800 /* Get special geometry settings from reference window. */
3801 n
->left_margin_cols
= r
->left_margin_cols
;
3802 n
->right_margin_cols
= r
->right_margin_cols
;
3803 n
->left_fringe_width
= r
->left_fringe_width
;
3804 n
->right_fringe_width
= r
->right_fringe_width
;
3805 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3806 n
->scroll_bar_width
= r
->scroll_bar_width
;
3807 n
->vertical_scroll_bar_type
= r
->vertical_scroll_bar_type
;
3809 /* Store `window-splits' in NEW's splits slot. */
3810 n
->splits
= Vwindow_splits
;
3812 /* Directly assign orthogonal coordinates and sizes. */
3815 n
->top_line
= o
->top_line
;
3816 n
->total_lines
= o
->total_lines
;
3820 n
->left_col
= o
->left_col
;
3821 n
->total_cols
= o
->total_cols
;
3824 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3825 get them ready here. */
3826 n
->new_total
= total_size
;
3827 n
->new_normal
= normal_size
;
3830 window_resize_apply (p
, horflag
);
3832 /* Set buffer of NEW to buffer of reference window. Don't run
3834 set_window_buffer (new, r
->buffer
, 0, 1);
3837 /* Maybe we should run the scroll functions in Elisp (which already
3838 runs the configuration change hook). */
3839 if (! NILP (Vwindow_scroll_functions
))
3840 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3841 Fmarker_position (n
->start
));
3847 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3848 doc
: /* Remove WINDOW from its frame.
3849 WINDOW defaults to the selected window. Return nil.
3850 Signal an error when WINDOW is the only window on its frame. */)
3851 (register Lisp_Object window
)
3853 register Lisp_Object parent
, sibling
, frame
, root
;
3854 struct window
*w
, *p
, *s
, *r
;
3857 int before_sibling
= 0;
3859 w
= decode_any_window (window
);
3860 XSETWINDOW (window
, w
);
3861 if (NILP (w
->buffer
) && NILP (w
->hchild
) && NILP (w
->vchild
))
3862 /* It's a no-op to delete an already deleted window. */
3867 /* Never delete a minibuffer or frame root window. */
3868 error ("Attempt to delete minibuffer or sole ordinary window");
3869 else if (NILP (w
->prev
) && NILP (w
->next
))
3870 /* Rather bow out here, this case should be handled on the Elisp
3872 error ("Attempt to delete sole window of parent");
3874 p
= XWINDOW (parent
);
3875 horflag
= NILP (p
->vchild
);
3877 frame
= WINDOW_FRAME (w
);
3880 root
= FRAME_ROOT_WINDOW (f
);
3883 /* Unlink WINDOW from window tree. */
3885 /* Get SIBLING below (on the right of) WINDOW. */
3887 /* before_sibling 1 means WINDOW is the first child of its
3888 parent and thus before the sibling. */
3891 s
= XWINDOW (sibling
);
3894 p
->hchild
= sibling
;
3896 p
->vchild
= sibling
;
3899 /* Get SIBLING above (on the left of) WINDOW. */
3902 s
= XWINDOW (sibling
);
3904 if (!NILP (s
->next
))
3905 XWINDOW (s
->next
)->prev
= sibling
;
3908 if (window_resize_check (r
, horflag
)
3909 && EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3910 /* We can delete WINDOW now. */
3914 window_resize_apply (p
, horflag
);
3916 windows_or_buffers_changed
++;
3917 Vwindow_list
= Qnil
;
3918 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3920 w
->next
= Qnil
; /* Don't delete w->next too. */
3921 free_window_matrices (w
);
3923 if (!NILP (w
->vchild
))
3925 delete_all_subwindows (w
->vchild
);
3928 else if (!NILP (w
->hchild
))
3930 delete_all_subwindows (w
->hchild
);
3933 else if (!NILP (w
->buffer
))
3936 unchain_marker (XMARKER (w
->pointm
));
3937 unchain_marker (XMARKER (w
->start
));
3941 if (NILP (s
->prev
) && NILP (s
->next
))
3942 /* A matrjoshka where SIBLING has become the only child of
3945 /* Put SIBLING into PARENT's place. */
3946 replace_window (parent
, sibling
, 0);
3947 /* Have SIBLING inherit the following three slot values from
3948 PARENT (the nest slot is not inherited). */
3949 s
->normal_cols
= p
->normal_cols
;
3950 s
->normal_lines
= p
->normal_lines
;
3951 s
->splits
= p
->splits
;
3952 /* Mark PARENT as deleted. */
3953 p
->vchild
= p
->hchild
= Qnil
;
3954 /* Try to merge SIBLING into its new parent. */
3955 recombine_windows (sibling
);
3960 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
3961 /* We deleted the frame's selected window. */
3963 /* Use the frame's first window as fallback ... */
3964 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
3965 /* ... but preferably use its most recently used window. */
3966 Lisp_Object mru_window
;
3968 /* `get-mru-window' might fail for some reason so play it safe
3969 - promote the first window _without recording it_ first. */
3970 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
3971 Fselect_window (new_selected_window
, Qt
);
3973 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
3977 /* Now look whether `get-mru-window' gets us something. */
3978 mru_window
= call1 (Qget_mru_window
, frame
);
3979 if (WINDOW_LIVE_P (mru_window
)
3980 && EQ (XWINDOW (mru_window
)->frame
, frame
))
3981 new_selected_window
= mru_window
;
3983 /* If all ended up well, we now promote the mru window. */
3984 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
3985 Fselect_window (new_selected_window
, Qnil
);
3987 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
3992 /* Must be run by the caller:
3993 run_window_configuration_change_hook (f); */
3996 /* We failed: Relink WINDOW into window tree. */
4009 if (!NILP (w
->next
))
4010 XWINDOW (w
->next
)->prev
= window
;
4012 error ("Deletion failed");
4018 /***********************************************************************
4019 Resizing Mini-Windows
4020 ***********************************************************************/
4022 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4025 grow_mini_window (struct window
*w
, int delta
)
4027 struct frame
*f
= XFRAME (w
->frame
);
4029 Lisp_Object root
, value
;
4031 xassert (MINI_WINDOW_P (w
));
4032 xassert (delta
>= 0);
4034 root
= FRAME_ROOT_WINDOW (f
);
4036 value
= call2 (Qwindow_resize_root_window_vertically
,
4037 root
, make_number (- delta
));
4038 if (INTEGERP (value
) && window_resize_check (r
, 0))
4041 window_resize_apply (r
, 0);
4043 /* Grow the mini-window. */
4044 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4045 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - XINT (value
));
4046 XSETFASTINT (w
->last_modified
, 0);
4047 XSETFASTINT (w
->last_overlay_modified
, 0);
4055 /* Shrink mini-window W. */
4057 shrink_mini_window (struct window
*w
)
4059 struct frame
*f
= XFRAME (w
->frame
);
4061 Lisp_Object root
, value
;
4064 xassert (MINI_WINDOW_P (w
));
4066 size
= XINT (w
->total_lines
);
4069 root
= FRAME_ROOT_WINDOW (f
);
4071 value
= call2 (Qwindow_resize_root_window_vertically
,
4072 root
, make_number (size
- 1));
4073 if (INTEGERP (value
) && window_resize_check (r
, 0))
4076 window_resize_apply (r
, 0);
4078 /* Shrink the mini-window. */
4079 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4080 XSETFASTINT (w
->total_lines
, 1);
4082 XSETFASTINT (w
->last_modified
, 0);
4083 XSETFASTINT (w
->last_overlay_modified
, 0);
4088 /* If the above failed for whatever strange reason we must make a
4089 one window frame here. The same routine will be needed when
4090 shrinking the frame (and probably when making the initial
4091 *scratch* window). For the moment leave things as they are. */
4095 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4096 doc
: /* Resize minibuffer window WINDOW. */)
4097 (Lisp_Object window
)
4099 struct window
*w
= XWINDOW (window
);
4104 CHECK_WINDOW (window
);
4105 f
= XFRAME (w
->frame
);
4107 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4108 error ("Not a valid minibuffer window");
4109 else if (FRAME_MINIBUF_ONLY_P (f
))
4110 error ("Cannot resize a minibuffer-only frame");
4112 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4113 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4114 if (window_resize_check (r
, 0)
4115 && XINT (w
->new_total
) > 0
4116 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4119 window_resize_apply (r
, 0);
4121 w
->total_lines
= w
->new_total
;
4122 XSETFASTINT (w
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
4124 windows_or_buffers_changed
++;
4125 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4129 run_window_configuration_change_hook (f
);
4132 else error ("Failed to resize minibuffer window");
4135 /* Mark window cursors off for all windows in the window tree rooted
4136 at W by setting their phys_cursor_on_p flag to zero. Called from
4137 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4138 the frame are cleared. */
4141 mark_window_cursors_off (struct window
*w
)
4145 if (!NILP (w
->hchild
))
4146 mark_window_cursors_off (XWINDOW (w
->hchild
));
4147 else if (!NILP (w
->vchild
))
4148 mark_window_cursors_off (XWINDOW (w
->vchild
));
4150 w
->phys_cursor_on_p
= 0;
4152 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4157 /* Return number of lines of text (not counting mode lines) in W. */
4160 window_internal_height (struct window
*w
)
4162 int ht
= XFASTINT (w
->total_lines
);
4164 if (!MINI_WINDOW_P (w
))
4166 if (!NILP (w
->parent
)
4167 || !NILP (w
->vchild
)
4168 || !NILP (w
->hchild
)
4171 || WINDOW_WANTS_MODELINE_P (w
))
4174 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4181 /************************************************************************
4183 ***********************************************************************/
4185 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4186 N screen-fulls, which is defined as the height of the window minus
4187 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4188 instead. Negative values of N mean scroll down. NOERROR non-zero
4189 means don't signal an error if we try to move over BEGV or ZV,
4193 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4196 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4198 /* If we must, use the pixel-based version which is much slower than
4199 the line-based one but can handle varying line heights. */
4200 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4201 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4203 window_scroll_line_based (window
, n
, whole
, noerror
);
4209 /* Implementation of window_scroll that works based on pixel line
4210 heights. See the comment of window_scroll for parameter
4214 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4217 struct window
*w
= XWINDOW (window
);
4218 struct text_pos start
;
4219 int this_scroll_margin
;
4220 /* True if we fiddled the window vscroll field without really scrolling. */
4222 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4223 void *itdata
= NULL
;
4225 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4227 /* If PT is not visible in WINDOW, move back one half of
4228 the screen. Allow PT to be partially visible, otherwise
4229 something like (scroll-down 1) with PT in the line before
4230 the partially visible one would recenter. */
4232 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4234 itdata
= bidi_shelve_cache ();
4235 /* Move backward half the height of the window. Performance note:
4236 vmotion used here is about 10% faster, but would give wrong
4237 results for variable height lines. */
4238 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4239 it
.current_y
= it
.last_visible_y
;
4240 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4242 /* The function move_iterator_vertically may move over more than
4243 the specified y-distance. If it->w is small, e.g. a
4244 mini-buffer window, we may end up in front of the window's
4245 display area. This is the case when Start displaying at the
4246 start of the line containing PT in this case. */
4247 if (it
.current_y
<= 0)
4249 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4250 move_it_vertically_backward (&it
, 0);
4254 start
= it
.current
.pos
;
4255 bidi_unshelve_cache (itdata
, 0);
4257 else if (auto_window_vscroll_p
)
4259 if (rtop
|| rbot
) /* partially visible */
4262 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4264 dy
= max ((window_box_height (w
)
4265 - next_screen_context_lines
* dy
),
4271 /* Only vscroll backwards if already vscrolled forwards. */
4272 if (w
->vscroll
< 0 && rtop
> 0)
4274 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4275 Fset_window_vscroll (window
, make_number (px
), Qt
);
4281 /* Do vscroll if already vscrolled or only display line. */
4282 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4284 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4285 Fset_window_vscroll (window
, make_number (px
), Qt
);
4289 /* Maybe modify window start instead of scrolling. */
4290 if (rbot
> 0 || w
->vscroll
< 0)
4294 Fset_window_vscroll (window
, make_number (0), Qt
);
4295 /* If there are other text lines above the current row,
4296 move window start to current row. Else to next row. */
4298 spos
= XINT (Fline_beginning_position (Qnil
));
4300 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4301 set_marker_restricted (w
->start
, make_number (spos
),
4303 w
->start_at_line_beg
= Qt
;
4304 w
->update_mode_line
= Qt
;
4305 XSETFASTINT (w
->last_modified
, 0);
4306 XSETFASTINT (w
->last_overlay_modified
, 0);
4307 /* Set force_start so that redisplay_window will run the
4308 window-scroll-functions. */
4309 w
->force_start
= Qt
;
4314 /* Cancel previous vscroll. */
4315 Fset_window_vscroll (window
, make_number (0), Qt
);
4318 itdata
= bidi_shelve_cache ();
4319 /* If scroll_preserve_screen_position is non-nil, we try to set
4320 point in the same window line as it is now, so get that line. */
4321 if (!NILP (Vscroll_preserve_screen_position
))
4323 /* We preserve the goal pixel coordinate across consecutive
4324 calls to scroll-up, scroll-down and other commands that
4325 have the `scroll-command' property. This avoids the
4326 possibility of point becoming "stuck" on a tall line when
4327 scrolling by one line. */
4328 if (window_scroll_pixel_based_preserve_y
< 0
4329 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4330 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4332 start_display (&it
, w
, start
);
4333 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4334 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4335 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4339 window_scroll_pixel_based_preserve_y
4340 = window_scroll_pixel_based_preserve_x
= -1;
4342 /* Move iterator it from start the specified distance forward or
4343 backward. The result is the new window start. */
4344 start_display (&it
, w
, start
);
4347 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4348 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4349 dy
= max ((window_box_height (w
)
4350 - next_screen_context_lines
* dy
),
4353 /* Note that move_it_vertically always moves the iterator to the
4354 start of a line. So, if the last line doesn't have a newline,
4355 we would end up at the start of the line ending at ZV. */
4358 move_it_vertically_backward (&it
, -dy
);
4359 /* Ensure we actually do move, e.g. in case we are currently
4360 looking at an image that is taller that the window height. */
4361 while (start_pos
== IT_CHARPOS (it
)
4362 && start_pos
> BEGV
)
4363 move_it_by_lines (&it
, -1);
4367 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4368 MOVE_TO_POS
| MOVE_TO_Y
);
4369 /* Ensure we actually do move, e.g. in case we are currently
4370 looking at an image that is taller that the window height. */
4371 while (start_pos
== IT_CHARPOS (it
)
4373 move_it_by_lines (&it
, 1);
4377 move_it_by_lines (&it
, n
);
4379 /* We failed if we find ZV is already on the screen (scrolling up,
4380 means there's nothing past the end), or if we can't start any
4381 earlier (scrolling down, means there's nothing past the top). */
4382 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4383 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4385 if (IT_CHARPOS (it
) == ZV
)
4387 if (it
.current_y
< it
.last_visible_y
4388 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4389 > it
.last_visible_y
))
4391 /* The last line was only partially visible, make it fully
4393 w
->vscroll
= (it
.last_visible_y
4394 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4395 adjust_glyphs (it
.f
);
4399 bidi_unshelve_cache (itdata
, 0);
4402 else if (n
< 0) /* could happen with empty buffers */
4403 xsignal0 (Qbeginning_of_buffer
);
4405 xsignal0 (Qend_of_buffer
);
4410 if (w
->vscroll
!= 0)
4411 /* The first line was only partially visible, make it fully
4416 bidi_unshelve_cache (itdata
, 0);
4420 xsignal0 (Qbeginning_of_buffer
);
4424 /* If control gets here, then we vscrolled. */
4426 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4428 /* Don't try to change the window start below. */
4434 ptrdiff_t pos
= IT_CHARPOS (it
);
4437 /* If in the middle of a multi-glyph character move forward to
4438 the next character. */
4439 if (in_display_vector_p (&it
))
4442 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4445 /* Set the window start, and set up the window for redisplay. */
4446 set_marker_restricted (w
->start
, make_number (pos
),
4448 bytepos
= XMARKER (w
->start
)->bytepos
;
4449 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4451 w
->update_mode_line
= Qt
;
4452 XSETFASTINT (w
->last_modified
, 0);
4453 XSETFASTINT (w
->last_overlay_modified
, 0);
4454 /* Set force_start so that redisplay_window will run the
4455 window-scroll-functions. */
4456 w
->force_start
= Qt
;
4459 /* The rest of this function uses current_y in a nonstandard way,
4460 not including the height of the header line if any. */
4461 it
.current_y
= it
.vpos
= 0;
4463 /* Move PT out of scroll margins.
4464 This code wants current_y to be zero at the window start position
4465 even if there is a header line. */
4466 this_scroll_margin
= max (0, scroll_margin
);
4467 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4468 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4472 /* We moved the window start towards ZV, so PT may be now
4473 in the scroll margin at the top. */
4474 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4475 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4476 && (NILP (Vscroll_preserve_screen_position
)
4477 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4478 /* We found PT at a legitimate height. Leave it alone. */
4480 else if (window_scroll_pixel_based_preserve_y
>= 0)
4482 /* If we have a header line, take account of it.
4483 This is necessary because we set it.current_y to 0, above. */
4484 move_it_to (&it
, -1,
4485 window_scroll_pixel_based_preserve_x
,
4486 window_scroll_pixel_based_preserve_y
4487 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4488 -1, MOVE_TO_Y
| MOVE_TO_X
);
4489 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4493 while (it
.current_y
< this_scroll_margin
)
4495 int prev
= it
.current_y
;
4496 move_it_by_lines (&it
, 1);
4497 if (prev
== it
.current_y
)
4500 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4505 ptrdiff_t charpos
, bytepos
;
4508 /* Save our position, for the
4509 window_scroll_pixel_based_preserve_y case. */
4510 charpos
= IT_CHARPOS (it
);
4511 bytepos
= IT_BYTEPOS (it
);
4513 /* We moved the window start towards BEGV, so PT may be now
4514 in the scroll margin at the bottom. */
4515 move_it_to (&it
, PT
, -1,
4516 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4517 - this_scroll_margin
- 1),
4519 MOVE_TO_POS
| MOVE_TO_Y
);
4521 /* Save our position, in case it's correct. */
4522 charpos
= IT_CHARPOS (it
);
4523 bytepos
= IT_BYTEPOS (it
);
4525 /* See if point is on a partially visible line at the end. */
4526 if (it
.what
== IT_EOB
)
4527 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4530 move_it_by_lines (&it
, 1);
4531 partial_p
= it
.current_y
> it
.last_visible_y
;
4534 if (charpos
== PT
&& !partial_p
4535 && (NILP (Vscroll_preserve_screen_position
)
4536 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4537 /* We found PT before we found the display margin, so PT is ok. */
4539 else if (window_scroll_pixel_based_preserve_y
>= 0)
4541 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4542 start_display (&it
, w
, start
);
4543 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4544 here because we called start_display again and did not
4545 alter it.current_y this time. */
4546 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4547 window_scroll_pixel_based_preserve_y
, -1,
4548 MOVE_TO_Y
| MOVE_TO_X
);
4549 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4554 /* The last line was only partially visible, so back up two
4555 lines to make sure we're on a fully visible line. */
4557 move_it_by_lines (&it
, -2);
4558 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4561 /* No, the position we saved is OK, so use it. */
4562 SET_PT_BOTH (charpos
, bytepos
);
4565 bidi_unshelve_cache (itdata
, 0);
4569 /* Implementation of window_scroll that works based on screen lines.
4570 See the comment of window_scroll for parameter descriptions. */
4573 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4575 register struct window
*w
= XWINDOW (window
);
4576 /* Fvertical_motion enters redisplay, which can trigger
4577 fontification, which in turn can modify buffer text (e.g., if the
4578 fontification functions replace escape sequences with faces, as
4579 in `grep-mode-font-lock-keywords'). So we use a marker to record
4580 the old point position, to prevent crashes in SET_PT_BOTH. */
4581 Lisp_Object opoint_marker
= Fpoint_marker ();
4582 register ptrdiff_t pos
, pos_byte
;
4583 register int ht
= window_internal_height (w
);
4584 register Lisp_Object tem
;
4588 Lisp_Object original_pos
= Qnil
;
4590 /* If scrolling screen-fulls, compute the number of lines to
4591 scroll from the window's height. */
4593 n
*= max (1, ht
- next_screen_context_lines
);
4595 startpos
= marker_position (w
->start
);
4597 if (!NILP (Vscroll_preserve_screen_position
))
4599 if (window_scroll_preserve_vpos
<= 0
4600 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4601 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4603 struct position posit
4604 = *compute_motion (startpos
, 0, 0, 0,
4606 -1, XINT (w
->hscroll
),
4608 window_scroll_preserve_vpos
= posit
.vpos
;
4609 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
4612 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4613 make_number (window_scroll_preserve_vpos
));
4616 XSETFASTINT (tem
, PT
);
4617 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4621 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4626 lose
= n
< 0 && PT
== BEGV
;
4627 Fvertical_motion (make_number (n
), window
);
4631 SET_PT_BOTH (marker_position (opoint_marker
),
4632 marker_byte_position (opoint_marker
));
4639 xsignal0 (Qbeginning_of_buffer
);
4644 /* Don't use a scroll margin that is negative or too large. */
4645 int this_scroll_margin
=
4646 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4648 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4649 w
->start_at_line_beg
= bolp
;
4650 w
->update_mode_line
= Qt
;
4651 XSETFASTINT (w
->last_modified
, 0);
4652 XSETFASTINT (w
->last_overlay_modified
, 0);
4653 /* Set force_start so that redisplay_window will run
4654 the window-scroll-functions. */
4655 w
->force_start
= Qt
;
4657 if (!NILP (Vscroll_preserve_screen_position
)
4658 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4660 SET_PT_BOTH (pos
, pos_byte
);
4661 Fvertical_motion (original_pos
, window
);
4663 /* If we scrolled forward, put point enough lines down
4664 that it is outside the scroll margin. */
4669 if (this_scroll_margin
> 0)
4671 SET_PT_BOTH (pos
, pos_byte
);
4672 Fvertical_motion (make_number (this_scroll_margin
), window
);
4678 if (top_margin
<= marker_position (opoint_marker
))
4679 SET_PT_BOTH (marker_position (opoint_marker
),
4680 marker_byte_position (opoint_marker
));
4681 else if (!NILP (Vscroll_preserve_screen_position
))
4683 SET_PT_BOTH (pos
, pos_byte
);
4684 Fvertical_motion (original_pos
, window
);
4687 SET_PT (top_margin
);
4693 /* If we scrolled backward, put point near the end of the window
4694 but not within the scroll margin. */
4695 SET_PT_BOTH (pos
, pos_byte
);
4696 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4697 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4700 bottom_margin
= PT
+ 1;
4702 if (bottom_margin
> marker_position (opoint_marker
))
4703 SET_PT_BOTH (marker_position (opoint_marker
),
4704 marker_byte_position (opoint_marker
));
4707 if (!NILP (Vscroll_preserve_screen_position
))
4709 SET_PT_BOTH (pos
, pos_byte
);
4710 Fvertical_motion (original_pos
, window
);
4713 Fvertical_motion (make_number (-1), window
);
4722 xsignal0 (Qend_of_buffer
);
4727 /* Scroll selected_window up or down. If N is nil, scroll a
4728 screen-full which is defined as the height of the window minus
4729 next_screen_context_lines. If N is the symbol `-', scroll.
4730 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4731 up. This is the guts of Fscroll_up and Fscroll_down. */
4734 scroll_command (Lisp_Object n
, int direction
)
4736 ptrdiff_t count
= SPECPDL_INDEX ();
4738 xassert (eabs (direction
) == 1);
4740 /* If selected window's buffer isn't current, make it current for
4741 the moment. But don't screw up if window_scroll gets an error. */
4742 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4744 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4745 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4747 /* Make redisplay consider other windows than just selected_window. */
4748 ++windows_or_buffers_changed
;
4752 window_scroll (selected_window
, direction
, 1, 0);
4753 else if (EQ (n
, Qminus
))
4754 window_scroll (selected_window
, -direction
, 1, 0);
4757 n
= Fprefix_numeric_value (n
);
4758 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4761 unbind_to (count
, Qnil
);
4764 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4765 doc
: /* Scroll text of selected window upward ARG lines.
4766 If ARG is omitted or nil, scroll upward by a near full screen.
4767 A near full screen is `next-screen-context-lines' less than a full screen.
4768 Negative ARG means scroll downward.
4769 If ARG is the atom `-', scroll downward by nearly full screen.
4770 When calling from a program, supply as argument a number, nil, or `-'. */)
4773 scroll_command (arg
, 1);
4777 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4778 doc
: /* Scroll text of selected window down ARG lines.
4779 If ARG is omitted or nil, scroll down by a near full screen.
4780 A near full screen is `next-screen-context-lines' less than a full screen.
4781 Negative ARG means scroll upward.
4782 If ARG is the atom `-', scroll upward by nearly full screen.
4783 When calling from a program, supply as argument a number, nil, or `-'. */)
4786 scroll_command (arg
, -1);
4790 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4791 doc
: /* Return the other window for \"other window scroll\" commands.
4792 If `other-window-scroll-buffer' is non-nil, a window
4793 showing that buffer is used.
4794 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4795 specifies the window. This takes precedence over
4796 `other-window-scroll-buffer'. */)
4801 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4802 && !NILP (Vminibuf_scroll_window
))
4803 window
= Vminibuf_scroll_window
;
4804 /* If buffer is specified, scroll that buffer. */
4805 else if (!NILP (Vother_window_scroll_buffer
))
4807 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4809 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4813 /* Nothing specified; look for a neighboring window on the same
4815 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4817 if (EQ (window
, selected_window
))
4818 /* That didn't get us anywhere; look for a window on another
4821 window
= Fnext_window (window
, Qnil
, Qt
);
4822 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4823 && ! EQ (window
, selected_window
));
4826 CHECK_LIVE_WINDOW (window
);
4828 if (EQ (window
, selected_window
))
4829 error ("There is no other window");
4834 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4835 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4836 A near full screen is `next-screen-context-lines' less than a full screen.
4837 The next window is the one below the current one; or the one at the top
4838 if the current one is at the bottom. Negative ARG means scroll downward.
4839 If ARG is the atom `-', scroll downward by nearly full screen.
4840 When calling from a program, supply as argument a number, nil, or `-'.
4842 If `other-window-scroll-buffer' is non-nil, scroll the window
4843 showing that buffer, popping the buffer up if necessary.
4844 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4845 specifies the window to scroll. This takes precedence over
4846 `other-window-scroll-buffer'. */)
4851 ptrdiff_t count
= SPECPDL_INDEX ();
4853 window
= Fother_window_for_scrolling ();
4854 w
= XWINDOW (window
);
4856 /* Don't screw up if window_scroll gets an error. */
4857 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4858 ++windows_or_buffers_changed
;
4860 Fset_buffer (w
->buffer
);
4861 SET_PT (marker_position (w
->pointm
));
4864 window_scroll (window
, 1, 1, 1);
4865 else if (EQ (arg
, Qminus
))
4866 window_scroll (window
, -1, 1, 1);
4872 window_scroll (window
, XINT (arg
), 0, 1);
4875 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4876 unbind_to (count
, Qnil
);
4881 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
4882 doc
: /* Scroll selected window display ARG columns left.
4883 Default for ARG is window width minus 2.
4884 Value is the total amount of leftward horizontal scrolling in
4885 effect after the change.
4886 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4887 lower bound for automatic scrolling, i.e. automatic scrolling
4888 will not scroll a window to a column less than the value returned
4889 by this function. This happens in an interactive call. */)
4890 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4894 struct window
*w
= XWINDOW (selected_window
);
4897 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4899 arg
= Fprefix_numeric_value (arg
);
4901 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
4902 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4904 if (!NILP (set_minimum
))
4905 w
->min_hscroll
= w
->hscroll
;
4910 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
4911 doc
: /* Scroll selected window display ARG columns right.
4912 Default for ARG is window width minus 2.
4913 Value is the total amount of leftward horizontal scrolling in
4914 effect after the change.
4915 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4916 lower bound for automatic scrolling, i.e. automatic scrolling
4917 will not scroll a window to a column less than the value returned
4918 by this function. This happens in an interactive call. */)
4919 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4923 struct window
*w
= XWINDOW (selected_window
);
4926 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4928 arg
= Fprefix_numeric_value (arg
);
4930 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
4931 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4933 if (!NILP (set_minimum
))
4934 w
->min_hscroll
= w
->hscroll
;
4939 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
4940 doc
: /* Return the window which was selected when entering the minibuffer.
4941 Returns nil, if selected window is not a minibuffer window. */)
4944 if (minibuf_level
> 0
4945 && MINI_WINDOW_P (XWINDOW (selected_window
))
4946 && WINDOW_LIVE_P (minibuf_selected_window
))
4947 return minibuf_selected_window
;
4952 /* Value is the number of lines actually displayed in window W,
4953 as opposed to its height. */
4956 displayed_window_lines (struct window
*w
)
4959 struct text_pos start
;
4960 int height
= window_box_height (w
);
4961 struct buffer
*old_buffer
;
4963 void *itdata
= NULL
;
4965 if (XBUFFER (w
->buffer
) != current_buffer
)
4967 old_buffer
= current_buffer
;
4968 set_buffer_internal (XBUFFER (w
->buffer
));
4973 /* In case W->start is out of the accessible range, do something
4974 reasonable. This happens in Info mode when Info-scroll-down
4975 calls (recenter -1) while W->start is 1. */
4976 if (XMARKER (w
->start
)->charpos
< BEGV
)
4977 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4978 else if (XMARKER (w
->start
)->charpos
> ZV
)
4979 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
4981 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4983 itdata
= bidi_shelve_cache ();
4984 start_display (&it
, w
, start
);
4985 move_it_vertically (&it
, height
);
4986 bottom_y
= line_bottom_y (&it
);
4987 bidi_unshelve_cache (itdata
, 0);
4989 /* rms: On a non-window display,
4990 the value of it.vpos at the bottom of the screen
4991 seems to be 1 larger than window_box_height (w).
4992 This kludge fixes a bug whereby (move-to-window-line -1)
4993 when ZV is on the last screen line
4994 moves to the previous screen line instead of the last one. */
4995 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
4998 /* Add in empty lines at the bottom of the window. */
4999 if (bottom_y
< height
)
5001 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5002 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5006 set_buffer_internal (old_buffer
);
5012 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5013 doc
: /* Center point in selected window and maybe redisplay frame.
5014 With prefix argument ARG, recenter putting point on screen line ARG
5015 relative to the selected window. If ARG is negative, it counts up from the
5016 bottom of the window. (ARG should be less than the height of the window.)
5018 If ARG is omitted or nil, then recenter with point on the middle line of
5019 the selected window; if the variable `recenter-redisplay' is non-nil,
5020 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5021 is set to `grow-only', this resets the tool-bar's height to the minimum
5022 height needed); if `recenter-redisplay' has the special value `tty',
5023 then only tty frame are redrawn.
5025 Just C-u as prefix means put point in the center of the window
5026 and redisplay normally--don't erase and redraw the frame. */)
5027 (register Lisp_Object arg
)
5029 struct window
*w
= XWINDOW (selected_window
);
5030 struct buffer
*buf
= XBUFFER (w
->buffer
);
5031 struct buffer
*obuf
= current_buffer
;
5033 ptrdiff_t charpos
, bytepos
;
5034 EMACS_INT iarg
IF_LINT (= 0);
5035 int this_scroll_margin
;
5037 /* If redisplay is suppressed due to an error, try again. */
5038 obuf
->display_error_modiff
= 0;
5042 if (!NILP (Vrecenter_redisplay
)
5043 && (!EQ (Vrecenter_redisplay
, Qtty
)
5044 || !NILP (Ftty_type (selected_frame
))))
5048 /* Invalidate pixel data calculated for all compositions. */
5049 for (i
= 0; i
< n_compositions
; i
++)
5050 composition_table
[i
]->font
= NULL
;
5052 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5054 Fredraw_frame (WINDOW_FRAME (w
));
5055 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5060 else if (CONSP (arg
)) /* Just C-u. */
5064 arg
= Fprefix_numeric_value (arg
);
5069 set_buffer_internal (buf
);
5071 /* Do this after making BUF current
5072 in case scroll_margin is buffer-local. */
5073 this_scroll_margin
=
5074 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5076 /* Handle centering on a graphical frame specially. Such frames can
5077 have variable-height lines and centering point on the basis of
5078 line counts would lead to strange effects. */
5079 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5085 void *itdata
= bidi_shelve_cache ();
5087 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5088 start_display (&it
, w
, pt
);
5089 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5090 charpos
= IT_CHARPOS (it
);
5091 bytepos
= IT_BYTEPOS (it
);
5092 bidi_unshelve_cache (itdata
, 0);
5098 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5099 int extra_line_spacing
;
5100 int h
= window_box_height (w
);
5101 void *itdata
= bidi_shelve_cache ();
5103 iarg
= - max (-iarg
, this_scroll_margin
);
5105 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5106 start_display (&it
, w
, pt
);
5108 /* Be sure we have the exact height of the full line containing PT. */
5109 move_it_by_lines (&it
, 0);
5111 /* The amount of pixels we have to move back is the window
5112 height minus what's displayed in the line containing PT,
5113 and the lines below. */
5116 move_it_by_lines (&it
, nlines
);
5118 if (it
.vpos
== nlines
)
5122 /* Last line has no newline */
5123 h
-= line_bottom_y (&it
);
5127 /* Don't reserve space for extra line spacing of last line. */
5128 extra_line_spacing
= it
.max_extra_line_spacing
;
5130 /* If we can't move down NLINES lines because we hit
5131 the end of the buffer, count in some empty lines. */
5132 if (it
.vpos
< nlines
)
5135 extra_line_spacing
= it
.extra_line_spacing
;
5136 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5140 bidi_unshelve_cache (itdata
, 0);
5144 /* Now find the new top line (starting position) of the window. */
5145 start_display (&it
, w
, pt
);
5147 move_it_vertically_backward (&it
, h
);
5149 /* If extra line spacing is present, we may move too far
5150 back. This causes the last line to be only partially
5151 visible (which triggers redisplay to recenter that line
5152 in the middle), so move forward.
5153 But ignore extra line spacing on last line, as it is not
5154 considered to be part of the visible height of the line.
5156 h
+= extra_line_spacing
;
5157 while (-it
.current_y
> h
)
5158 move_it_by_lines (&it
, 1);
5160 charpos
= IT_CHARPOS (it
);
5161 bytepos
= IT_BYTEPOS (it
);
5163 bidi_unshelve_cache (itdata
, 0);
5167 struct position pos
;
5169 iarg
= max (iarg
, this_scroll_margin
);
5171 pos
= *vmotion (PT
, -iarg
, w
);
5172 charpos
= pos
.bufpos
;
5173 bytepos
= pos
.bytepos
;
5178 struct position pos
;
5179 int ht
= window_internal_height (w
);
5186 /* Don't let it get into the margin at either top or bottom. */
5187 iarg
= max (iarg
, this_scroll_margin
);
5188 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5190 pos
= *vmotion (PT
, - iarg
, w
);
5191 charpos
= pos
.bufpos
;
5192 bytepos
= pos
.bytepos
;
5195 /* Set the new window start. */
5196 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5197 w
->window_end_valid
= Qnil
;
5199 w
->optional_new_start
= Qt
;
5201 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5202 w
->start_at_line_beg
= Qt
;
5204 w
->start_at_line_beg
= Qnil
;
5206 set_buffer_internal (obuf
);
5210 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5212 doc
: /* Return the height in lines of the text display area of WINDOW.
5213 WINDOW defaults to the selected window.
5215 The return value does not include the mode line, any header line, nor
5216 any partial-height lines in the text display area. */)
5217 (Lisp_Object window
)
5219 struct window
*w
= decode_window (window
);
5220 int pixel_height
= window_box_height (w
);
5221 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5222 return make_number (line_height
);
5227 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5229 doc
: /* Position point relative to window.
5230 ARG nil means position point at center of window.
5231 Else, ARG specifies vertical position within the window;
5232 zero means top of window, negative means relative to bottom of window. */)
5235 struct window
*w
= XWINDOW (selected_window
);
5239 int this_scroll_margin
;
5242 if (!(BUFFERP (w
->buffer
)
5243 && XBUFFER (w
->buffer
) == current_buffer
))
5244 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5245 when passed below to set_marker_both. */
5246 error ("move-to-window-line called from unrelated buffer");
5248 window
= selected_window
;
5249 start
= marker_position (w
->start
);
5250 if (start
< BEGV
|| start
> ZV
)
5252 int height
= window_internal_height (w
);
5253 Fvertical_motion (make_number (- (height
/ 2)), window
);
5254 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5255 w
->start_at_line_beg
= Fbolp ();
5256 w
->force_start
= Qt
;
5259 Fgoto_char (w
->start
);
5261 lines
= displayed_window_lines (w
);
5264 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5268 XSETFASTINT (arg
, lines
/ 2);
5271 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5274 iarg
= iarg
+ lines
;
5276 #if 0 /* This code would prevent move-to-window-line from moving point
5277 to a place inside the scroll margins (which would cause the
5278 next redisplay to scroll). I wrote this code, but then concluded
5279 it is probably better not to install it. However, it is here
5280 inside #if 0 so as not to lose it. -- rms. */
5282 /* Don't let it get into the margin at either top or bottom. */
5283 iarg
= max (iarg
, this_scroll_margin
);
5284 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5287 arg
= make_number (iarg
);
5290 /* Skip past a partially visible first line. */
5292 XSETINT (arg
, XINT (arg
) + 1);
5294 return Fvertical_motion (arg
, window
);
5299 /***********************************************************************
5300 Window Configuration
5301 ***********************************************************************/
5303 struct save_window_data
5305 struct vectorlike_header header
;
5306 Lisp_Object selected_frame
;
5307 Lisp_Object current_window
;
5308 Lisp_Object current_buffer
;
5309 Lisp_Object minibuf_scroll_window
;
5310 Lisp_Object minibuf_selected_window
;
5311 Lisp_Object root_window
;
5312 Lisp_Object focus_frame
;
5313 /* A vector, each of whose elements is a struct saved_window
5315 Lisp_Object saved_windows
;
5317 /* All fields above are traced by the GC.
5318 From `fame-cols' down, the fields are ignored by the GC. */
5320 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5321 int frame_tool_bar_lines
;
5324 /* This is saved as a Lisp_Vector */
5327 struct vectorlike_header header
;
5329 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5330 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5331 Lisp_Object normal_cols
, normal_lines
;
5332 Lisp_Object hscroll
, min_hscroll
;
5333 Lisp_Object parent
, prev
;
5334 Lisp_Object start_at_line_beg
;
5335 Lisp_Object display_table
;
5336 Lisp_Object left_margin_cols
, right_margin_cols
;
5337 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5338 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5339 Lisp_Object splits
, nest
, window_parameters
;
5342 #define SAVED_WINDOW_N(swv,n) \
5343 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5345 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5346 doc
: /* Return t if OBJECT is a window-configuration object. */)
5347 (Lisp_Object object
)
5349 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5352 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5353 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5354 (Lisp_Object config
)
5356 register struct save_window_data
*data
;
5357 struct Lisp_Vector
*saved_windows
;
5359 CHECK_WINDOW_CONFIGURATION (config
);
5361 data
= (struct save_window_data
*) XVECTOR (config
);
5362 saved_windows
= XVECTOR (data
->saved_windows
);
5363 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5366 DEFUN ("set-window-configuration", Fset_window_configuration
,
5367 Sset_window_configuration
, 1, 1, 0,
5368 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5369 CONFIGURATION must be a value previously returned
5370 by `current-window-configuration' (which see).
5371 If CONFIGURATION was made from a frame that is now deleted,
5372 only frame-independent values can be restored. In this case,
5373 the return value is nil. Otherwise the value is t. */)
5374 (Lisp_Object configuration
)
5376 register struct save_window_data
*data
;
5377 struct Lisp_Vector
*saved_windows
;
5378 Lisp_Object new_current_buffer
;
5380 Lisp_Object auto_buffer_name
;
5382 ptrdiff_t old_point
= -1;
5384 CHECK_WINDOW_CONFIGURATION (configuration
);
5386 data
= (struct save_window_data
*) XVECTOR (configuration
);
5387 saved_windows
= XVECTOR (data
->saved_windows
);
5389 new_current_buffer
= data
->current_buffer
;
5390 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5391 new_current_buffer
= Qnil
;
5394 if (XBUFFER (new_current_buffer
) == current_buffer
)
5395 /* The code further down "preserves point" by saving here PT in
5396 old_point and then setting it later back into PT. When the
5397 current-selected-window and the final-selected-window both show
5398 the current buffer, this suffers from the problem that the
5399 current PT is the window-point of the current-selected-window,
5400 while the final PT is the point of the final-selected-window, so
5401 this copy from one PT to the other would end up moving the
5402 window-point of the final-selected-window to the window-point of
5403 the current-selected-window. So we have to be careful which
5404 point of the current-buffer we copy into old_point. */
5405 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5406 && WINDOWP (selected_window
)
5407 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5408 && !EQ (selected_window
, data
->current_window
))
5409 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5413 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5414 point in new_current_buffer as of the last time this buffer was
5415 used. This can be non-deterministic since it can be changed by
5416 things like jit-lock by mere temporary selection of some random
5417 window that happens to show this buffer.
5418 So if possible we want this arbitrary choice of "which point" to
5419 be the one from the to-be-selected-window so as to prevent this
5420 window's cursor from being copied from another window. */
5421 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5422 /* If current_window = selected_window, its point is in BUF_PT. */
5423 && !EQ (selected_window
, data
->current_window
))
5424 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5426 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5429 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5432 /* If f is a dead frame, don't bother rebuilding its window tree.
5433 However, there is other stuff we should still try to do below. */
5434 if (FRAME_LIVE_P (f
))
5437 Lisp_Object dead_windows
= Qnil
;
5438 register struct window
*w
;
5439 register struct saved_window
*p
;
5440 struct window
*root_window
;
5441 struct window
**leaf_windows
;
5446 /* If the frame has been resized since this window configuration was
5447 made, we change the frame to the size specified in the
5448 configuration, restore the configuration, and then resize it
5449 back. We keep track of the prevailing height in these variables. */
5450 int previous_frame_lines
= FRAME_LINES (f
);
5451 int previous_frame_cols
= FRAME_COLS (f
);
5452 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5453 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5455 /* The mouse highlighting code could get screwed up
5456 if it runs during this. */
5459 if (data
->frame_lines
!= previous_frame_lines
5460 || data
->frame_cols
!= previous_frame_cols
)
5461 change_frame_size (f
, data
->frame_lines
,
5462 data
->frame_cols
, 0, 0, 0);
5463 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5464 if (data
->frame_menu_bar_lines
5465 != previous_frame_menu_bar_lines
)
5466 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5468 #ifdef HAVE_WINDOW_SYSTEM
5469 if (data
->frame_tool_bar_lines
5470 != previous_frame_tool_bar_lines
)
5471 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5476 /* "Swap out" point from the selected window's buffer
5477 into the window itself. (Normally the pointm of the selected
5478 window holds garbage.) We do this now, before
5479 restoring the window contents, and prevent it from
5480 being done later on when we select a new window. */
5481 if (! NILP (XWINDOW (selected_window
)->buffer
))
5483 w
= XWINDOW (selected_window
);
5484 set_marker_both (w
->pointm
,
5486 BUF_PT (XBUFFER (w
->buffer
)),
5487 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5490 windows_or_buffers_changed
++;
5491 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5493 /* Problem: Freeing all matrices and later allocating them again
5494 is a serious redisplay flickering problem. What we would
5495 really like to do is to free only those matrices not reused
5497 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5499 = (struct window
**) alloca (count_windows (root_window
)
5500 * sizeof (struct window
*));
5501 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5504 Mark all windows now on frame as "deleted".
5505 Restoring the new configuration "undeletes" any that are in it.
5507 Save their current buffers in their height fields, since we may
5508 need it later, if a buffer saved in the configuration is now
5510 delete_all_subwindows (FRAME_ROOT_WINDOW (f
));
5512 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5514 p
= SAVED_WINDOW_N (saved_windows
, k
);
5516 w
= XWINDOW (window
);
5519 if (!NILP (p
->parent
))
5520 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5521 XFASTINT (p
->parent
))->window
;
5525 if (!NILP (p
->prev
))
5527 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5528 XFASTINT (p
->prev
))->window
;
5529 XWINDOW (w
->prev
)->next
= p
->window
;
5534 if (!NILP (w
->parent
))
5536 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5538 XWINDOW (w
->parent
)->vchild
= p
->window
;
5539 XWINDOW (w
->parent
)->hchild
= Qnil
;
5543 XWINDOW (w
->parent
)->hchild
= p
->window
;
5544 XWINDOW (w
->parent
)->vchild
= Qnil
;
5549 /* If we squirreled away the buffer in the window's height,
5551 if (BUFFERP (w
->total_lines
))
5552 w
->buffer
= w
->total_lines
;
5553 w
->left_col
= p
->left_col
;
5554 w
->top_line
= p
->top_line
;
5555 w
->total_cols
= p
->total_cols
;
5556 w
->total_lines
= p
->total_lines
;
5557 w
->normal_cols
= p
->normal_cols
;
5558 w
->normal_lines
= p
->normal_lines
;
5559 w
->hscroll
= p
->hscroll
;
5560 w
->min_hscroll
= p
->min_hscroll
;
5561 w
->display_table
= p
->display_table
;
5562 w
->left_margin_cols
= p
->left_margin_cols
;
5563 w
->right_margin_cols
= p
->right_margin_cols
;
5564 w
->left_fringe_width
= p
->left_fringe_width
;
5565 w
->right_fringe_width
= p
->right_fringe_width
;
5566 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5567 w
->scroll_bar_width
= p
->scroll_bar_width
;
5568 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5569 w
->dedicated
= p
->dedicated
;
5570 w
->splits
= p
->splits
;
5572 w
->window_parameters
= p
->window_parameters
;
5573 XSETFASTINT (w
->last_modified
, 0);
5574 XSETFASTINT (w
->last_overlay_modified
, 0);
5576 /* Reinstall the saved buffer and pointers into it. */
5577 if (NILP (p
->buffer
))
5578 /* An internal window. */
5579 w
->buffer
= p
->buffer
;
5580 else if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5581 /* If saved buffer is alive, install it. */
5583 w
->buffer
= p
->buffer
;
5584 w
->start_at_line_beg
= p
->start_at_line_beg
;
5585 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5586 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5587 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5588 p
->mark
, w
->buffer
);
5590 /* As documented in Fcurrent_window_configuration, don't
5591 restore the location of point in the buffer which was
5592 current when the window configuration was recorded. */
5593 if (!EQ (p
->buffer
, new_current_buffer
)
5594 && XBUFFER (p
->buffer
) == current_buffer
)
5595 Fgoto_char (w
->pointm
);
5597 else if (!NILP (w
->buffer
) && !NILP (BVAR (XBUFFER (w
->buffer
), name
)))
5598 /* Keep window's old buffer; make sure the markers are
5601 /* Set window markers at start of visible range. */
5602 if (XMARKER (w
->start
)->buffer
== 0)
5603 set_marker_restricted (w
->start
, make_number (0),
5605 if (XMARKER (w
->pointm
)->buffer
== 0)
5606 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5607 BUF_PT (XBUFFER (w
->buffer
)),
5608 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5609 w
->start_at_line_beg
= Qt
;
5611 else if (STRINGP (auto_buffer_name
=
5612 Fwindow_parameter (window
, Qauto_buffer_name
))
5613 && SCHARS (auto_buffer_name
) != 0
5614 && !NILP (w
->buffer
= Fget_buffer_create (auto_buffer_name
)))
5616 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5617 set_marker_restricted (w
->pointm
, make_number (0), w
->buffer
);
5618 w
->start_at_line_beg
= Qt
;
5621 /* Window has no live buffer, get one. */
5623 /* Get the buffer via other_buffer_safely in order to
5624 avoid showing an unimportant buffer and, if necessary, to
5625 recreate *scratch* in the course (part of Juanma's bs-show
5626 scenario from March 2011). */
5627 w
->buffer
= other_buffer_safely (Fcurrent_buffer ());
5628 /* This will set the markers to beginning of visible
5630 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5631 set_marker_restricted (w
->pointm
, make_number (0), w
->buffer
);
5632 w
->start_at_line_beg
= Qt
;
5633 if (!NILP (w
->dedicated
))
5634 /* Record this window as dead. */
5635 dead_windows
= Fcons (window
, dead_windows
);
5636 /* Make sure window is no more dedicated. */
5637 w
->dedicated
= Qnil
;
5641 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5642 /* Arrange *not* to restore point in the buffer that was
5643 current when the window configuration was saved. */
5644 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5645 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5646 make_number (old_point
),
5647 XWINDOW (data
->current_window
)->buffer
);
5649 /* In the following call to `select-window', prevent "swapping out
5650 point" in the old selected window using the buffer that has
5651 been restored into it. We already swapped out that point from
5652 that window's old buffer. */
5653 select_window (data
->current_window
, Qnil
, 1);
5654 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5657 if (NILP (data
->focus_frame
)
5658 || (FRAMEP (data
->focus_frame
)
5659 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5660 Fredirect_frame_focus (frame
, data
->focus_frame
);
5662 /* Set the screen height to the value it had before this function. */
5663 if (previous_frame_lines
!= FRAME_LINES (f
)
5664 || previous_frame_cols
!= FRAME_COLS (f
))
5665 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5667 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5668 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5669 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5671 #ifdef HAVE_WINDOW_SYSTEM
5672 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5673 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5678 /* Now, free glyph matrices in windows that were not reused. */
5679 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5681 if (NILP (leaf_windows
[i
]->buffer
))
5683 /* Assert it's not reused as a combination. */
5684 xassert (NILP (leaf_windows
[i
]->hchild
)
5685 && NILP (leaf_windows
[i
]->vchild
));
5686 free_window_matrices (leaf_windows
[i
]);
5688 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5695 /* Scan dead buffer windows. */
5696 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5698 window
= XCAR (dead_windows
);
5699 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5700 delete_deletable_window (window
);
5703 /* Fselect_window will have made f the selected frame, so we
5704 reselect the proper frame here. Fhandle_switch_frame will change the
5705 selected window too, but that doesn't make the call to
5706 Fselect_window above totally superfluous; it still sets f's
5708 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5709 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5711 run_window_configuration_change_hook (f
);
5714 if (!NILP (new_current_buffer
))
5715 Fset_buffer (new_current_buffer
);
5717 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5718 minibuf_selected_window
= data
->minibuf_selected_window
;
5720 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5724 /* Delete all subwindows reachable via the next, vchild, and hchild
5727 delete_all_subwindows (Lisp_Object window
)
5729 register struct window
*w
;
5731 w
= XWINDOW (window
);
5733 if (!NILP (w
->next
))
5734 /* Delete WINDOW's siblings (we traverse postorderly). */
5735 delete_all_subwindows (w
->next
);
5737 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5739 if (!NILP (w
->vchild
))
5741 delete_all_subwindows (w
->vchild
);
5744 else if (!NILP (w
->hchild
))
5746 delete_all_subwindows (w
->hchild
);
5749 else if (!NILP (w
->buffer
))
5752 unchain_marker (XMARKER (w
->pointm
));
5753 unchain_marker (XMARKER (w
->start
));
5757 Vwindow_list
= Qnil
;
5761 count_windows (register struct window
*window
)
5763 register int count
= 1;
5764 if (!NILP (window
->next
))
5765 count
+= count_windows (XWINDOW (window
->next
));
5766 if (!NILP (window
->vchild
))
5767 count
+= count_windows (XWINDOW (window
->vchild
));
5768 if (!NILP (window
->hchild
))
5769 count
+= count_windows (XWINDOW (window
->hchild
));
5774 /* Fill vector FLAT with leaf windows under W, starting at index I.
5775 Value is last index + 1. */
5777 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5781 if (!NILP (w
->hchild
))
5782 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5783 else if (!NILP (w
->vchild
))
5784 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5788 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5795 /* Return a pointer to the glyph W's physical cursor is on. Value is
5796 null if W's current matrix is invalid, so that no meaningfull glyph
5799 get_phys_cursor_glyph (struct window
*w
)
5801 struct glyph_row
*row
;
5802 struct glyph
*glyph
;
5804 if (w
->phys_cursor
.vpos
>= 0
5805 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5806 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5808 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5809 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5818 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
5820 register struct saved_window
*p
;
5821 register struct window
*w
;
5822 register Lisp_Object tem
;
5824 for (;!NILP (window
); window
= w
->next
)
5826 p
= SAVED_WINDOW_N (vector
, i
);
5827 w
= XWINDOW (window
);
5829 XSETFASTINT (w
->temslot
, i
); i
++;
5831 p
->buffer
= w
->buffer
;
5832 p
->left_col
= w
->left_col
;
5833 p
->top_line
= w
->top_line
;
5834 p
->total_cols
= w
->total_cols
;
5835 p
->total_lines
= w
->total_lines
;
5836 p
->normal_cols
= w
->normal_cols
;
5837 p
->normal_lines
= w
->normal_lines
;
5838 p
->hscroll
= w
->hscroll
;
5839 p
->min_hscroll
= w
->min_hscroll
;
5840 p
->display_table
= w
->display_table
;
5841 p
->left_margin_cols
= w
->left_margin_cols
;
5842 p
->right_margin_cols
= w
->right_margin_cols
;
5843 p
->left_fringe_width
= w
->left_fringe_width
;
5844 p
->right_fringe_width
= w
->right_fringe_width
;
5845 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
5846 p
->scroll_bar_width
= w
->scroll_bar_width
;
5847 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5848 p
->dedicated
= w
->dedicated
;
5849 p
->splits
= w
->splits
;
5851 p
->window_parameters
= w
->window_parameters
;
5852 if (!NILP (w
->buffer
))
5854 /* Save w's value of point in the window configuration.
5855 If w is the selected window, then get the value of point
5856 from the buffer; pointm is garbage in the selected window. */
5857 if (EQ (window
, selected_window
))
5859 p
->pointm
= Fmake_marker ();
5860 set_marker_both (p
->pointm
, w
->buffer
,
5861 BUF_PT (XBUFFER (w
->buffer
)),
5862 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5865 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5867 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5868 p
->start_at_line_beg
= w
->start_at_line_beg
;
5870 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
5871 p
->mark
= Fcopy_marker (tem
, Qnil
);
5878 p
->start_at_line_beg
= Qnil
;
5881 if (NILP (w
->parent
))
5884 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5889 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5891 if (!NILP (w
->vchild
))
5892 i
= save_window_save (w
->vchild
, vector
, i
);
5893 if (!NILP (w
->hchild
))
5894 i
= save_window_save (w
->hchild
, vector
, i
);
5900 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5901 Scurrent_window_configuration
, 0, 1, 0,
5902 doc
: /* Return an object representing the current window configuration of FRAME.
5903 If FRAME is nil or omitted, use the selected frame.
5904 This describes the number of windows, their sizes and current buffers,
5905 and for each displayed buffer, where display starts, and the positions of
5906 point and mark. An exception is made for point in the current buffer:
5907 its value is -not- saved.
5908 This also records the currently selected frame, and FRAME's focus
5909 redirection (see `redirect-frame-focus'). */)
5912 register Lisp_Object tem
;
5913 register int n_windows
;
5914 register struct save_window_data
*data
;
5919 frame
= selected_frame
;
5920 CHECK_LIVE_FRAME (frame
);
5923 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5924 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
5925 PVEC_WINDOW_CONFIGURATION
);
5927 data
->frame_cols
= FRAME_COLS (f
);
5928 data
->frame_lines
= FRAME_LINES (f
);
5929 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5930 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5931 data
->selected_frame
= selected_frame
;
5932 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5933 XSETBUFFER (data
->current_buffer
, current_buffer
);
5934 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
5935 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
5936 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5937 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5938 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5939 data
->saved_windows
= tem
;
5940 for (i
= 0; i
< n_windows
; i
++)
5941 XVECTOR (tem
)->contents
[i
]
5942 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
5943 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5944 XSETWINDOW_CONFIGURATION (tem
, data
);
5948 /***********************************************************************
5950 ***********************************************************************/
5952 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5954 doc
: /* Set width of marginal areas of window WINDOW.
5955 If WINDOW is nil, set margins of the currently selected window.
5956 Second arg LEFT-WIDTH specifies the number of character cells to
5957 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
5958 does the same for the right marginal area. A nil width parameter
5959 means no margin. */)
5960 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
5962 struct window
*w
= decode_window (window
);
5964 /* Translate negative or zero widths to nil.
5965 Margins that are too wide have to be checked elsewhere. */
5967 if (!NILP (left_width
))
5969 CHECK_NUMBER (left_width
);
5970 if (XINT (left_width
) <= 0)
5974 if (!NILP (right_width
))
5976 CHECK_NUMBER (right_width
);
5977 if (XINT (right_width
) <= 0)
5981 if (!EQ (w
->left_margin_cols
, left_width
)
5982 || !EQ (w
->right_margin_cols
, right_width
))
5984 w
->left_margin_cols
= left_width
;
5985 w
->right_margin_cols
= right_width
;
5987 adjust_window_margins (w
);
5989 ++windows_or_buffers_changed
;
5990 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
5997 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
5999 doc
: /* Get width of marginal areas of window WINDOW.
6000 If WINDOW is omitted or nil, use the currently selected window.
6001 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6002 If a marginal area does not exist, its width will be returned
6004 (Lisp_Object window
)
6006 struct window
*w
= decode_window (window
);
6007 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6012 /***********************************************************************
6014 ***********************************************************************/
6016 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6018 doc
: /* Set the fringe widths of window WINDOW.
6019 If WINDOW is nil, set the fringe widths of the currently selected
6021 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6022 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6023 fringe width. If a fringe width arg is nil, that means to use the
6024 frame's default fringe width. Default fringe widths can be set with
6025 the command `set-fringe-style'.
6026 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6027 outside of the display margins. By default, fringes are drawn between
6028 display marginal areas and the text area. */)
6029 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6031 struct window
*w
= decode_window (window
);
6033 if (!NILP (left_width
))
6034 CHECK_NATNUM (left_width
);
6035 if (!NILP (right_width
))
6036 CHECK_NATNUM (right_width
);
6038 /* Do nothing on a tty. */
6039 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6040 && (!EQ (w
->left_fringe_width
, left_width
)
6041 || !EQ (w
->right_fringe_width
, right_width
)
6042 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6044 w
->left_fringe_width
= left_width
;
6045 w
->right_fringe_width
= right_width
;
6046 w
->fringes_outside_margins
= outside_margins
;
6048 adjust_window_margins (w
);
6050 clear_glyph_matrix (w
->current_matrix
);
6051 w
->window_end_valid
= Qnil
;
6053 ++windows_or_buffers_changed
;
6054 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6061 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6063 doc
: /* Get width of fringes of window WINDOW.
6064 If WINDOW is omitted or nil, use the currently selected window.
6065 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6066 (Lisp_Object window
)
6068 struct window
*w
= decode_window (window
);
6070 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6071 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6072 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6073 ? Qt
: Qnil
), Qnil
)));
6078 /***********************************************************************
6080 ***********************************************************************/
6082 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6083 Sset_window_scroll_bars
, 2, 4, 0,
6084 doc
: /* Set width and type of scroll bars of window WINDOW.
6085 If window is nil, set scroll bars of the currently selected window.
6086 Second parameter WIDTH specifies the pixel width for the scroll bar;
6087 this is automatically adjusted to a multiple of the frame column width.
6088 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6089 bar: left, right, or nil.
6090 If WIDTH is nil, use the frame's scroll-bar width.
6091 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6092 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6093 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6095 struct window
*w
= decode_window (window
);
6099 CHECK_RANGED_INTEGER (0, width
, INT_MAX
);
6101 if (XINT (width
) == 0)
6102 vertical_type
= Qnil
;
6105 if (!(NILP (vertical_type
)
6106 || EQ (vertical_type
, Qleft
)
6107 || EQ (vertical_type
, Qright
)
6108 || EQ (vertical_type
, Qt
)))
6109 error ("Invalid type of vertical scroll bar");
6111 if (!EQ (w
->scroll_bar_width
, width
)
6112 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6114 w
->scroll_bar_width
= width
;
6115 w
->vertical_scroll_bar_type
= vertical_type
;
6117 adjust_window_margins (w
);
6119 clear_glyph_matrix (w
->current_matrix
);
6120 w
->window_end_valid
= Qnil
;
6122 ++windows_or_buffers_changed
;
6123 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6130 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6132 doc
: /* Get width and type of scroll bars of window WINDOW.
6133 If WINDOW is omitted or nil, use the currently selected window.
6134 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6135 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6137 (Lisp_Object window
)
6139 struct window
*w
= decode_window (window
);
6140 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6141 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6142 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6143 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6144 Fcons (w
->vertical_scroll_bar_type
,
6145 Fcons (Qnil
, Qnil
))));
6150 /***********************************************************************
6152 ***********************************************************************/
6154 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6155 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6156 Use the selected window if WINDOW is nil or omitted.
6157 Normally, value is a multiple of the canonical character height of WINDOW;
6158 optional second arg PIXELS-P means value is measured in pixels. */)
6159 (Lisp_Object window
, Lisp_Object pixels_p
)
6166 window
= selected_window
;
6168 CHECK_WINDOW (window
);
6169 w
= XWINDOW (window
);
6170 f
= XFRAME (w
->frame
);
6172 if (FRAME_WINDOW_P (f
))
6173 result
= (NILP (pixels_p
)
6174 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6175 : make_number (-w
->vscroll
));
6177 result
= make_number (0);
6182 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6184 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6185 WINDOW nil means use the selected window. Normally, VSCROLL is a
6186 non-negative multiple of the canonical character height of WINDOW;
6187 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6188 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6189 corresponds to an integral number of pixels. The return value is the
6190 result of this rounding.
6191 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6192 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6198 window
= selected_window
;
6200 CHECK_WINDOW (window
);
6201 CHECK_NUMBER_OR_FLOAT (vscroll
);
6203 w
= XWINDOW (window
);
6204 f
= XFRAME (w
->frame
);
6206 if (FRAME_WINDOW_P (f
))
6208 int old_dy
= w
->vscroll
;
6210 w
->vscroll
= - (NILP (pixels_p
)
6211 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6212 : XFLOATINT (vscroll
));
6213 w
->vscroll
= min (w
->vscroll
, 0);
6215 if (w
->vscroll
!= old_dy
)
6217 /* Adjust glyph matrix of the frame if the virtual display
6218 area becomes larger than before. */
6219 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6222 /* Prevent redisplay shortcuts. */
6223 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6227 return Fwindow_vscroll (window
, pixels_p
);
6231 /* Call FN for all leaf windows on frame F. FN is called with the
6232 first argument being a pointer to the leaf window, and with
6233 additional argument USER_DATA. Stops when FN returns 0. */
6236 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6239 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6240 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6241 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6245 /* Helper function for foreach_window. Call FN for all leaf windows
6246 reachable from W. FN is called with the first argument being a
6247 pointer to the leaf window, and with additional argument USER_DATA.
6248 Stop when FN returns 0. Value is 0 if stopped by FN. */
6251 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6255 for (cont
= 1; w
&& cont
;)
6257 if (!NILP (w
->hchild
))
6258 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6259 else if (!NILP (w
->vchild
))
6260 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6262 cont
= fn (w
, user_data
);
6264 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6271 /* Freeze or unfreeze the window start of W unless it is a
6272 mini-window or the selected window. FREEZE_P non-null means freeze
6273 the window start. */
6276 freeze_window_start (struct window
*w
, void *freeze_p
)
6278 if (MINI_WINDOW_P (w
)
6279 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6280 && (w
== XWINDOW (selected_window
)
6281 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6282 && ! NILP (Vminibuf_scroll_window
)
6283 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6286 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6291 /* Freeze or unfreeze the window starts of all leaf windows on frame
6292 F, except the selected window and a mini-window. FREEZE_P non-zero
6293 means freeze the window start. */
6296 freeze_window_starts (struct frame
*f
, int freeze_p
)
6298 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6302 /***********************************************************************
6304 ***********************************************************************/
6306 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6307 describe the same state of affairs. This is used by Fequal.
6309 ignore_positions non-zero means ignore non-matching scroll positions
6312 This ignores a couple of things like the dedicatedness status of
6313 window, splits, nest and the like. This might have to be fixed. */
6316 compare_window_configurations (Lisp_Object configuration1
, Lisp_Object configuration2
, int ignore_positions
)
6318 register struct save_window_data
*d1
, *d2
;
6319 struct Lisp_Vector
*sws1
, *sws2
;
6322 CHECK_WINDOW_CONFIGURATION (configuration1
);
6323 CHECK_WINDOW_CONFIGURATION (configuration2
);
6325 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6326 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6327 sws1
= XVECTOR (d1
->saved_windows
);
6328 sws2
= XVECTOR (d2
->saved_windows
);
6330 /* Frame settings must match. */
6331 if (d1
->frame_cols
!= d2
->frame_cols
6332 || d1
->frame_lines
!= d2
->frame_lines
6333 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6334 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6335 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6336 || (!ignore_positions
6337 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6338 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6339 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6340 /* Verify that the two configurations have the same number of windows. */
6341 || sws1
->header
.size
!= sws2
->header
.size
)
6344 for (i
= 0; i
< sws1
->header
.size
; i
++)
6346 struct saved_window
*sw1
, *sw2
;
6348 sw1
= SAVED_WINDOW_N (sws1
, i
);
6349 sw2
= SAVED_WINDOW_N (sws2
, i
);
6352 /* The "current" windows in the two configurations must
6353 correspond to each other. */
6354 EQ (d1
->current_window
, sw1
->window
)
6355 != EQ (d2
->current_window
, sw2
->window
)
6356 /* Windows' buffers must match. */
6357 || !EQ (sw1
->buffer
, sw2
->buffer
)
6358 || !EQ (sw1
->left_col
, sw2
->left_col
)
6359 || !EQ (sw1
->top_line
, sw2
->top_line
)
6360 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6361 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6362 || !EQ (sw1
->display_table
, sw2
->display_table
)
6363 /* The next two disjuncts check the window structure for
6365 || !EQ (sw1
->parent
, sw2
->parent
)
6366 || !EQ (sw1
->prev
, sw2
->prev
)
6367 || (!ignore_positions
6368 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6369 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6370 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6371 || NILP (Fequal (sw1
->start
, sw2
->start
))
6372 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6373 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6374 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6375 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6376 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6377 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6378 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6379 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6380 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6387 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6388 Scompare_window_configurations
, 2, 2, 0,
6389 doc
: /* Compare two window configurations as regards the structure of windows.
6390 This function ignores details such as the values of point and mark
6391 and scrolling positions. */)
6392 (Lisp_Object x
, Lisp_Object y
)
6394 if (compare_window_configurations (x
, y
, 1))
6400 init_window_once (void)
6402 struct frame
*f
= make_initial_frame ();
6403 XSETFRAME (selected_frame
, f
);
6404 Vterminal_frame
= selected_frame
;
6405 minibuf_window
= f
->minibuffer_window
;
6406 selected_window
= f
->selected_window
;
6407 last_nonminibuf_frame
= f
;
6409 window_initialized
= 1;
6415 Vwindow_list
= Qnil
;
6419 syms_of_window (void)
6421 DEFSYM (Qscroll_up
, "scroll-up");
6422 DEFSYM (Qscroll_down
, "scroll-down");
6423 DEFSYM (Qscroll_command
, "scroll-command");
6425 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6426 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6428 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6429 DEFSYM (Qwindowp
, "windowp");
6430 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6431 DEFSYM (Qwindow_live_p
, "window-live-p");
6432 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6433 DEFSYM (Qdelete_window
, "delete-window");
6434 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6435 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6436 DEFSYM (Qsafe
, "safe");
6437 DEFSYM (Qdisplay_buffer
, "display-buffer");
6438 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6439 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6440 DEFSYM (Qget_mru_window
, "get-mru-window");
6441 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6442 DEFSYM (Qabove
, "above");
6443 DEFSYM (Qbelow
, "below");
6444 DEFSYM (Qauto_buffer_name
, "auto-buffer-name");
6446 staticpro (&Vwindow_list
);
6448 minibuf_selected_window
= Qnil
;
6449 staticpro (&minibuf_selected_window
);
6451 window_scroll_pixel_based_preserve_x
= -1;
6452 window_scroll_pixel_based_preserve_y
= -1;
6453 window_scroll_preserve_hpos
= -1;
6454 window_scroll_preserve_vpos
= -1;
6456 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6457 doc
: /* Non-nil means call as function to display a help buffer.
6458 The function is called with one argument, the buffer to be displayed.
6459 Used by `with-output-to-temp-buffer'.
6460 If this function is used, then it must do the entire job of showing
6461 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6462 Vtemp_buffer_show_function
= Qnil
;
6464 DEFVAR_LISP ("temp-buffer-show-specifiers", Vtemp_buffer_show_specifiers
,
6465 doc
: /* Buffer display specifiers used by `with-output-to-temp-buffer'.
6466 These specifiers are passed by `with-output-to-temp-buffer' as second
6467 argument to `display-buffer'. Applications should only let-bind this
6468 around a call to `with-output-to-temp-buffer'.
6470 For a description of buffer display specifiers see the variable
6471 `display-buffer-alist'. */);
6472 Vtemp_buffer_show_specifiers
= Qnil
;
6474 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6475 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6476 Vminibuf_scroll_window
= Qnil
;
6478 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6479 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6480 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6481 is displayed in the `mode-line' face. */);
6482 mode_line_in_non_selected_windows
= 1;
6484 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6485 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6486 Vother_window_scroll_buffer
= Qnil
;
6488 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6489 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6490 auto_window_vscroll_p
= 1;
6492 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6493 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6494 next_screen_context_lines
= 2;
6496 DEFVAR_LISP ("scroll-preserve-screen-position",
6497 Vscroll_preserve_screen_position
,
6498 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6499 A value of nil means point does not keep its screen position except
6500 at the scroll margin or window boundary respectively.
6501 A value of t means point keeps its screen position if the scroll
6502 command moved it vertically out of the window, e.g. when scrolling
6504 Any other value means point always keeps its screen position.
6505 Scroll commands should have the `scroll-command' property
6506 on their symbols to be controlled by this variable. */);
6507 Vscroll_preserve_screen_position
= Qnil
;
6509 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6510 doc
: /* Type of marker to use for `window-point'. */);
6511 Vwindow_point_insertion_type
= Qnil
;
6513 DEFVAR_LISP ("window-configuration-change-hook",
6514 Vwindow_configuration_change_hook
,
6515 doc
: /* Functions to call when window configuration changes.
6516 The buffer-local part is run once per window, with the relevant window
6517 selected; while the global part is run only once for the modified frame,
6518 with the relevant frame selected. */);
6519 Vwindow_configuration_change_hook
= Qnil
;
6521 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6522 doc
: /* If non-nil, then the `recenter' command with a nil argument
6523 will redraw the entire frame; the special value `tty' causes the
6524 frame to be redrawn only if it is a tty frame. */);
6525 Vrecenter_redisplay
= Qtty
;
6527 DEFVAR_LISP ("window-splits", Vwindow_splits
,
6528 doc
: /* Non-nil means splitting windows is handled specially.
6529 If this variable is nil, splitting a window gets the entire screen space
6530 for displaying the new window from the window to split. If this
6531 variable is non-nil, splitting a window may resize all windows in the
6532 same combination. This also allows to split a window that is otherwise
6533 too small or of fixed size.
6535 The value of this variable is also assigned to the split status of the
6536 new window and, provided the old and new window form a new combination,
6537 to the window that was split as well. The split status of a window can
6538 be retrieved with the function `window-splits' and altered by the
6539 function `set-window-splits'.
6541 If the value of the variable `window-nest' is non-nil, the space for the
6542 new window is exclusively taken from the window that shall be split, but
6543 the split status of the window that is split as well as that of the new
6544 window are still set to the value of this variable. */);
6545 Vwindow_splits
= Qnil
;
6547 DEFVAR_LISP ("window-nest", Vwindow_nest
,
6548 doc
: /* Non-nil means splitting a window makes a new parent window.
6549 If this variable is nil, splitting a window will create a new parent
6550 window only if the window has no parent window or the window shall
6551 become a combination orthogonal to the one it it is part of.
6553 If this variable is non-nil, splitting a window always creates a new
6554 parent window. If all splits behave this way, each frame's window tree
6555 is a binary tree and every window but the frame's root window has
6556 exactly one sibling.
6558 The value of this variable is also assigned to the nest status of the
6559 new parent window. The nest status of a window can be retrieved via the
6560 function `window-nest' and altered by the function `set-window-nest'. */);
6561 Vwindow_nest
= Qnil
;
6563 defsubr (&Sselected_window
);
6564 defsubr (&Sminibuffer_window
);
6565 defsubr (&Swindow_minibuffer_p
);
6566 defsubr (&Swindowp
);
6567 defsubr (&Swindow_live_p
);
6568 defsubr (&Swindow_frame
);
6569 defsubr (&Sframe_root_window
);
6570 defsubr (&Sframe_first_window
);
6571 defsubr (&Sframe_selected_window
);
6572 defsubr (&Sset_frame_selected_window
);
6573 defsubr (&Spos_visible_in_window_p
);
6574 defsubr (&Swindow_line_height
);
6575 defsubr (&Swindow_buffer
);
6576 defsubr (&Swindow_parent
);
6577 defsubr (&Swindow_top_child
);
6578 defsubr (&Swindow_left_child
);
6579 defsubr (&Swindow_next_sibling
);
6580 defsubr (&Swindow_prev_sibling
);
6581 defsubr (&Swindow_splits
);
6582 defsubr (&Sset_window_splits
);
6583 defsubr (&Swindow_nest
);
6584 defsubr (&Sset_window_nest
);
6585 defsubr (&Swindow_use_time
);
6586 defsubr (&Swindow_top_line
);
6587 defsubr (&Swindow_left_column
);
6588 defsubr (&Swindow_total_size
);
6589 defsubr (&Swindow_normal_size
);
6590 defsubr (&Swindow_new_total
);
6591 defsubr (&Swindow_new_normal
);
6592 defsubr (&Sset_window_new_total
);
6593 defsubr (&Sset_window_new_normal
);
6594 defsubr (&Swindow_resize_apply
);
6595 defsubr (&Swindow_body_size
);
6596 defsubr (&Swindow_hscroll
);
6597 defsubr (&Sset_window_hscroll
);
6598 defsubr (&Swindow_redisplay_end_trigger
);
6599 defsubr (&Sset_window_redisplay_end_trigger
);
6600 defsubr (&Swindow_edges
);
6601 defsubr (&Swindow_pixel_edges
);
6602 defsubr (&Swindow_absolute_pixel_edges
);
6603 defsubr (&Swindow_inside_edges
);
6604 defsubr (&Swindow_inside_pixel_edges
);
6605 defsubr (&Swindow_inside_absolute_pixel_edges
);
6606 defsubr (&Scoordinates_in_window_p
);
6607 defsubr (&Swindow_at
);
6608 defsubr (&Swindow_point
);
6609 defsubr (&Swindow_start
);
6610 defsubr (&Swindow_end
);
6611 defsubr (&Sset_window_point
);
6612 defsubr (&Sset_window_start
);
6613 defsubr (&Swindow_dedicated_p
);
6614 defsubr (&Sset_window_dedicated_p
);
6615 defsubr (&Swindow_display_table
);
6616 defsubr (&Sset_window_display_table
);
6617 defsubr (&Snext_window
);
6618 defsubr (&Sprevious_window
);
6619 defsubr (&Sget_buffer_window
);
6620 defsubr (&Sdelete_other_windows_internal
);
6621 defsubr (&Sdelete_window_internal
);
6622 defsubr (&Sresize_mini_window_internal
);
6623 defsubr (&Sset_window_buffer
);
6624 defsubr (&Srun_window_configuration_change_hook
);
6625 defsubr (&Sselect_window
);
6626 defsubr (&Sforce_window_update
);
6627 defsubr (&Stemp_output_buffer_show
);
6628 defsubr (&Ssplit_window_internal
);
6629 defsubr (&Sscroll_up
);
6630 defsubr (&Sscroll_down
);
6631 defsubr (&Sscroll_left
);
6632 defsubr (&Sscroll_right
);
6633 defsubr (&Sother_window_for_scrolling
);
6634 defsubr (&Sscroll_other_window
);
6635 defsubr (&Sminibuffer_selected_window
);
6636 defsubr (&Srecenter
);
6637 defsubr (&Swindow_text_height
);
6638 defsubr (&Smove_to_window_line
);
6639 defsubr (&Swindow_configuration_p
);
6640 defsubr (&Swindow_configuration_frame
);
6641 defsubr (&Sset_window_configuration
);
6642 defsubr (&Scurrent_window_configuration
);
6643 defsubr (&Sset_window_margins
);
6644 defsubr (&Swindow_margins
);
6645 defsubr (&Sset_window_fringes
);
6646 defsubr (&Swindow_fringes
);
6647 defsubr (&Sset_window_scroll_bars
);
6648 defsubr (&Swindow_scroll_bars
);
6649 defsubr (&Swindow_vscroll
);
6650 defsubr (&Sset_window_vscroll
);
6651 defsubr (&Scompare_window_configurations
);
6652 defsubr (&Swindow_list
);
6653 defsubr (&Swindow_list_1
);
6654 defsubr (&Swindow_prev_buffers
);
6655 defsubr (&Sset_window_prev_buffers
);
6656 defsubr (&Swindow_next_buffers
);
6657 defsubr (&Sset_window_next_buffers
);
6658 defsubr (&Swindow_parameters
);
6659 defsubr (&Swindow_parameter
);
6660 defsubr (&Sset_window_parameter
);
6664 keys_of_window (void)
6666 initial_define_key (control_x_map
, '<', "scroll-left");
6667 initial_define_key (control_x_map
, '>', "scroll-right");
6669 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6670 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6671 initial_define_key (meta_map
, 'v', "scroll-down-command");