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
));
923 enum window_part part
;
924 int ux
= FRAME_COLUMN_WIDTH (f
);
925 int x0
= WINDOW_LEFT_EDGE_X (w
);
926 int x1
= WINDOW_RIGHT_EDGE_X (w
);
927 /* The width of the area where the vertical line can be dragged.
928 (Between mode lines for instance. */
929 int grabbable_width
= ux
;
930 int lmargin_width
, rmargin_width
, text_left
, text_right
;
931 int top_y
= WINDOW_TOP_EDGE_Y (w
);
932 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
934 /* Outside any interesting row? */
935 if (y
< top_y
|| y
>= bottom_y
)
938 /* In what's below, we subtract 1 when computing right_x because we
939 want the rightmost pixel, which is given by left_pixel+width-1. */
940 if (w
->pseudo_window_p
)
943 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
947 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
948 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
951 /* On the mode line or header line? If it's near the start of
952 the mode or header line of window that's has a horizontal
953 sibling, say it's on the vertical line. That's to be able
954 to resize windows horizontally in case we're using toolkit
957 if (WINDOW_WANTS_MODELINE_P (w
)
958 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
962 header_vertical_border_check
:
963 /* We're somewhere on the mode line. We consider the place
964 between mode lines of horizontally adjacent mode lines
965 as the vertical border. If scroll bars on the left,
966 return the right window. */
967 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
968 || WINDOW_RIGHTMOST_P (w
))
969 && !WINDOW_LEFTMOST_P (w
)
970 && eabs (x
- x0
) < grabbable_width
)
971 return ON_VERTICAL_BORDER
;
973 /* Make sure we're not at the rightmost position of a
974 mode-/header-line and there's yet another window on the
976 else if ((WINDOW_RIGHTMOST_P (w
) || x
< x1
)
977 && eabs (x
- x1
) < grabbable_width
)
978 return ON_VERTICAL_BORDER
;
980 if (x
< x0
|| x
>= x1
)
986 if (WINDOW_WANTS_HEADER_LINE_P (w
)
987 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
989 part
= ON_HEADER_LINE
;
990 goto header_vertical_border_check
;
993 if (x
< x0
|| x
>= x1
) return ON_NOTHING
;
995 /* Outside any interesting column? */
996 if (x
< left_x
|| x
> right_x
)
997 return ON_SCROLL_BAR
;
999 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1000 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1002 text_left
= window_box_left (w
, TEXT_AREA
);
1003 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1005 if (FRAME_WINDOW_P (f
))
1007 if (!w
->pseudo_window_p
1008 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1009 && !WINDOW_RIGHTMOST_P (w
)
1010 && (eabs (x
- right_x
) < grabbable_width
))
1011 return ON_VERTICAL_BORDER
;
1013 /* Need to say "x > right_x" rather than >=, since on character
1014 terminals, the vertical line's x coordinate is right_x. */
1015 else if (!w
->pseudo_window_p
1016 && !WINDOW_RIGHTMOST_P (w
)
1017 && x
> right_x
- ux
)
1018 return ON_VERTICAL_BORDER
;
1022 if (lmargin_width
> 0
1023 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1024 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1025 : (x
< left_x
+ lmargin_width
)))
1026 return ON_LEFT_MARGIN
;
1028 return ON_LEFT_FRINGE
;
1031 if (x
>= text_right
)
1033 if (rmargin_width
> 0
1034 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1035 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1036 : (x
>= right_x
- rmargin_width
)))
1037 return ON_RIGHT_MARGIN
;
1039 return ON_RIGHT_FRINGE
;
1042 /* Everything special ruled out - must be on text area */
1046 /* Take X is the frame-relative pixel x-coordinate, and return the
1047 x-coordinate relative to part PART of window W. */
1049 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1051 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1056 return x
- window_box_left (w
, TEXT_AREA
);
1058 case ON_LEFT_FRINGE
:
1061 case ON_RIGHT_FRINGE
:
1062 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1064 case ON_LEFT_MARGIN
:
1066 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1067 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1069 case ON_RIGHT_MARGIN
:
1071 - ((w
->pseudo_window_p
)
1072 ? WINDOW_TOTAL_WIDTH (w
)
1073 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1074 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1075 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1076 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1079 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1084 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1085 Scoordinates_in_window_p
, 2, 2, 0,
1086 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1087 COORDINATES is a cons of the form (X . Y), X and Y being distances
1088 measured in characters from the upper-left corner of the frame.
1089 \(0 . 0) denotes the character in the upper left corner of the
1091 If COORDINATES are in the text portion of WINDOW,
1092 the coordinates relative to the window are returned.
1093 If they are in the mode line of WINDOW, `mode-line' is returned.
1094 If they are in the top mode line of WINDOW, `header-line' is returned.
1095 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1096 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1097 If they are on the border between WINDOW and its right sibling,
1098 `vertical-line' is returned.
1099 If they are in the windows's left or right marginal areas, `left-margin'\n\
1100 or `right-margin' is returned. */)
1101 (register Lisp_Object coordinates
, Lisp_Object window
)
1108 CHECK_WINDOW (window
);
1109 w
= XWINDOW (window
);
1110 f
= XFRAME (w
->frame
);
1111 CHECK_CONS (coordinates
);
1112 lx
= Fcar (coordinates
);
1113 ly
= Fcdr (coordinates
);
1114 CHECK_NUMBER_OR_FLOAT (lx
);
1115 CHECK_NUMBER_OR_FLOAT (ly
);
1116 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1117 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1119 switch (coordinates_in_window (w
, x
, y
))
1125 /* Convert X and Y to window relative pixel coordinates, and
1126 return the canonical char units. */
1127 x
-= window_box_left (w
, TEXT_AREA
);
1128 y
-= WINDOW_TOP_EDGE_Y (w
);
1129 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1130 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1135 case ON_VERTICAL_BORDER
:
1136 return Qvertical_line
;
1138 case ON_HEADER_LINE
:
1139 return Qheader_line
;
1141 case ON_LEFT_FRINGE
:
1142 return Qleft_fringe
;
1144 case ON_RIGHT_FRINGE
:
1145 return Qright_fringe
;
1147 case ON_LEFT_MARGIN
:
1148 return Qleft_margin
;
1150 case ON_RIGHT_MARGIN
:
1151 return Qright_margin
;
1154 /* Historically we are supposed to return nil in this case. */
1163 /* Callback for foreach_window, used in window_from_coordinates.
1164 Check if window W contains coordinates specified by USER_DATA which
1165 is actually a pointer to a struct check_window_data CW.
1167 Check if window W contains coordinates *CW->x and *CW->y. If it
1168 does, return W in *CW->window, as Lisp_Object, and return in
1169 *CW->part the part of the window under coordinates *X,*Y. Return
1170 zero from this function to stop iterating over windows. */
1172 struct check_window_data
1174 Lisp_Object
*window
;
1176 enum window_part
*part
;
1180 check_window_containing (struct window
*w
, void *user_data
)
1182 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1183 enum window_part found
;
1186 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1187 if (found
!= ON_NOTHING
)
1190 XSETWINDOW (*cw
->window
, w
);
1198 /* Find the window containing frame-relative pixel position X/Y and
1199 return it as a Lisp_Object.
1201 If X, Y is on one of the window's special `window_part' elements,
1202 set *PART to the id of that element.
1204 If there is no window under X, Y return nil and leave *PART
1205 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1207 This function was previously implemented with a loop cycling over
1208 windows with Fnext_window, and starting with the frame's selected
1209 window. It turned out that this doesn't work with an
1210 implementation of next_window using Vwindow_list, because
1211 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1212 tree of F when this function is called asynchronously from
1213 note_mouse_highlight. The original loop didn't terminate in this
1217 window_from_coordinates (struct frame
*f
, int x
, int y
,
1218 enum window_part
*part
, int tool_bar_p
)
1221 struct check_window_data cw
;
1222 enum window_part dummy
;
1228 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1229 foreach_window (f
, check_window_containing
, &cw
);
1231 /* If not found above, see if it's in the tool bar window, if a tool
1235 && WINDOWP (f
->tool_bar_window
)
1236 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1237 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1241 window
= f
->tool_bar_window
;
1247 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1248 doc
: /* Return window containing coordinates X and Y on FRAME.
1249 FRAME must be a live frame and defaults to the selected one.
1250 The top left corner of the frame is considered to be row 0,
1252 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1257 frame
= selected_frame
;
1258 CHECK_LIVE_FRAME (frame
);
1261 /* Check that arguments are integers or floats. */
1262 CHECK_NUMBER_OR_FLOAT (x
);
1263 CHECK_NUMBER_OR_FLOAT (y
);
1265 return window_from_coordinates (f
,
1266 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1267 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1268 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1269 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1273 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1274 doc
: /* Return current value of point in WINDOW.
1275 WINDOW must be a live window and defaults to the selected one.
1277 For a nonselected window, this is the value point would have
1278 if that window were selected.
1280 Note that, when WINDOW is the selected window and its buffer
1281 is also currently selected, the value returned is the same as (point).
1282 It would be more strictly correct to return the `top-level' value
1283 of point, outside of any save-excursion forms.
1284 But that is hard to define. */)
1285 (Lisp_Object window
)
1287 register struct window
*w
= decode_window (window
);
1289 if (w
== XWINDOW (selected_window
)
1290 && current_buffer
== XBUFFER (w
->buffer
))
1292 return Fmarker_position (w
->pointm
);
1295 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1296 doc
: /* Return position at which display currently starts in WINDOW.
1297 WINDOW must be a live window and defaults to the selected one.
1298 This is updated by redisplay or by calling `set-window-start'. */)
1299 (Lisp_Object window
)
1301 return Fmarker_position (decode_window (window
)->start
);
1304 /* This is text temporarily removed from the doc string below.
1306 This function returns nil if the position is not currently known.
1307 That happens when redisplay is preempted and doesn't finish.
1308 If in that case you want to compute where the end of the window would
1309 have been if redisplay had finished, do this:
1311 (goto-char (window-start window))
1312 (vertical-motion (1- (window-height window)) window)
1315 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1316 doc
: /* Return position at which display currently ends in WINDOW.
1317 WINDOW must be a live window and defaults to the selected one.
1318 This is updated by redisplay, when it runs to completion.
1319 Simply changing the buffer text or setting `window-start'
1320 does not update this value.
1321 Return nil if there is no recorded value. \(This can happen if the
1322 last redisplay of WINDOW was preempted, and did not finish.)
1323 If UPDATE is non-nil, compute the up-to-date position
1324 if it isn't already recorded. */)
1325 (Lisp_Object window
, Lisp_Object update
)
1328 struct window
*w
= decode_window (window
);
1336 #if 0 /* This change broke some things. We should make it later. */
1337 /* If we don't know the end position, return nil.
1338 The user can compute it with vertical-motion if he wants to.
1339 It would be nicer to do it automatically,
1340 but that's so slow that it would probably bother people. */
1341 if (NILP (w
->window_end_valid
))
1346 && ! (! NILP (w
->window_end_valid
)
1347 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1348 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1351 struct text_pos startp
;
1353 struct buffer
*old_buffer
= NULL
;
1354 void *itdata
= NULL
;
1356 /* Cannot use Fvertical_motion because that function doesn't
1357 cope with variable-height lines. */
1358 if (b
!= current_buffer
)
1360 old_buffer
= current_buffer
;
1361 set_buffer_internal (b
);
1364 /* In case W->start is out of the range, use something
1365 reasonable. This situation occurred when loading a file with
1366 `-l' containing a call to `rmail' with subsequent other
1367 commands. At the end, W->start happened to be BEG, while
1368 rmail had already narrowed the buffer. */
1369 if (XMARKER (w
->start
)->charpos
< BEGV
)
1370 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1371 else if (XMARKER (w
->start
)->charpos
> ZV
)
1372 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1374 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1376 itdata
= bidi_shelve_cache ();
1377 start_display (&it
, w
, startp
);
1378 move_it_vertically (&it
, window_box_height (w
));
1379 if (it
.current_y
< it
.last_visible_y
)
1380 move_it_past_eol (&it
);
1381 value
= make_number (IT_CHARPOS (it
));
1382 bidi_unshelve_cache (itdata
, 0);
1385 set_buffer_internal (old_buffer
);
1388 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1393 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1394 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1396 (Lisp_Object window
, Lisp_Object pos
)
1398 register struct window
*w
= decode_window (window
);
1400 CHECK_NUMBER_COERCE_MARKER (pos
);
1401 if (w
== XWINDOW (selected_window
)
1402 && XBUFFER (w
->buffer
) == current_buffer
)
1405 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1407 /* We have to make sure that redisplay updates the window to show
1408 the new value of point. */
1409 if (!EQ (window
, selected_window
))
1410 ++windows_or_buffers_changed
;
1415 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1416 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1417 If WINDOW is nil, the selected window is used. Return POS.
1418 Optional third arg NOFORCE non-nil inhibits next redisplay from
1419 overriding motion of point in order to display at this exact start. */)
1420 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1422 register struct window
*w
= decode_window (window
);
1424 CHECK_NUMBER_COERCE_MARKER (pos
);
1425 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1426 /* this is not right, but much easier than doing what is right. */
1427 w
->start_at_line_beg
= Qnil
;
1429 w
->force_start
= Qt
;
1430 w
->update_mode_line
= Qt
;
1431 XSETFASTINT (w
->last_modified
, 0);
1432 XSETFASTINT (w
->last_overlay_modified
, 0);
1433 if (!EQ (window
, selected_window
))
1434 windows_or_buffers_changed
++;
1439 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1440 Spos_visible_in_window_p
, 0, 3, 0,
1441 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1442 Return nil if that position is scrolled vertically out of view.
1443 If a character is only partially visible, nil is returned, unless the
1444 optional argument PARTIALLY is non-nil.
1445 If POS is only out of view because of horizontal scrolling, return non-nil.
1446 If POS is t, it specifies the position of the last visible glyph in WINDOW.
1447 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
1449 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1450 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1451 where X and Y are the pixel coordinates relative to the top left corner
1452 of the window. The remaining elements are omitted if the character after
1453 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1454 off-window at the top and bottom of the row, ROWH is the height of the
1455 display row, and VPOS is the row number (0-based) containing POS. */)
1456 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1458 register struct window
*w
;
1459 register EMACS_INT posint
;
1460 register struct buffer
*buf
;
1461 struct text_pos top
;
1462 Lisp_Object in_window
= Qnil
;
1463 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1466 w
= decode_window (window
);
1467 buf
= XBUFFER (w
->buffer
);
1468 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1472 else if (!NILP (pos
))
1474 CHECK_NUMBER_COERCE_MARKER (pos
);
1475 posint
= XINT (pos
);
1477 else if (w
== XWINDOW (selected_window
))
1480 posint
= XMARKER (w
->pointm
)->charpos
;
1482 /* If position is above window start or outside buffer boundaries,
1483 or if window start is out of range, position is not visible. */
1485 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1486 && CHARPOS (top
) >= BUF_BEGV (buf
)
1487 && CHARPOS (top
) <= BUF_ZV (buf
)
1488 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1489 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1492 if (!NILP (in_window
) && !NILP (partially
))
1494 Lisp_Object part
= Qnil
;
1496 part
= list4 (make_number (rtop
), make_number (rbot
),
1497 make_number (rowh
), make_number (vpos
));
1498 in_window
= Fcons (make_number (x
),
1499 Fcons (make_number (y
), part
));
1505 DEFUN ("window-line-height", Fwindow_line_height
,
1506 Swindow_line_height
, 0, 2, 0,
1507 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1508 WINDOW defaults to the selected window.
1510 Return height of current line if LINE is omitted or nil. Return height of
1511 header or mode line if LINE is `header-line' or `mode-line'.
1512 Otherwise, LINE is a text line number starting from 0. A negative number
1513 counts from the end of the window.
1515 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1516 in pixels of the visible part of the line, VPOS and YPOS are the
1517 vertical position in lines and pixels of the line, relative to the top
1518 of the first text line, and OFFBOT is the number of off-window pixels at
1519 the bottom of the text line. If there are off-window pixels at the top
1520 of the (first) text line, YPOS is negative.
1522 Return nil if window display is not up-to-date. In that case, use
1523 `pos-visible-in-window-p' to obtain the information. */)
1524 (Lisp_Object line
, Lisp_Object window
)
1526 register struct window
*w
;
1527 register struct buffer
*b
;
1528 struct glyph_row
*row
, *end_row
;
1532 w
= decode_window (window
);
1534 if (noninteractive
|| w
->pseudo_window_p
)
1537 CHECK_BUFFER (w
->buffer
);
1538 b
= XBUFFER (w
->buffer
);
1540 /* Fail if current matrix is not up-to-date. */
1541 if (NILP (w
->window_end_valid
)
1542 || current_buffer
->clip_changed
1543 || current_buffer
->prevent_redisplay_optimizations_p
1544 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
1545 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
1551 if (i
< 0 || i
>= w
->current_matrix
->nrows
1552 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1554 max_y
= window_text_bottom_y (w
);
1558 if (EQ (line
, Qheader_line
))
1560 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1562 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1563 if (!row
->enabled_p
)
1565 return list4 (make_number (row
->height
),
1566 make_number (0), make_number (0),
1570 if (EQ (line
, Qmode_line
))
1572 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1573 if (!row
->enabled_p
)
1575 return list4 (make_number (row
->height
),
1576 make_number (0), /* not accurate */
1577 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
1578 + window_text_bottom_y (w
)),
1582 CHECK_NUMBER (line
);
1585 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1586 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1587 max_y
= window_text_bottom_y (w
);
1590 while ((n
< 0 || i
< n
)
1591 && row
<= end_row
&& row
->enabled_p
1592 && row
->y
+ row
->height
< max_y
)
1595 if (row
> end_row
|| !row
->enabled_p
)
1607 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1608 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
1610 make_number (row
->y
),
1611 make_number (crop
));
1614 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1616 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1617 More precisely, return the value assigned by the last call of
1618 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1619 never called with WINDOW as its argument, or the value set by that
1620 function was internally reset since its last call. WINDOW defaults to
1621 the selected window.
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' and
1627 `kill-buffer' can delete a dedicated window and the containing frame.
1629 Functions like `set-window-buffer' may change the buffer displayed by a
1630 window, unless that window is "strongly" dedicated to its buffer, that
1631 is the value returned by `window-dedicated-p' is t. */)
1632 (Lisp_Object window
)
1634 return decode_window (window
)->dedicated
;
1637 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1638 Sset_window_dedicated_p
, 2, 2, 0,
1639 doc
: /* Mark WINDOW as dedicated according to FLAG.
1640 WINDOW must be a live window and defaults to the selected one. FLAG
1641 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1642 mark WINDOW as non-dedicated. Return FLAG.
1644 When a window is dedicated to its buffer, `display-buffer' will refrain
1645 from displaying another buffer in it. `get-lru-window' and
1646 `get-largest-window' treat dedicated windows specially.
1647 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1648 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1649 and the containing frame.
1651 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1652 its buffer. Functions like `set-window-buffer' may change the buffer
1653 displayed by a window, unless that window is strongly dedicated to its
1654 buffer. If and when `set-window-buffer' displays another buffer in a
1655 window, it also makes sure that the window is no more dedicated. */)
1656 (Lisp_Object window
, Lisp_Object flag
)
1658 register struct window
*w
= decode_window (window
);
1660 w
->dedicated
= flag
;
1661 return w
->dedicated
;
1664 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1666 doc
: /* Return buffers previously shown in WINDOW.
1667 WINDOW must be a live window and defaults to the selected one.
1669 The return value is a list of elements (BUFFER WINDOW-START POS),
1670 where BUFFER is a buffer, WINDOW-START is the start position of the
1671 window for that buffer, and POS is a window-specific point value. */)
1672 (Lisp_Object window
)
1674 return decode_window (window
)->prev_buffers
;
1677 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1678 Sset_window_prev_buffers
, 2, 2, 0,
1679 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1680 WINDOW must be a live window and defaults to the selected one.
1682 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1683 where BUFFER is a buffer, WINDOW-START is the start position of the
1684 window for that buffer, and POS is a window-specific point value. */)
1685 (Lisp_Object window
, Lisp_Object prev_buffers
)
1687 return decode_window (window
)->prev_buffers
= prev_buffers
;
1690 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1692 doc
: /* Return list of buffers recently re-shown in WINDOW.
1693 WINDOW must be a live window and defaults to the selected one. */)
1694 (Lisp_Object window
)
1696 return decode_window (window
)->next_buffers
;
1699 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1700 Sset_window_next_buffers
, 2, 2, 0,
1701 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1702 WINDOW must be a live window and defaults to the selected one.
1703 NEXT-BUFFERS should be a list of buffers. */)
1704 (Lisp_Object window
, Lisp_Object next_buffers
)
1706 return decode_window (window
)->next_buffers
= next_buffers
;
1709 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1711 doc
: /* Return the parameters of WINDOW and their values.
1712 WINDOW defaults to the selected window. The return value is a list of
1713 elements of the form (PARAMETER . VALUE). */)
1714 (Lisp_Object window
)
1716 return Fcopy_alist (decode_any_window (window
)->window_parameters
);
1719 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1721 doc
: /* Return WINDOW's value for PARAMETER.
1722 WINDOW defaults to the selected window. */)
1723 (Lisp_Object window
, Lisp_Object parameter
)
1727 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1728 return CDR_SAFE (result
);
1731 DEFUN ("set-window-parameter", Fset_window_parameter
,
1732 Sset_window_parameter
, 3, 3, 0,
1733 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1734 WINDOW defaults to the selected window. Return VALUE. */)
1735 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1737 register struct window
*w
= decode_any_window (window
);
1738 Lisp_Object old_alist_elt
;
1740 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1741 if (NILP (old_alist_elt
))
1742 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1744 Fsetcdr (old_alist_elt
, value
);
1748 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1750 doc
: /* Return the display-table that WINDOW is using.
1751 WINDOW defaults to the selected window. */)
1752 (Lisp_Object window
)
1754 return decode_window (window
)->display_table
;
1757 /* Get the display table for use on window W. This is either W's
1758 display table or W's buffer's display table. Ignore the specified
1759 tables if they are not valid; if no valid table is specified,
1762 struct Lisp_Char_Table
*
1763 window_display_table (struct window
*w
)
1765 struct Lisp_Char_Table
*dp
= NULL
;
1767 if (DISP_TABLE_P (w
->display_table
))
1768 dp
= XCHAR_TABLE (w
->display_table
);
1769 else if (BUFFERP (w
->buffer
))
1771 struct buffer
*b
= XBUFFER (w
->buffer
);
1773 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1774 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1775 else if (DISP_TABLE_P (Vstandard_display_table
))
1776 dp
= XCHAR_TABLE (Vstandard_display_table
);
1782 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1783 doc
: /* Set WINDOW's display-table to TABLE. */)
1784 (register Lisp_Object window
, Lisp_Object table
)
1786 register struct window
*w
;
1788 w
= decode_window (window
);
1789 w
->display_table
= table
;
1793 /* Record info on buffer window W is displaying
1794 when it is about to cease to display that buffer. */
1796 unshow_buffer (register struct window
*w
)
1803 if (b
!= XMARKER (w
->pointm
)->buffer
)
1807 if (w
== XWINDOW (selected_window
)
1808 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1809 /* Do this except when the selected window's buffer
1810 is being removed from some other window. */
1812 /* last_window_start records the start position that this buffer
1813 had in the last window to be disconnected from it.
1814 Now that this statement is unconditional,
1815 it is possible for the buffer to be displayed in the
1816 selected window, while last_window_start reflects another
1817 window which was recently showing the same buffer.
1818 Some people might say that might be a good thing. Let's see. */
1819 b
->last_window_start
= marker_position (w
->start
);
1821 /* Point in the selected window's buffer
1822 is actually stored in that buffer, and the window's pointm isn't used.
1823 So don't clobber point in that buffer. */
1824 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1825 /* This line helps to fix Horsley's testbug.el bug. */
1826 && !(WINDOWP (BVAR (b
, last_selected_window
))
1827 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1828 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1829 temp_set_point_both (b
,
1830 clip_to_bounds (BUF_BEGV (b
),
1831 XMARKER (w
->pointm
)->charpos
,
1833 clip_to_bounds (BUF_BEGV_BYTE (b
),
1834 marker_byte_position (w
->pointm
),
1837 if (WINDOWP (BVAR (b
, last_selected_window
))
1838 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1839 BVAR (b
, last_selected_window
) = Qnil
;
1842 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1843 means change window structure only. Otherwise store geometry and
1844 other settings as well. */
1846 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1848 register Lisp_Object tem
;
1849 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1851 /* If OLD is its frame's root window, then NEW is the new
1852 root window for that frame. */
1853 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1854 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = new;
1858 n
->left_col
= o
->left_col
;
1859 n
->top_line
= o
->top_line
;
1860 n
->total_cols
= o
->total_cols
;
1861 n
->total_lines
= o
->total_lines
;
1862 n
->normal_cols
= o
->normal_cols
;
1863 o
->normal_cols
= make_float (1.0);
1864 n
->normal_lines
= o
->normal_lines
;
1865 o
->normal_lines
= make_float (1.0);
1866 n
->desired_matrix
= n
->current_matrix
= 0;
1868 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1869 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1870 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1871 n
->phys_cursor_type
= -1;
1872 n
->phys_cursor_width
= -1;
1873 n
->must_be_updated_p
= 0;
1874 n
->pseudo_window_p
= 0;
1875 XSETFASTINT (n
->window_end_vpos
, 0);
1876 XSETFASTINT (n
->window_end_pos
, 0);
1877 n
->window_end_valid
= Qnil
;
1878 n
->frozen_window_start_p
= 0;
1881 n
->next
= tem
= o
->next
;
1883 XWINDOW (tem
)->prev
= new;
1885 n
->prev
= tem
= o
->prev
;
1887 XWINDOW (tem
)->next
= new;
1889 n
->parent
= tem
= o
->parent
;
1892 if (EQ (XWINDOW (tem
)->vchild
, old
))
1893 XWINDOW (tem
)->vchild
= new;
1894 if (EQ (XWINDOW (tem
)->hchild
, old
))
1895 XWINDOW (tem
)->hchild
= new;
1899 /* If window WINDOW and its parent window are iso-combined, merge
1900 WINDOW's children into those of its parent window and mark WINDOW as
1904 recombine_windows (Lisp_Object window
)
1906 struct window
*w
, *p
, *c
;
1907 Lisp_Object parent
, child
;
1910 w
= XWINDOW (window
);
1912 if (!NILP (parent
) && NILP (w
->nest
))
1914 p
= XWINDOW (parent
);
1915 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
1916 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
1917 /* WINDOW and PARENT are both either a vertical or a horizontal
1920 horflag
= NILP (w
->vchild
);
1921 child
= horflag
? w
->hchild
: w
->vchild
;
1922 c
= XWINDOW (child
);
1924 /* Splice WINDOW's children into its parent's children and
1925 assign new normal sizes. */
1934 XWINDOW (w
->prev
)->next
= child
;
1943 = make_float (XFLOATINT (c
->total_cols
)
1944 / XFLOATINT (p
->total_cols
));
1947 = make_float (XFLOATINT (c
->total_lines
)
1948 / XFLOATINT (p
->total_lines
));
1952 if (!NILP (w
->next
))
1955 XWINDOW (c
->next
)->prev
= child
;
1963 c
= XWINDOW (child
);
1967 /* WINDOW can be deleted now. */
1968 w
->vchild
= w
->hchild
= Qnil
;
1973 /* If WINDOW can be deleted, delete it. */
1975 delete_deletable_window (Lisp_Object window
)
1977 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
1978 call1 (Qdelete_window
, window
);
1981 /***********************************************************************
1983 ***********************************************************************/
1985 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1986 pointer. This is a callback function for foreach_window, used in
1987 the window_list function. */
1990 add_window_to_list (struct window
*w
, void *user_data
)
1992 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1994 XSETWINDOW (window
, w
);
1995 *list
= Fcons (window
, *list
);
2000 /* Return a list of all windows, for use by next_window. If
2001 Vwindow_list is a list, return that list. Otherwise, build a new
2002 list, cache it in Vwindow_list, and return that. */
2007 if (!CONSP (Vwindow_list
))
2011 Vwindow_list
= Qnil
;
2012 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
2014 Lisp_Object args
[2];
2016 /* We are visiting windows in canonical order, and add
2017 new windows at the front of args[1], which means we
2018 have to reverse this list at the end. */
2020 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
2021 args
[0] = Vwindow_list
;
2022 args
[1] = Fnreverse (args
[1]);
2023 Vwindow_list
= Fnconc (2, args
);
2027 return Vwindow_list
;
2031 /* Value is non-zero if WINDOW satisfies the constraints given by
2032 OWINDOW, MINIBUF and ALL_FRAMES.
2034 MINIBUF t means WINDOW may be minibuffer windows.
2035 `lambda' means WINDOW may not be a minibuffer window.
2036 a window means a specific minibuffer window
2038 ALL_FRAMES t means search all frames,
2039 nil means search just current frame,
2040 `visible' means search just visible frames on the
2042 0 means search visible and iconified frames on the
2044 a window means search the frame that window belongs to,
2045 a frame means consider windows on that frame, only. */
2048 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2050 struct window
*w
= XWINDOW (window
);
2051 struct frame
*f
= XFRAME (w
->frame
);
2052 int candidate_p
= 1;
2054 if (!BUFFERP (w
->buffer
))
2056 else if (MINI_WINDOW_P (w
)
2057 && (EQ (minibuf
, Qlambda
)
2058 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2060 /* If MINIBUF is `lambda' don't consider any mini-windows.
2061 If it is a window, consider only that one. */
2064 else if (EQ (all_frames
, Qt
))
2066 else if (NILP (all_frames
))
2068 xassert (WINDOWP (owindow
));
2069 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2071 else if (EQ (all_frames
, Qvisible
))
2073 FRAME_SAMPLE_VISIBILITY (f
);
2074 candidate_p
= FRAME_VISIBLE_P (f
)
2075 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2076 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2079 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2081 FRAME_SAMPLE_VISIBILITY (f
);
2082 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2083 #ifdef HAVE_X_WINDOWS
2084 /* Yuck!! If we've just created the frame and the
2085 window-manager requested the user to place it
2086 manually, the window may still not be considered
2087 `visible'. I'd argue it should be at least
2088 something like `iconified', but don't know how to do
2090 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2091 && !f
->output_data
.x
->has_been_visible
)
2094 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2095 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2097 else if (WINDOWP (all_frames
))
2098 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2099 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2100 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2101 else if (FRAMEP (all_frames
))
2102 candidate_p
= EQ (all_frames
, w
->frame
);
2108 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2109 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2110 MINIBUF, and ALL_FRAMES. */
2113 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2116 *window
= selected_window
;
2118 CHECK_LIVE_WINDOW (*window
);
2120 /* MINIBUF nil may or may not include minibuffers. Decide if it
2122 if (NILP (*minibuf
))
2123 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2124 else if (!EQ (*minibuf
, Qt
))
2127 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2128 => count none of them, or a specific minibuffer window (the
2129 active one) to count. */
2131 /* ALL_FRAMES nil doesn't specify which frames to include. */
2132 if (NILP (*all_frames
))
2133 *all_frames
= (!EQ (*minibuf
, Qlambda
)
2134 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
2136 else if (EQ (*all_frames
, Qvisible
))
2138 else if (EQ (*all_frames
, make_number (0)))
2140 else if (FRAMEP (*all_frames
))
2142 else if (!EQ (*all_frames
, Qt
))
2147 /* Return the next or previous window of WINDOW in cyclic ordering
2148 of windows. NEXT_P non-zero means return the next window. See the
2149 documentation string of next-window for the meaning of MINIBUF and
2153 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2155 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2157 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2158 return the first window on the frame. */
2159 if (FRAMEP (all_frames
)
2160 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2161 return Fframe_first_window (all_frames
);
2167 /* Find WINDOW in the list of all windows. */
2168 list
= Fmemq (window
, window_list ());
2170 /* Scan forward from WINDOW to the end of the window list. */
2172 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2173 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2176 /* Scan from the start of the window list up to WINDOW. */
2178 for (list
= Vwindow_list
;
2179 CONSP (list
) && !EQ (XCAR (list
), window
);
2181 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2185 window
= XCAR (list
);
2189 Lisp_Object candidate
, list
;
2191 /* Scan through the list of windows for candidates. If there are
2192 candidate windows in front of WINDOW, the last one of these
2193 is the one we want. If there are candidates following WINDOW
2194 in the list, again the last one of these is the one we want. */
2196 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2198 if (EQ (XCAR (list
), window
))
2200 if (WINDOWP (candidate
))
2203 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2205 candidate
= XCAR (list
);
2208 if (WINDOWP (candidate
))
2216 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2217 doc
: /* Return window following WINDOW in cyclic ordering of windows.
2218 WINDOW must be a live window and defaults to the selected one. The
2219 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2222 MINIBUF nil or omitted means consider the minibuffer window only if the
2223 minibuffer is active. MINIBUF t means consider the minibuffer window
2224 even if the minibuffer is not active. Any other value means do not
2225 consider the minibuffer window even if the minibuffer is active.
2227 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2228 plus the minibuffer window if specified by the MINIBUF argument. If the
2229 minibuffer counts, consider all windows on all frames that share that
2230 minibuffer too. The following non-nil values of ALL-FRAMES have special
2233 - t means consider all windows on all existing frames.
2235 - `visible' means consider all windows on all visible frames.
2237 - 0 (the number zero) means consider all windows on all visible and
2240 - A frame means consider all windows on that frame only.
2242 Anything else means consider all windows on WINDOW's frame and no
2245 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2246 `next-window' to iterate through the entire cycle of acceptable
2247 windows, eventually ending up back at the window you started with.
2248 `previous-window' traverses the same cycle, in the reverse order. */)
2249 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2251 return next_window (window
, minibuf
, all_frames
, 1);
2255 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2256 doc
: /* Return window preceding WINDOW in cyclic ordering of windows.
2257 WINDOW must be a live window and defaults to the selected one. The
2258 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2261 MINIBUF nil or omitted means consider the minibuffer window only if the
2262 minibuffer is active. MINIBUF t means consider the minibuffer window
2263 even if the minibuffer is not active. Any other value means do not
2264 consider the minibuffer window even if the minibuffer is active.
2266 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2267 plus the minibuffer window if specified by the MINIBUF argument. If the
2268 minibuffer counts, consider all windows on all frames that share that
2269 minibuffer too. The following non-nil values of ALL-FRAMES have special
2272 - t means consider all windows on all existing frames.
2274 - `visible' means consider all windows on all visible frames.
2276 - 0 (the number zero) means consider all windows on all visible and
2279 - A frame means consider all windows on that frame only.
2281 Anything else means consider all windows on WINDOW's frame and no
2284 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2285 use `previous-window' to iterate through the entire cycle of
2286 acceptable windows, eventually ending up back at the window you
2287 started with. `next-window' traverses the same cycle, in the
2289 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2291 return next_window (window
, minibuf
, all_frames
, 0);
2295 /* Return a list of windows in cyclic ordering. Arguments are like
2296 for `next-window'. */
2299 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2301 Lisp_Object tail
, list
, rest
;
2303 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2306 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2307 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2308 list
= Fcons (XCAR (tail
), list
);
2310 /* Rotate the list to start with WINDOW. */
2311 list
= Fnreverse (list
);
2312 rest
= Fmemq (window
, list
);
2313 if (!NILP (rest
) && !EQ (rest
, list
))
2315 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2317 XSETCDR (tail
, Qnil
);
2318 list
= nconc2 (rest
, list
);
2324 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2325 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2326 FRAME nil or omitted means use the selected frame.
2327 WINDOW nil or omitted means use the selected window.
2328 MINIBUF t means include the minibuffer window, even if it isn't active.
2329 MINIBUF nil or omitted means include the minibuffer window only
2331 MINIBUF neither nil nor t means never include the minibuffer window. */)
2332 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2335 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2336 CHECK_WINDOW (window
);
2338 frame
= selected_frame
;
2340 if (!EQ (frame
, XWINDOW (window
)->frame
))
2341 error ("Window is on a different frame");
2343 return window_list_1 (window
, minibuf
, frame
);
2347 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2348 doc
: /* Return a list of all live windows.
2349 WINDOW specifies the first window to list and defaults to the selected
2352 Optional argument MINIBUF nil or omitted means consider the minibuffer
2353 window only if the minibuffer is active. MINIBUF t means consider the
2354 minibuffer window even if the minibuffer is not active. Any other value
2355 means do not consider the minibuffer window even if the minibuffer is
2358 Optional argument ALL-FRAMES nil or omitted means consider all windows
2359 on WINDOW's frame, plus the minibuffer window if specified by the
2360 MINIBUF argument. If the minibuffer counts, consider all windows on all
2361 frames that share that minibuffer too. The following non-nil values of
2362 ALL-FRAMES have special meanings:
2364 - t means consider all windows on all existing frames.
2366 - `visible' means consider all windows on all visible frames.
2368 - 0 (the number zero) means consider all windows on all visible and
2371 - A frame means consider all windows on that frame only.
2373 Anything else means consider all windows on WINDOW's frame and no
2376 If WINDOW is not on the list of windows returned, some other window will
2377 be listed first but no error is signalled. */)
2378 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2380 return window_list_1 (window
, minibuf
, all_frames
);
2383 /* Look at all windows, performing an operation specified by TYPE
2385 If FRAMES is Qt, look at all frames;
2386 Qnil, look at just the selected frame;
2387 Qvisible, look at visible frames;
2388 a frame, just look at windows on that frame.
2389 If MINI is non-zero, perform the operation on minibuffer windows too. */
2394 GET_BUFFER_WINDOW
, /* Arg is buffer */
2395 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2396 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2401 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2403 Lisp_Object window
, windows
, best_window
, frame_arg
;
2404 int frame_best_window_flag
= 0;
2406 struct gcpro gcpro1
;
2408 /* If we're only looping through windows on a particular frame,
2409 frame points to that frame. If we're looping through windows
2410 on all frames, frame is 0. */
2411 if (FRAMEP (frames
))
2412 f
= XFRAME (frames
);
2413 else if (NILP (frames
))
2414 f
= SELECTED_FRAME ();
2419 frame_arg
= Qlambda
;
2420 else if (EQ (frames
, make_number (0)))
2422 else if (EQ (frames
, Qvisible
))
2427 /* frame_arg is Qlambda to stick to one frame,
2428 Qvisible to consider all visible frames,
2431 /* Pick a window to start with. */
2435 window
= FRAME_SELECTED_WINDOW (f
);
2437 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2439 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2443 for (; CONSP (windows
); windows
= XCDR (windows
))
2447 window
= XCAR (windows
);
2448 w
= XWINDOW (window
);
2450 /* Note that we do not pay attention here to whether the frame
2451 is visible, since Fwindow_list skips non-visible frames if
2452 that is desired, under the control of frame_arg. */
2453 if (!MINI_WINDOW_P (w
)
2454 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2455 consider all windows. */
2456 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2457 || (mini
&& minibuf_level
> 0))
2460 case GET_BUFFER_WINDOW
:
2461 if (EQ (w
->buffer
, obj
)
2462 /* Don't find any minibuffer window except the one that
2463 is currently in use. */
2464 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2466 if (EQ (window
, selected_window
))
2467 /* Preferably return the selected window. */
2468 RETURN_UNGCPRO (window
);
2469 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2470 && !frame_best_window_flag
)
2471 /* Prefer windows on the current frame (but don't
2472 choose another one if we have one already). */
2474 best_window
= window
;
2475 frame_best_window_flag
= 1;
2477 else if (NILP (best_window
))
2478 best_window
= window
;
2482 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2483 /* We could simply check whether the buffer shown by window
2484 is live, and show another buffer in case it isn't. */
2485 if (EQ (w
->buffer
, obj
))
2487 /* Undedicate WINDOW. */
2488 w
->dedicated
= Qnil
;
2489 /* Make WINDOW show the buffer returned by
2490 other_buffer_safely, don't run any hooks. */
2492 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2493 /* If WINDOW is the selected window, make its buffer
2494 current. But do so only if the window shows the
2495 current buffer (Bug#6454). */
2496 if (EQ (window
, selected_window
)
2497 && XBUFFER (w
->buffer
) == current_buffer
)
2498 Fset_buffer (w
->buffer
);
2502 case REDISPLAY_BUFFER_WINDOWS
:
2503 if (EQ (w
->buffer
, obj
))
2505 mark_window_display_accurate (window
, 0);
2506 w
->update_mode_line
= Qt
;
2507 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2508 ++update_mode_lines
;
2509 best_window
= window
;
2513 /* Check for a window that has a killed buffer. */
2514 case CHECK_ALL_WINDOWS
:
2515 if (! NILP (w
->buffer
)
2516 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2520 case WINDOW_LOOP_UNUSED
:
2529 /* Used for debugging. Abort if any window has a dead buffer. */
2531 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2533 check_all_windows (void)
2535 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2538 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2539 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2540 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2543 The optional argument ALL-FRAMES specifies the frames to consider:
2545 - t means consider all windows on all existing frames.
2547 - `visible' means consider all windows on all visible frames.
2549 - 0 (the number zero) means consider all windows on all visible
2550 and iconified frames.
2552 - A frame means consider all windows on that frame only.
2554 Any other value of ALL-FRAMES means consider all windows on the
2555 selected frame and no others. */)
2556 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2560 if (NILP (buffer_or_name
))
2561 buffer
= Fcurrent_buffer ();
2563 buffer
= Fget_buffer (buffer_or_name
);
2565 if (BUFFERP (buffer
))
2566 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2572 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2574 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2578 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2579 Sdelete_other_windows_internal
, 0, 2, "",
2580 doc
: /* Make WINDOW fill its frame.
2581 Only the frame WINDOW is on is affected. WINDOW may be any window and
2582 defaults to the selected one.
2584 Optional argument ROOT, if non-nil, must specify an internal window
2585 containing WINDOW as a subwindow. If this is the case, replace ROOT by
2586 WINDOW and leave alone any windows not contained in ROOT.
2588 When WINDOW is live try to reduce display jumps by keeping the text
2589 previously visible in WINDOW in the same place on the frame. Doing this
2590 depends on the value of (window-start WINDOW), so if calling this
2591 function in a program gives strange scrolling, make sure the
2592 window-start value is reasonable when this function is called. */)
2593 (Lisp_Object window
, Lisp_Object root
)
2595 struct window
*w
, *r
, *s
;
2597 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2598 ptrdiff_t startpos
IF_LINT (= 0);
2599 int top
IF_LINT (= 0), new_top
, resize_failed
;
2601 w
= decode_any_window (window
);
2602 XSETWINDOW (window
, w
);
2603 f
= XFRAME (w
->frame
);
2606 /* ROOT is the frame's root window. */
2608 root
= FRAME_ROOT_WINDOW (f
);
2612 /* ROOT must be an ancestor of WINDOW. */
2614 r
= decode_any_window (root
);
2615 pwindow
= XWINDOW (window
)->parent
;
2616 while (!NILP (pwindow
))
2617 if (EQ (pwindow
, root
))
2620 pwindow
= XWINDOW (pwindow
)->parent
;
2621 if (!EQ (pwindow
, root
))
2622 error ("Specified root is not an ancestor of specified window");
2625 if (EQ (window
, root
))
2628 /* I don't understand the "top > 0" part below. If we deal with a
2629 standalone minibuffer it would have been caught by the preceding
2631 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2632 error ("Can't expand minibuffer to full frame");
2634 if (!NILP (w
->buffer
))
2636 startpos
= marker_position (w
->start
);
2637 top
= WINDOW_TOP_EDGE_LINE (w
)
2638 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2639 /* Make sure WINDOW is the frame's selected window. */
2640 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2642 if (EQ (selected_frame
, w
->frame
))
2643 Fselect_window (window
, Qnil
);
2645 FRAME_SELECTED_WINDOW (f
) = window
;
2650 /* See if the frame's selected window is a subwindow of WINDOW, by
2651 finding all the selected window's parents and comparing each
2652 one with WINDOW. If it isn't we need a new selected window for
2654 swindow
= FRAME_SELECTED_WINDOW (f
);
2658 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2659 pwindow
= XWINDOW (pwindow
)->parent
;
2661 if (EQ (window
, pwindow
))
2662 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2663 as the new selected window. */
2666 /* Else try the previous window of SWINDOW. */
2667 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2670 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2672 if (EQ (selected_frame
, w
->frame
))
2673 Fselect_window (swindow
, Qnil
);
2675 FRAME_SELECTED_WINDOW (f
) = swindow
;
2680 free_window_matrices (r
);
2682 windows_or_buffers_changed
++;
2683 Vwindow_list
= Qnil
;
2684 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2687 if (NILP (w
->buffer
))
2689 /* Resize subwindows vertically. */
2690 XSETINT (delta
, XINT (r
->total_lines
) - XINT (w
->total_lines
));
2691 w
->top_line
= r
->top_line
;
2692 resize_root_window (window
, delta
, Qnil
, Qnil
);
2693 if (window_resize_check (w
, 0))
2694 window_resize_apply (w
, 0);
2697 resize_root_window (window
, delta
, Qnil
, Qt
);
2698 if (window_resize_check (w
, 0))
2699 window_resize_apply (w
, 0);
2704 /* Resize subwindows horizontally. */
2707 w
->left_col
= r
->left_col
;
2708 XSETINT (delta
, XINT (r
->total_cols
) - XINT (w
->total_cols
));
2709 w
->left_col
= r
->left_col
;
2710 resize_root_window (window
, delta
, Qt
, Qnil
);
2711 if (window_resize_check (w
, 1))
2712 window_resize_apply (w
, 1);
2715 resize_root_window (window
, delta
, Qt
, Qt
);
2716 if (window_resize_check (w
, 1))
2717 window_resize_apply (w
, 1);
2724 /* Play safe, if we still can ... */
2727 w
= XWINDOW (window
);
2731 /* Cleanly unlink WINDOW from window-tree. */
2732 if (!NILP (w
->prev
))
2733 /* Get SIBLING above (on the left of) WINDOW. */
2736 s
= XWINDOW (sibling
);
2738 if (!NILP (s
->next
))
2739 XWINDOW (s
->next
)->prev
= sibling
;
2742 /* Get SIBLING below (on the right of) WINDOW. */
2745 s
= XWINDOW (sibling
);
2747 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2748 XWINDOW (w
->parent
)->vchild
= sibling
;
2750 XWINDOW (w
->parent
)->hchild
= sibling
;
2753 /* Delete ROOT and all subwindows of ROOT. */
2754 if (!NILP (r
->vchild
))
2756 delete_all_subwindows (r
->vchild
);
2759 else if (!NILP (r
->hchild
))
2761 delete_all_subwindows (r
->hchild
);
2765 replace_window (root
, window
, 1);
2767 /* Reset WINDOW's splits status. */
2770 /* This must become SWINDOW anyway ....... */
2771 if (!NILP (w
->buffer
) && !resize_failed
)
2773 /* Try to minimize scrolling, by setting the window start to the
2774 point will cause the text at the old window start to be at the
2775 same place on the frame. But don't try to do this if the
2776 window start is outside the visible portion (as might happen
2777 when the display is not current, due to typeahead). */
2778 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2780 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2781 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2783 struct position pos
;
2784 struct buffer
*obuf
= current_buffer
;
2786 Fset_buffer (w
->buffer
);
2787 /* This computation used to temporarily move point, but that
2788 can have unwanted side effects due to text properties. */
2789 pos
= *vmotion (startpos
, -top
, w
);
2791 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2792 w
->window_end_valid
= Qnil
;
2793 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2794 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2796 /* We need to do this, so that the window-scroll-functions
2798 w
->optional_new_start
= Qt
;
2800 set_buffer_internal (obuf
);
2807 run_window_configuration_change_hook (f
);
2814 replace_buffer_in_windows (Lisp_Object buffer
)
2816 call1 (Qreplace_buffer_in_windows
, buffer
);
2820 /* Safely replace BUFFER with some other buffer in all windows of all
2821 frames, even those on other keyboards. */
2824 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2826 Lisp_Object tail
, frame
;
2828 /* A single call to window_loop won't do the job because it only
2829 considers frames on the current keyboard. So loop manually over
2830 frames, and handle each one. */
2831 FOR_EACH_FRAME (tail
, frame
)
2832 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2835 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2836 minimum allowable size. */
2839 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2841 /* For height, we have to see:
2842 how many windows the frame has at minimum (one or two),
2843 and whether it has a menu bar or other special stuff at the top. */
2845 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2846 ? MIN_SAFE_WINDOW_HEIGHT
2847 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2849 if (FRAME_TOP_MARGIN (frame
) > 0)
2850 min_height
+= FRAME_TOP_MARGIN (frame
);
2852 if (*rows
< min_height
)
2854 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2855 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2858 /* Adjust the margins of window W if text area is too small.
2859 Return 1 if window width is ok after adjustment; 0 if window
2860 is still too narrow. */
2863 adjust_window_margins (struct window
*w
)
2865 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2866 - WINDOW_FRINGE_COLS (w
)
2867 - WINDOW_SCROLL_BAR_COLS (w
));
2868 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2869 + WINDOW_RIGHT_MARGIN_COLS (w
));
2871 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2874 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2877 /* Window's text area is too narrow, but reducing the window
2878 margins will fix that. */
2879 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2880 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2882 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2883 w
->left_margin_cols
= w
->right_margin_cols
2884 = make_number (margin_cols
/2);
2886 w
->right_margin_cols
= make_number (margin_cols
);
2889 w
->left_margin_cols
= make_number (margin_cols
);
2893 static Lisp_Object
Fset_window_margins (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2894 static Lisp_Object
Fset_window_fringes (Lisp_Object
, Lisp_Object
, Lisp_Object
,
2896 static Lisp_Object
Fset_window_scroll_bars (Lisp_Object
, Lisp_Object
,
2897 Lisp_Object
, Lisp_Object
);
2898 static Lisp_Object
Fset_window_vscroll (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2900 /* The following three routines are needed for running a window's
2901 configuration change hook. */
2903 run_funs (Lisp_Object funs
)
2905 for (; CONSP (funs
); funs
= XCDR (funs
))
2906 if (!EQ (XCAR (funs
), Qt
))
2907 call0 (XCAR (funs
));
2911 select_window_norecord (Lisp_Object window
)
2913 return WINDOW_LIVE_P (window
)
2914 ? Fselect_window (window
, Qt
) : selected_window
;
2918 select_frame_norecord (Lisp_Object frame
)
2920 return FRAME_LIVE_P (XFRAME (frame
))
2921 ? Fselect_frame (frame
, Qt
) : selected_frame
;
2925 run_window_configuration_change_hook (struct frame
*f
)
2927 ptrdiff_t count
= SPECPDL_INDEX ();
2928 Lisp_Object frame
, global_wcch
2929 = Fdefault_value (Qwindow_configuration_change_hook
);
2930 XSETFRAME (frame
, f
);
2932 if (NILP (Vrun_hooks
))
2935 /* Use the right buffer. Matters when running the local hooks. */
2936 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
2938 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2939 Fset_buffer (Fwindow_buffer (Qnil
));
2942 if (SELECTED_FRAME () != f
)
2944 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
2945 select_frame_norecord (frame
);
2948 /* Look for buffer-local values. */
2950 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
2951 for (; CONSP (windows
); windows
= XCDR (windows
))
2953 Lisp_Object window
= XCAR (windows
);
2954 Lisp_Object buffer
= Fwindow_buffer (window
);
2955 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
2958 ptrdiff_t inner_count
= SPECPDL_INDEX ();
2959 record_unwind_protect (select_window_norecord
, Fselected_window ());
2960 select_window_norecord (window
);
2961 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
2963 unbind_to (inner_count
, Qnil
);
2968 run_funs (global_wcch
);
2969 unbind_to (count
, Qnil
);
2972 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
2973 Srun_window_configuration_change_hook
, 1, 1, 0,
2974 doc
: /* Run `window-configuration-change-hook' for FRAME. */)
2977 CHECK_LIVE_FRAME (frame
);
2978 run_window_configuration_change_hook (XFRAME (frame
));
2982 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2983 means it's allowed to run hooks. See make_frame for a case where
2984 it's not allowed. KEEP_MARGINS_P non-zero means that the current
2985 margins, fringes, and scroll-bar settings of the window are not
2986 reset from the buffer's local settings. */
2989 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
2991 struct window
*w
= XWINDOW (window
);
2992 struct buffer
*b
= XBUFFER (buffer
);
2993 ptrdiff_t count
= SPECPDL_INDEX ();
2994 int samebuf
= EQ (buffer
, w
->buffer
);
2998 if (EQ (window
, selected_window
))
2999 BVAR (b
, last_selected_window
) = window
;
3001 /* Let redisplay errors through. */
3002 b
->display_error_modiff
= 0;
3004 /* Update time stamps of buffer display. */
3005 if (INTEGERP (BVAR (b
, display_count
)))
3006 XSETINT (BVAR (b
, display_count
), XINT (BVAR (b
, display_count
)) + 1);
3007 BVAR (b
, display_time
) = Fcurrent_time ();
3009 XSETFASTINT (w
->window_end_pos
, 0);
3010 XSETFASTINT (w
->window_end_vpos
, 0);
3011 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3012 w
->window_end_valid
= Qnil
;
3013 if (!(keep_margins_p
&& samebuf
))
3014 { /* If we're not actually changing the buffer, don't reset hscroll and
3015 vscroll. This case happens for example when called from
3016 change_frame_size_1, where we use a dummy call to
3017 Fset_window_buffer on the frame's selected window (and no other)
3018 just in order to run window-configuration-change-hook.
3019 Resetting hscroll and vscroll here is problematic for things like
3020 image-mode and doc-view-mode since it resets the image's position
3021 whenever we resize the frame. */
3022 w
->hscroll
= w
->min_hscroll
= make_number (0);
3024 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3025 set_marker_restricted (w
->start
,
3026 make_number (b
->last_window_start
),
3028 w
->start_at_line_beg
= Qnil
;
3029 w
->force_start
= Qnil
;
3030 XSETFASTINT (w
->last_modified
, 0);
3031 XSETFASTINT (w
->last_overlay_modified
, 0);
3033 /* Maybe we could move this into the `if' but it's not obviously safe and
3034 I doubt it's worth the trouble. */
3035 windows_or_buffers_changed
++;
3037 /* We must select BUFFER for running the window-scroll-functions. */
3038 /* We can't check ! NILP (Vwindow_scroll_functions) here
3039 because that might itself be a local variable. */
3040 if (window_initialized
)
3042 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3043 Fset_buffer (buffer
);
3046 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3048 if (!keep_margins_p
)
3050 /* Set left and right marginal area width etc. from buffer. */
3052 /* This may call adjust_window_margins three times, so
3053 temporarily disable window margins. */
3054 Lisp_Object save_left
= w
->left_margin_cols
;
3055 Lisp_Object save_right
= w
->right_margin_cols
;
3057 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3059 Fset_window_fringes (window
,
3060 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3061 BVAR (b
, fringes_outside_margins
));
3063 Fset_window_scroll_bars (window
,
3064 BVAR (b
, scroll_bar_width
),
3065 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3067 w
->left_margin_cols
= save_left
;
3068 w
->right_margin_cols
= save_right
;
3070 Fset_window_margins (window
,
3071 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3076 if (! NILP (Vwindow_scroll_functions
))
3077 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3078 Fmarker_position (w
->start
));
3079 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3082 unbind_to (count
, Qnil
);
3085 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3086 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3087 WINDOW has to be a live window and defaults to the selected one.
3088 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3090 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3091 display margins, fringe widths, and scroll bar settings are preserved;
3092 the default is to reset these from the local settings for BUFFER-OR-NAME
3093 or the frame defaults. Return nil.
3095 This function throws an error when WINDOW is strongly dedicated to its
3096 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3097 already display BUFFER-OR-NAME.
3099 This function runs `window-scroll-functions' before running
3100 `window-configuration-change-hook'. */)
3101 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3103 register Lisp_Object tem
, buffer
;
3104 register struct window
*w
= decode_window (window
);
3106 XSETWINDOW (window
, w
);
3107 buffer
= Fget_buffer (buffer_or_name
);
3108 CHECK_BUFFER (buffer
);
3109 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3110 error ("Attempt to display deleted buffer");
3114 error ("Window is deleted");
3115 else if (!EQ (tem
, Qt
))
3116 /* w->buffer is t when the window is first being set up. */
3118 if (!EQ (tem
, buffer
))
3120 if (EQ (w
->dedicated
, Qt
))
3121 /* WINDOW is strongly dedicated to its buffer, signal an
3123 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3125 /* WINDOW is weakly dedicated to its buffer, reset
3127 w
->dedicated
= Qnil
;
3129 call1 (Qrecord_window_buffer
, window
);
3135 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3141 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3143 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3146 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3148 doc
: /* Force all windows to be updated on next redisplay.
3149 If optional arg OBJECT is a window, force redisplay of that window only.
3150 If OBJECT is a buffer or buffer name, force redisplay of all windows
3151 displaying that buffer. */)
3152 (Lisp_Object object
)
3156 windows_or_buffers_changed
++;
3157 update_mode_lines
++;
3161 if (WINDOWP (object
))
3163 struct window
*w
= XWINDOW (object
);
3164 mark_window_display_accurate (object
, 0);
3165 w
->update_mode_line
= Qt
;
3166 if (BUFFERP (w
->buffer
))
3167 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3168 ++update_mode_lines
;
3172 if (STRINGP (object
))
3173 object
= Fget_buffer (object
);
3174 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3176 /* Walk all windows looking for buffer, and force update
3177 of each of those windows. */
3179 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3180 return NILP (object
) ? Qnil
: Qt
;
3183 /* If nothing suitable was found, just return.
3184 We could signal an error, but this feature will typically be used
3185 asynchronously in timers or process sentinels, so we don't. */
3191 temp_output_buffer_show (register Lisp_Object buf
)
3193 register struct buffer
*old
= current_buffer
;
3194 register Lisp_Object window
;
3195 register struct window
*w
;
3197 BVAR (XBUFFER (buf
), directory
) = BVAR (current_buffer
, directory
);
3200 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3204 set_buffer_internal (old
);
3206 if (!NILP (Vtemp_buffer_show_function
))
3207 call1 (Vtemp_buffer_show_function
, buf
);
3210 window
= display_buffer (buf
, Vtemp_buffer_show_specifiers
, Qnil
);
3211 /* Reset Vtemp_buffer_show_specifiers immediately so it won't
3212 affect subsequent calls. */
3213 Vtemp_buffer_show_specifiers
= Qnil
;
3215 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3216 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3217 Vminibuf_scroll_window
= window
;
3218 w
= XWINDOW (window
);
3219 XSETFASTINT (w
->hscroll
, 0);
3220 XSETFASTINT (w
->min_hscroll
, 0);
3221 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3222 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3224 /* Run temp-buffer-show-hook, with the chosen window selected
3225 and its buffer current. */
3227 ptrdiff_t count
= SPECPDL_INDEX ();
3228 Lisp_Object prev_window
, prev_buffer
;
3229 prev_window
= selected_window
;
3230 XSETBUFFER (prev_buffer
, old
);
3232 /* Select the window that was chosen, for running the hook.
3233 Note: Both Fselect_window and select_window_norecord may
3234 set-buffer to the buffer displayed in the window,
3235 so we need to save the current buffer. --stef */
3236 record_unwind_protect (Fset_buffer
, prev_buffer
);
3237 record_unwind_protect (select_window_norecord
, prev_window
);
3238 Fselect_window (window
, Qt
);
3239 Fset_buffer (w
->buffer
);
3240 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3241 unbind_to (count
, Qnil
);
3246 DEFUN ("internal-temp-output-buffer-show",
3247 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3249 doc
: /* Internal function for `with-output-to-temp-buffer''. */)
3252 temp_output_buffer_show (buf
);
3256 /* Make new window, have it replace WINDOW in window-tree, and make
3257 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3258 horizontal child). */
3260 make_parent_window (Lisp_Object window
, int horflag
)
3263 register struct window
*o
, *p
;
3266 o
= XWINDOW (window
);
3267 p
= allocate_window ();
3268 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3269 ((struct Lisp_Vector
*) p
)->contents
[i
]
3270 = ((struct Lisp_Vector
*) o
)->contents
[i
];
3271 XSETWINDOW (parent
, p
);
3274 XSETFASTINT (p
->sequence_number
, sequence_number
);
3276 replace_window (window
, parent
, 1);
3282 p
->hchild
= horflag
? window
: Qnil
;
3283 p
->vchild
= horflag
? Qnil
: window
;
3289 p
->window_parameters
= Qnil
;
3292 /* Make new window from scratch. */
3297 register struct window
*w
;
3299 w
= allocate_window ();
3300 /* Initialize all Lisp data. */
3301 w
->frame
= w
->mini_p
= Qnil
;
3302 w
->next
= w
->prev
= w
->hchild
= w
->vchild
= w
->parent
= Qnil
;
3303 XSETFASTINT (w
->left_col
, 0);
3304 XSETFASTINT (w
->top_line
, 0);
3305 XSETFASTINT (w
->total_lines
, 0);
3306 XSETFASTINT (w
->total_cols
, 0);
3307 w
->normal_lines
= make_float (1.0);
3308 w
->normal_cols
= make_float (1.0);
3309 XSETFASTINT (w
->new_total
, 0);
3310 XSETFASTINT (w
->new_normal
, 0);
3312 w
->start
= Fmake_marker ();
3313 w
->pointm
= Fmake_marker ();
3314 w
->force_start
= w
->optional_new_start
= Qnil
;
3315 XSETFASTINT (w
->hscroll
, 0);
3316 XSETFASTINT (w
->min_hscroll
, 0);
3317 XSETFASTINT (w
->use_time
, 0);
3319 XSETFASTINT (w
->sequence_number
, sequence_number
);
3320 w
->temslot
= w
->last_modified
= w
->last_overlay_modified
= Qnil
;
3321 XSETFASTINT (w
->last_point
, 0);
3322 w
->last_had_star
= w
->vertical_scroll_bar
= Qnil
;
3323 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3324 w
->left_fringe_width
= w
->right_fringe_width
= Qnil
;
3325 w
->fringes_outside_margins
= Qnil
;
3326 w
->scroll_bar_width
= Qnil
;
3327 w
->vertical_scroll_bar_type
= Qt
;
3328 w
->last_mark_x
= w
->last_mark_y
= Qnil
;
3329 XSETFASTINT (w
->window_end_pos
, 0);
3330 XSETFASTINT (w
->window_end_vpos
, 0);
3331 w
->window_end_valid
= w
->update_mode_line
= Qnil
;
3332 w
->start_at_line_beg
= w
->display_table
= w
->dedicated
= Qnil
;
3333 w
->base_line_number
= w
->base_line_pos
= w
->region_showing
= Qnil
;
3334 w
->column_number_displayed
= w
->redisplay_end_trigger
= Qnil
;
3335 w
->splits
= w
->nest
= w
->window_parameters
= Qnil
;
3336 w
->prev_buffers
= w
->next_buffers
= Qnil
;
3337 /* Initialize non-Lisp data. */
3338 w
->desired_matrix
= w
->current_matrix
= 0;
3339 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3340 memset (&w
->cursor
, 0, sizeof (w
->cursor
));
3341 memset (&w
->last_cursor
, 0, sizeof (w
->last_cursor
));
3342 memset (&w
->phys_cursor
, 0, sizeof (w
->phys_cursor
));
3343 w
->phys_cursor_type
= -1;
3344 w
->phys_cursor_width
= -1;
3345 w
->last_cursor_off_p
= w
->cursor_off_p
= 0;
3346 w
->must_be_updated_p
= 0;
3347 w
->pseudo_window_p
= 0;
3348 w
->frozen_window_start_p
= 0;
3350 /* Reset window_list. */
3351 Vwindow_list
= Qnil
;
3352 /* Return window. */
3353 XSETWINDOW (window
, w
);
3357 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3358 doc
: /* Set new total size of WINDOW to SIZE.
3361 Optional argument ADD non-nil means add SIZE to the new total size of
3362 WINDOW and return the sum.
3364 Note: This function does not operate on any subwindows of WINDOW. */)
3365 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3367 struct window
*w
= decode_any_window (window
);
3369 CHECK_NUMBER (size
);
3371 XSETINT (w
->new_total
, XINT (size
));
3373 XSETINT (w
->new_total
, XINT (w
->new_total
) + XINT (size
));
3375 return w
->new_total
;
3378 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3379 doc
: /* Set new normal size of WINDOW to SIZE.
3382 Note: This function does not operate on any subwindows of WINDOW. */)
3383 (Lisp_Object window
, Lisp_Object size
)
3385 struct window
*w
= decode_any_window (window
);
3387 w
->new_normal
= size
;
3388 return w
->new_normal
;
3391 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3392 non-zero) to w->new_total would result in correct heights (widths)
3393 for window W and recursively all subwindows of W.
3395 Note: This function does not check any of `window-fixed-size-p',
3396 `window-min-height' or `window-min-width'. It does check that window
3397 sizes do not drop below one line (two columns). */
3399 window_resize_check (struct window
*w
, int horflag
)
3403 if (!NILP (w
->vchild
))
3404 /* W is a vertical combination. */
3406 c
= XWINDOW (w
->vchild
);
3408 /* All subwindows of W must have the same width as W. */
3412 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3413 || !window_resize_check (c
, horflag
))
3415 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3420 /* The sum of the heights of the subwindows of W must equal W's
3423 int sum_of_sizes
= 0;
3426 if (!window_resize_check (c
, horflag
))
3428 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3429 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3431 return (sum_of_sizes
== XINT (w
->new_total
));
3434 else if (!NILP (w
->hchild
))
3435 /* W is a horizontal combination. */
3437 c
= XWINDOW (w
->hchild
);
3439 /* The sum of the widths of the subwindows of W must equal W's
3442 int sum_of_sizes
= 0;
3445 if (!window_resize_check (c
, horflag
))
3447 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3448 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3450 return (sum_of_sizes
== XINT (w
->new_total
));
3453 /* All subwindows of W must have the same height as W. */
3457 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3458 || !window_resize_check (c
, horflag
))
3460 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3466 /* A leaf window. Make sure it's not too small. The following
3467 hardcodes the values of `window-safe-min-width' (2) and
3468 `window-safe-min-height' (1) which are defined in window.el. */
3469 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3472 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3473 w->new_total for window W and recursively all subwindows of W. Also
3474 calculate and assign the new vertical (horizontal) start positions of
3475 each of these windows.
3477 This function does not perform any error checks. Make sure you have
3478 run window_resize_check on W before applying this function. */
3480 window_resize_apply (struct window
*w
, int horflag
)
3485 /* Note: Assigning new_normal requires that the new total size of the
3486 parent window has been set *before*. */
3489 w
->total_cols
= w
->new_total
;
3490 if (NUMBERP (w
->new_normal
))
3491 w
->normal_cols
= w
->new_normal
;
3493 pos
= XINT (w
->left_col
);
3497 w
->total_lines
= w
->new_total
;
3498 if (NUMBERP (w
->new_normal
))
3499 w
->normal_lines
= w
->new_normal
;
3501 pos
= XINT (w
->top_line
);
3504 if (!NILP (w
->vchild
))
3505 /* W is a vertical combination. */
3507 c
= XWINDOW (w
->vchild
);
3511 XSETFASTINT (c
->left_col
, pos
);
3513 XSETFASTINT (c
->top_line
, pos
);
3514 window_resize_apply (c
, horflag
);
3516 pos
= pos
+ XINT (c
->total_lines
);
3517 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3520 else if (!NILP (w
->hchild
))
3521 /* W is a horizontal combination. */
3523 c
= XWINDOW (w
->hchild
);
3527 XSETFASTINT (c
->left_col
, pos
);
3529 XSETFASTINT (c
->top_line
, pos
);
3530 window_resize_apply (c
, horflag
);
3532 pos
= pos
+ XINT (c
->total_cols
);
3533 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3537 /* Clear out some redisplay caches. */
3538 XSETFASTINT (w
->last_modified
, 0);
3539 XSETFASTINT (w
->last_overlay_modified
, 0);
3543 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 1, 2, 0,
3544 doc
: /* Apply requested size values for window-tree of FRAME.
3545 Optional argument HORIZONTAL omitted or nil means apply requested height
3546 values. HORIZONTAL non-nil means apply requested width values.
3548 This function checks whether the requested values sum up to a valid
3549 window layout, recursively assigns the new sizes of all subwindows and
3550 calculates and assigns the new start positions of these windows.
3552 Note: This function does not check any of `window-fixed-size-p',
3553 `window-min-height' or `window-min-width'. All these checks have to
3554 be applied on the Elisp level. */)
3555 (Lisp_Object frame
, Lisp_Object horizontal
)
3559 int horflag
= !NILP (horizontal
);
3562 frame
= selected_frame
;
3563 CHECK_LIVE_FRAME (frame
);
3566 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3568 if (!window_resize_check (r
, horflag
)
3569 || ! EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3573 window_resize_apply (r
, horflag
);
3575 windows_or_buffers_changed
++;
3576 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3581 run_window_configuration_change_hook (f
);
3587 /* Resize frame F's windows when number of lines of F is set to SIZE.
3588 HORFLAG 1 means resize windows when number of columns of F is set to
3591 This function can delete all windows but the selected one in order to
3592 satisfy the request. The result will be meaningful if and only if
3593 F's windows have meaningful sizes when you call this. */
3595 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3597 Lisp_Object root
= f
->root_window
;
3598 struct window
*r
= XWINDOW (root
);
3599 Lisp_Object mini
= f
->minibuffer_window
;
3601 /* new_size is the new size of the frame's root window. */
3602 int new_size
= (horflag
3605 - FRAME_TOP_MARGIN (f
)
3606 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3609 XSETFASTINT (r
->top_line
, FRAME_TOP_MARGIN (f
));
3610 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3611 /* For a leaf root window just set the size. */
3613 XSETFASTINT (r
->total_cols
, new_size
);
3615 XSETFASTINT (r
->total_lines
, new_size
);
3618 /* old_size is the old size of the frame's root window. */
3619 int old_size
= XFASTINT (horflag
? r
->total_cols
: r
->total_lines
);
3622 XSETINT (delta
, new_size
- old_size
);
3623 /* Try a "normal" resize first. */
3624 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3625 if (window_resize_check (r
, horflag
) && new_size
== XINT (r
->new_total
))
3626 window_resize_apply (r
, horflag
);
3629 /* Try with "reasonable" minimum sizes next. */
3630 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3631 if (window_resize_check (r
, horflag
)
3632 && new_size
== XINT (r
->new_total
))
3633 window_resize_apply (r
, horflag
);
3636 /* Finally, try with "safe" minimum sizes. */
3637 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3638 if (window_resize_check (r
, horflag
)
3639 && new_size
== XINT (r
->new_total
))
3640 window_resize_apply (r
, horflag
);
3643 /* We lost. Delete all windows but the frame's
3645 root
= f
->selected_window
;
3646 Fdelete_other_windows_internal (root
, Qnil
);
3648 XSETFASTINT (XWINDOW (root
)->total_cols
, new_size
);
3650 XSETFASTINT (XWINDOW (root
)->total_lines
, new_size
);
3656 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3660 XSETFASTINT (m
->total_cols
, size
);
3663 /* Are we sure we always want 1 line here? */
3664 XSETFASTINT (m
->total_lines
, 1);
3665 XSETFASTINT (m
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
3671 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3672 doc
: /* Split window OLD.
3673 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3674 new window. In any case TOTAL-SIZE must be a positive integer.
3676 Third argument SIDE nil (or `below') specifies that the new window shall
3677 be located below WINDOW. SIDE `above' means the new window shall be
3678 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3679 lines of the new window including space reserved for the mode and/or
3682 SIDE t (or `right') specifies that the new window shall be located on
3683 the right side of WINDOW. SIDE `left' means the new window shall be
3684 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3685 number of columns of the new window including space reserved for fringes
3686 and the scrollbar or a divider column.
3688 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3689 according to the SIDE argument.
3691 The new total and normal sizes of all involved windows must have been
3692 set correctly. See the code of `split-window' for how this is done. */)
3693 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3695 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3696 parent window or an internal window we have to install as OLD's new
3697 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3698 provided OLD is a leaf window, or to the frame's selected window.
3699 NEW (*n) is the new window created with some parameters taken from
3701 register Lisp_Object
new, frame
, reference
;
3702 register struct window
*o
, *p
, *n
, *r
;
3705 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3706 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3711 frame
= WINDOW_FRAME (o
);
3714 CHECK_NUMBER (total_size
);
3716 /* Set do_nest to 1 if we have to make a new parent window. We do
3717 that if either `window-nest' is non-nil, or OLD has no parent, or
3718 OLD is ortho-combined. */
3720 !NILP (Vwindow_nest
)
3723 ? (XWINDOW (o
->parent
)->hchild
)
3724 : (XWINDOW (o
->parent
)->vchild
));
3726 /* We need a live reference window to initialize some parameters. */
3727 if (WINDOW_LIVE_P (old
))
3728 /* OLD is live, use it as reference window. */
3731 /* Use the frame's selected window as reference window. */
3732 reference
= FRAME_SELECTED_WINDOW (f
);
3733 r
= XWINDOW (reference
);
3735 /* The following bugs are caught by `split-window'. */
3736 if (MINI_WINDOW_P (o
))
3737 error ("Attempt to split minibuffer window");
3738 else if (XINT (total_size
) < (horflag
? 2 : 1))
3739 error ("Size of new window too small (after split)");
3740 else if (!do_nest
&& !NILP (Vwindow_splits
))
3741 /* `window-splits' non-nil means try to resize OLD's siblings
3744 p
= XWINDOW (o
->parent
);
3745 /* Temporarily pretend we split the parent window. */
3746 XSETINT (p
->new_total
,
3747 XINT (horflag
? p
->total_cols
: p
->total_lines
)
3748 - XINT (total_size
));
3749 if (!window_resize_check (p
, horflag
))
3750 error ("Window sizes don't fit");
3752 /* Undo the temporary pretension. */
3753 p
->new_total
= horflag
? p
->total_cols
: p
->total_lines
;
3757 if (!window_resize_check (o
, horflag
))
3758 error ("Resizing old window failed");
3759 else if (XINT (total_size
) + XINT (o
->new_total
)
3760 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3761 error ("Sum of sizes of old and new window don't fit");
3764 /* This is our point of no return. */
3767 /* Save the old value of o->normal_cols/lines. It gets corrupted
3768 by make_parent_window and we need it below for assigning it to
3770 Lisp_Object new_normal
= horflag
? o
->normal_cols
: o
->normal_lines
;
3772 make_parent_window (old
, horflag
);
3773 p
= XWINDOW (o
->parent
);
3774 /* Store value of `window-nest' in new parent's nest slot. */
3775 p
->nest
= Vwindow_nest
;
3776 /* Have PARENT inherit splits slot value from OLD. */
3777 p
->splits
= o
->splits
;
3778 /* Store value of `window-splits' in OLD's splits slot. */
3779 o
->splits
= Vwindow_splits
;
3780 /* These get applied below. */
3781 p
->new_total
= horflag
? o
->total_cols
: o
->total_lines
;
3782 p
->new_normal
= new_normal
;
3785 p
= XWINDOW (o
->parent
);
3787 windows_or_buffers_changed
++;
3788 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3789 new = make_window ();
3792 n
->parent
= o
->parent
;
3793 n
->vchild
= n
->hchild
= Qnil
;
3795 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3804 XWINDOW (n
->prev
)->next
= new;
3811 if (!NILP (n
->next
))
3812 XWINDOW (n
->next
)->prev
= new;
3818 n
->window_end_valid
= Qnil
;
3819 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3821 /* Get special geometry settings from reference window. */
3822 n
->left_margin_cols
= r
->left_margin_cols
;
3823 n
->right_margin_cols
= r
->right_margin_cols
;
3824 n
->left_fringe_width
= r
->left_fringe_width
;
3825 n
->right_fringe_width
= r
->right_fringe_width
;
3826 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3827 n
->scroll_bar_width
= r
->scroll_bar_width
;
3828 n
->vertical_scroll_bar_type
= r
->vertical_scroll_bar_type
;
3830 /* Store `window-splits' in NEW's splits slot. */
3831 n
->splits
= Vwindow_splits
;
3833 /* Directly assign orthogonal coordinates and sizes. */
3836 n
->top_line
= o
->top_line
;
3837 n
->total_lines
= o
->total_lines
;
3841 n
->left_col
= o
->left_col
;
3842 n
->total_cols
= o
->total_cols
;
3845 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3846 get them ready here. */
3847 n
->new_total
= total_size
;
3848 n
->new_normal
= normal_size
;
3851 window_resize_apply (p
, horflag
);
3853 /* Set buffer of NEW to buffer of reference window. Don't run
3855 set_window_buffer (new, r
->buffer
, 0, 1);
3858 /* Maybe we should run the scroll functions in Elisp (which already
3859 runs the configuration change hook). */
3860 if (! NILP (Vwindow_scroll_functions
))
3861 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3862 Fmarker_position (n
->start
));
3868 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3869 doc
: /* Remove WINDOW from its frame.
3870 WINDOW defaults to the selected window. Return nil. Signal an error
3871 when WINDOW is the only window on its frame. */)
3872 (register Lisp_Object window
)
3874 register Lisp_Object parent
, sibling
, frame
, root
;
3875 struct window
*w
, *p
, *s
, *r
;
3878 int before_sibling
= 0;
3880 w
= decode_any_window (window
);
3881 XSETWINDOW (window
, w
);
3882 if (NILP (w
->buffer
) && NILP (w
->hchild
) && NILP (w
->vchild
))
3883 /* It's a no-op to delete an already deleted window. */
3888 /* Never delete a minibuffer or frame root window. */
3889 error ("Attempt to delete minibuffer or sole ordinary window");
3890 else if (NILP (w
->prev
) && NILP (w
->next
))
3891 /* Rather bow out here, this case should be handled on the Elisp
3893 error ("Attempt to delete sole window of parent");
3895 p
= XWINDOW (parent
);
3896 horflag
= NILP (p
->vchild
);
3898 frame
= WINDOW_FRAME (w
);
3901 root
= FRAME_ROOT_WINDOW (f
);
3904 /* Unlink WINDOW from window tree. */
3906 /* Get SIBLING below (on the right of) WINDOW. */
3908 /* before_sibling 1 means WINDOW is the first child of its
3909 parent and thus before the sibling. */
3912 s
= XWINDOW (sibling
);
3915 p
->hchild
= sibling
;
3917 p
->vchild
= sibling
;
3920 /* Get SIBLING above (on the left of) WINDOW. */
3923 s
= XWINDOW (sibling
);
3925 if (!NILP (s
->next
))
3926 XWINDOW (s
->next
)->prev
= sibling
;
3929 if (window_resize_check (r
, horflag
)
3930 && EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3931 /* We can delete WINDOW now. */
3935 window_resize_apply (p
, horflag
);
3937 windows_or_buffers_changed
++;
3938 Vwindow_list
= Qnil
;
3939 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3941 w
->next
= Qnil
; /* Don't delete w->next too. */
3942 free_window_matrices (w
);
3944 if (!NILP (w
->vchild
))
3946 delete_all_subwindows (w
->vchild
);
3949 else if (!NILP (w
->hchild
))
3951 delete_all_subwindows (w
->hchild
);
3954 else if (!NILP (w
->buffer
))
3957 unchain_marker (XMARKER (w
->pointm
));
3958 unchain_marker (XMARKER (w
->start
));
3962 if (NILP (s
->prev
) && NILP (s
->next
))
3963 /* A matrjoshka where SIBLING has become the only child of
3966 /* Put SIBLING into PARENT's place. */
3967 replace_window (parent
, sibling
, 0);
3968 /* Have SIBLING inherit the following three slot values from
3969 PARENT (the nest slot is not inherited). */
3970 s
->normal_cols
= p
->normal_cols
;
3971 s
->normal_lines
= p
->normal_lines
;
3972 s
->splits
= p
->splits
;
3973 /* Mark PARENT as deleted. */
3974 p
->vchild
= p
->hchild
= Qnil
;
3975 /* Try to merge SIBLING into its new parent. */
3976 recombine_windows (sibling
);
3981 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
3982 /* We deleted the frame's selected window. */
3984 /* Use the frame's first window as fallback ... */
3985 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
3986 /* ... but preferably use its most recently used window. */
3987 Lisp_Object mru_window
;
3989 /* `get-mru-window' might fail for some reason so play it safe
3990 - promote the first window _without recording it_ first. */
3991 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
3992 Fselect_window (new_selected_window
, Qt
);
3994 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
3998 /* Now look whether `get-mru-window' gets us something. */
3999 mru_window
= call1 (Qget_mru_window
, frame
);
4000 if (WINDOW_LIVE_P (mru_window
)
4001 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4002 new_selected_window
= mru_window
;
4004 /* If all ended up well, we now promote the mru window. */
4005 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4006 Fselect_window (new_selected_window
, Qnil
);
4008 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
4013 /* Must be run by the caller:
4014 run_window_configuration_change_hook (f); */
4017 /* We failed: Relink WINDOW into window tree. */
4030 if (!NILP (w
->next
))
4031 XWINDOW (w
->next
)->prev
= window
;
4033 error ("Deletion failed");
4039 /***********************************************************************
4040 Resizing Mini-Windows
4041 ***********************************************************************/
4043 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4046 grow_mini_window (struct window
*w
, int delta
)
4048 struct frame
*f
= XFRAME (w
->frame
);
4050 Lisp_Object root
, value
;
4052 xassert (MINI_WINDOW_P (w
));
4053 xassert (delta
>= 0);
4055 root
= FRAME_ROOT_WINDOW (f
);
4057 value
= call2 (Qwindow_resize_root_window_vertically
,
4058 root
, make_number (- delta
));
4059 if (INTEGERP (value
) && window_resize_check (r
, 0))
4062 window_resize_apply (r
, 0);
4064 /* Grow the mini-window. */
4065 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4066 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - XINT (value
));
4067 XSETFASTINT (w
->last_modified
, 0);
4068 XSETFASTINT (w
->last_overlay_modified
, 0);
4076 /* Shrink mini-window W. */
4078 shrink_mini_window (struct window
*w
)
4080 struct frame
*f
= XFRAME (w
->frame
);
4082 Lisp_Object root
, value
;
4085 xassert (MINI_WINDOW_P (w
));
4087 size
= XINT (w
->total_lines
);
4090 root
= FRAME_ROOT_WINDOW (f
);
4092 value
= call2 (Qwindow_resize_root_window_vertically
,
4093 root
, make_number (size
- 1));
4094 if (INTEGERP (value
) && window_resize_check (r
, 0))
4097 window_resize_apply (r
, 0);
4099 /* Shrink the mini-window. */
4100 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4101 XSETFASTINT (w
->total_lines
, 1);
4103 XSETFASTINT (w
->last_modified
, 0);
4104 XSETFASTINT (w
->last_overlay_modified
, 0);
4109 /* If the above failed for whatever strange reason we must make a
4110 one window frame here. The same routine will be needed when
4111 shrinking the frame (and probably when making the initial
4112 *scratch* window). For the moment leave things as they are. */
4116 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4117 doc
: /* Resize minibuffer window WINDOW. */)
4118 (Lisp_Object window
)
4120 struct window
*w
= XWINDOW (window
);
4125 CHECK_WINDOW (window
);
4126 f
= XFRAME (w
->frame
);
4128 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4129 error ("Not a valid minibuffer window");
4130 else if (FRAME_MINIBUF_ONLY_P (f
))
4131 error ("Cannot resize a minibuffer-only frame");
4133 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4134 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4135 if (window_resize_check (r
, 0)
4136 && XINT (w
->new_total
) > 0
4137 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4140 window_resize_apply (r
, 0);
4142 w
->total_lines
= w
->new_total
;
4143 XSETFASTINT (w
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
4145 windows_or_buffers_changed
++;
4146 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4150 run_window_configuration_change_hook (f
);
4153 else error ("Failed to resize minibuffer window");
4156 /* Mark window cursors off for all windows in the window tree rooted
4157 at W by setting their phys_cursor_on_p flag to zero. Called from
4158 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4159 the frame are cleared. */
4162 mark_window_cursors_off (struct window
*w
)
4166 if (!NILP (w
->hchild
))
4167 mark_window_cursors_off (XWINDOW (w
->hchild
));
4168 else if (!NILP (w
->vchild
))
4169 mark_window_cursors_off (XWINDOW (w
->vchild
));
4171 w
->phys_cursor_on_p
= 0;
4173 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4178 /* Return number of lines of text (not counting mode lines) in W. */
4181 window_internal_height (struct window
*w
)
4183 int ht
= XFASTINT (w
->total_lines
);
4185 if (!MINI_WINDOW_P (w
))
4187 if (!NILP (w
->parent
)
4188 || !NILP (w
->vchild
)
4189 || !NILP (w
->hchild
)
4192 || WINDOW_WANTS_MODELINE_P (w
))
4195 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4202 /************************************************************************
4204 ***********************************************************************/
4206 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4207 N screen-fulls, which is defined as the height of the window minus
4208 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4209 instead. Negative values of N mean scroll down. NOERROR non-zero
4210 means don't signal an error if we try to move over BEGV or ZV,
4214 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4217 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4219 /* If we must, use the pixel-based version which is much slower than
4220 the line-based one but can handle varying line heights. */
4221 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4222 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4224 window_scroll_line_based (window
, n
, whole
, noerror
);
4230 /* Implementation of window_scroll that works based on pixel line
4231 heights. See the comment of window_scroll for parameter
4235 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4238 struct window
*w
= XWINDOW (window
);
4239 struct text_pos start
;
4240 int this_scroll_margin
;
4241 /* True if we fiddled the window vscroll field without really scrolling. */
4243 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4244 void *itdata
= NULL
;
4246 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4248 /* If PT is not visible in WINDOW, move back one half of
4249 the screen. Allow PT to be partially visible, otherwise
4250 something like (scroll-down 1) with PT in the line before
4251 the partially visible one would recenter. */
4253 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4255 itdata
= bidi_shelve_cache ();
4256 /* Move backward half the height of the window. Performance note:
4257 vmotion used here is about 10% faster, but would give wrong
4258 results for variable height lines. */
4259 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4260 it
.current_y
= it
.last_visible_y
;
4261 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4263 /* The function move_iterator_vertically may move over more than
4264 the specified y-distance. If it->w is small, e.g. a
4265 mini-buffer window, we may end up in front of the window's
4266 display area. This is the case when Start displaying at the
4267 start of the line containing PT in this case. */
4268 if (it
.current_y
<= 0)
4270 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4271 move_it_vertically_backward (&it
, 0);
4275 start
= it
.current
.pos
;
4276 bidi_unshelve_cache (itdata
, 0);
4278 else if (auto_window_vscroll_p
)
4280 if (rtop
|| rbot
) /* partially visible */
4283 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4285 dy
= max ((window_box_height (w
)
4286 - next_screen_context_lines
* dy
),
4292 /* Only vscroll backwards if already vscrolled forwards. */
4293 if (w
->vscroll
< 0 && rtop
> 0)
4295 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4296 Fset_window_vscroll (window
, make_number (px
), Qt
);
4302 /* Do vscroll if already vscrolled or only display line. */
4303 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4305 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4306 Fset_window_vscroll (window
, make_number (px
), Qt
);
4310 /* Maybe modify window start instead of scrolling. */
4311 if (rbot
> 0 || w
->vscroll
< 0)
4315 Fset_window_vscroll (window
, make_number (0), Qt
);
4316 /* If there are other text lines above the current row,
4317 move window start to current row. Else to next row. */
4319 spos
= XINT (Fline_beginning_position (Qnil
));
4321 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4322 set_marker_restricted (w
->start
, make_number (spos
),
4324 w
->start_at_line_beg
= Qt
;
4325 w
->update_mode_line
= Qt
;
4326 XSETFASTINT (w
->last_modified
, 0);
4327 XSETFASTINT (w
->last_overlay_modified
, 0);
4328 /* Set force_start so that redisplay_window will run the
4329 window-scroll-functions. */
4330 w
->force_start
= Qt
;
4335 /* Cancel previous vscroll. */
4336 Fset_window_vscroll (window
, make_number (0), Qt
);
4339 itdata
= bidi_shelve_cache ();
4340 /* If scroll_preserve_screen_position is non-nil, we try to set
4341 point in the same window line as it is now, so get that line. */
4342 if (!NILP (Vscroll_preserve_screen_position
))
4344 /* We preserve the goal pixel coordinate across consecutive
4345 calls to scroll-up, scroll-down and other commands that
4346 have the `scroll-command' property. This avoids the
4347 possibility of point becoming "stuck" on a tall line when
4348 scrolling by one line. */
4349 if (window_scroll_pixel_based_preserve_y
< 0
4350 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4351 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4353 start_display (&it
, w
, start
);
4354 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4355 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4356 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4360 window_scroll_pixel_based_preserve_y
4361 = window_scroll_pixel_based_preserve_x
= -1;
4363 /* Move iterator it from start the specified distance forward or
4364 backward. The result is the new window start. */
4365 start_display (&it
, w
, start
);
4368 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4369 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4370 dy
= max ((window_box_height (w
)
4371 - next_screen_context_lines
* dy
),
4374 /* Note that move_it_vertically always moves the iterator to the
4375 start of a line. So, if the last line doesn't have a newline,
4376 we would end up at the start of the line ending at ZV. */
4379 move_it_vertically_backward (&it
, -dy
);
4380 /* Ensure we actually do move, e.g. in case we are currently
4381 looking at an image that is taller that the window height. */
4382 while (start_pos
== IT_CHARPOS (it
)
4383 && start_pos
> BEGV
)
4384 move_it_by_lines (&it
, -1);
4388 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4389 MOVE_TO_POS
| MOVE_TO_Y
);
4390 /* Ensure we actually do move, e.g. in case we are currently
4391 looking at an image that is taller that the window height. */
4392 while (start_pos
== IT_CHARPOS (it
)
4394 move_it_by_lines (&it
, 1);
4398 move_it_by_lines (&it
, n
);
4400 /* We failed if we find ZV is already on the screen (scrolling up,
4401 means there's nothing past the end), or if we can't start any
4402 earlier (scrolling down, means there's nothing past the top). */
4403 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4404 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4406 if (IT_CHARPOS (it
) == ZV
)
4408 if (it
.current_y
< it
.last_visible_y
4409 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4410 > it
.last_visible_y
))
4412 /* The last line was only partially visible, make it fully
4414 w
->vscroll
= (it
.last_visible_y
4415 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4416 adjust_glyphs (it
.f
);
4420 bidi_unshelve_cache (itdata
, 0);
4423 else if (n
< 0) /* could happen with empty buffers */
4424 xsignal0 (Qbeginning_of_buffer
);
4426 xsignal0 (Qend_of_buffer
);
4431 if (w
->vscroll
!= 0)
4432 /* The first line was only partially visible, make it fully
4437 bidi_unshelve_cache (itdata
, 0);
4441 xsignal0 (Qbeginning_of_buffer
);
4445 /* If control gets here, then we vscrolled. */
4447 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4449 /* Don't try to change the window start below. */
4455 ptrdiff_t pos
= IT_CHARPOS (it
);
4458 /* If in the middle of a multi-glyph character move forward to
4459 the next character. */
4460 if (in_display_vector_p (&it
))
4463 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4466 /* Set the window start, and set up the window for redisplay. */
4467 set_marker_restricted (w
->start
, make_number (pos
),
4469 bytepos
= XMARKER (w
->start
)->bytepos
;
4470 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4472 w
->update_mode_line
= Qt
;
4473 XSETFASTINT (w
->last_modified
, 0);
4474 XSETFASTINT (w
->last_overlay_modified
, 0);
4475 /* Set force_start so that redisplay_window will run the
4476 window-scroll-functions. */
4477 w
->force_start
= Qt
;
4480 /* The rest of this function uses current_y in a nonstandard way,
4481 not including the height of the header line if any. */
4482 it
.current_y
= it
.vpos
= 0;
4484 /* Move PT out of scroll margins.
4485 This code wants current_y to be zero at the window start position
4486 even if there is a header line. */
4487 this_scroll_margin
= max (0, scroll_margin
);
4488 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4489 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4493 /* We moved the window start towards ZV, so PT may be now
4494 in the scroll margin at the top. */
4495 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4496 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4497 && (NILP (Vscroll_preserve_screen_position
)
4498 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4499 /* We found PT at a legitimate height. Leave it alone. */
4501 else if (window_scroll_pixel_based_preserve_y
>= 0)
4503 /* If we have a header line, take account of it.
4504 This is necessary because we set it.current_y to 0, above. */
4505 move_it_to (&it
, -1,
4506 window_scroll_pixel_based_preserve_x
,
4507 window_scroll_pixel_based_preserve_y
4508 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4509 -1, MOVE_TO_Y
| MOVE_TO_X
);
4510 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4514 while (it
.current_y
< this_scroll_margin
)
4516 int prev
= it
.current_y
;
4517 move_it_by_lines (&it
, 1);
4518 if (prev
== it
.current_y
)
4521 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4526 ptrdiff_t charpos
, bytepos
;
4529 /* Save our position, for the
4530 window_scroll_pixel_based_preserve_y case. */
4531 charpos
= IT_CHARPOS (it
);
4532 bytepos
= IT_BYTEPOS (it
);
4534 /* We moved the window start towards BEGV, so PT may be now
4535 in the scroll margin at the bottom. */
4536 move_it_to (&it
, PT
, -1,
4537 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4538 - this_scroll_margin
- 1),
4540 MOVE_TO_POS
| MOVE_TO_Y
);
4542 /* Save our position, in case it's correct. */
4543 charpos
= IT_CHARPOS (it
);
4544 bytepos
= IT_BYTEPOS (it
);
4546 /* See if point is on a partially visible line at the end. */
4547 if (it
.what
== IT_EOB
)
4548 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4551 move_it_by_lines (&it
, 1);
4552 partial_p
= it
.current_y
> it
.last_visible_y
;
4555 if (charpos
== PT
&& !partial_p
4556 && (NILP (Vscroll_preserve_screen_position
)
4557 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4558 /* We found PT before we found the display margin, so PT is ok. */
4560 else if (window_scroll_pixel_based_preserve_y
>= 0)
4562 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4563 start_display (&it
, w
, start
);
4564 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4565 here because we called start_display again and did not
4566 alter it.current_y this time. */
4567 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4568 window_scroll_pixel_based_preserve_y
, -1,
4569 MOVE_TO_Y
| MOVE_TO_X
);
4570 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4575 /* The last line was only partially visible, so back up two
4576 lines to make sure we're on a fully visible line. */
4578 move_it_by_lines (&it
, -2);
4579 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4582 /* No, the position we saved is OK, so use it. */
4583 SET_PT_BOTH (charpos
, bytepos
);
4586 bidi_unshelve_cache (itdata
, 0);
4590 /* Implementation of window_scroll that works based on screen lines.
4591 See the comment of window_scroll for parameter descriptions. */
4594 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4596 register struct window
*w
= XWINDOW (window
);
4597 /* Fvertical_motion enters redisplay, which can trigger
4598 fontification, which in turn can modify buffer text (e.g., if the
4599 fontification functions replace escape sequences with faces, as
4600 in `grep-mode-font-lock-keywords'). So we use a marker to record
4601 the old point position, to prevent crashes in SET_PT_BOTH. */
4602 Lisp_Object opoint_marker
= Fpoint_marker ();
4603 register ptrdiff_t pos
, pos_byte
;
4604 register int ht
= window_internal_height (w
);
4605 register Lisp_Object tem
;
4609 Lisp_Object original_pos
= Qnil
;
4611 /* If scrolling screen-fulls, compute the number of lines to
4612 scroll from the window's height. */
4614 n
*= max (1, ht
- next_screen_context_lines
);
4616 startpos
= marker_position (w
->start
);
4618 if (!NILP (Vscroll_preserve_screen_position
))
4620 if (window_scroll_preserve_vpos
<= 0
4621 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4622 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4624 struct position posit
4625 = *compute_motion (startpos
, 0, 0, 0,
4627 -1, XINT (w
->hscroll
),
4629 window_scroll_preserve_vpos
= posit
.vpos
;
4630 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
4633 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4634 make_number (window_scroll_preserve_vpos
));
4637 XSETFASTINT (tem
, PT
);
4638 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4642 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4647 lose
= n
< 0 && PT
== BEGV
;
4648 Fvertical_motion (make_number (n
), window
);
4652 SET_PT_BOTH (marker_position (opoint_marker
),
4653 marker_byte_position (opoint_marker
));
4660 xsignal0 (Qbeginning_of_buffer
);
4665 /* Don't use a scroll margin that is negative or too large. */
4666 int this_scroll_margin
=
4667 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4669 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4670 w
->start_at_line_beg
= bolp
;
4671 w
->update_mode_line
= Qt
;
4672 XSETFASTINT (w
->last_modified
, 0);
4673 XSETFASTINT (w
->last_overlay_modified
, 0);
4674 /* Set force_start so that redisplay_window will run
4675 the window-scroll-functions. */
4676 w
->force_start
= Qt
;
4678 if (!NILP (Vscroll_preserve_screen_position
)
4679 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4681 SET_PT_BOTH (pos
, pos_byte
);
4682 Fvertical_motion (original_pos
, window
);
4684 /* If we scrolled forward, put point enough lines down
4685 that it is outside the scroll margin. */
4690 if (this_scroll_margin
> 0)
4692 SET_PT_BOTH (pos
, pos_byte
);
4693 Fvertical_motion (make_number (this_scroll_margin
), window
);
4699 if (top_margin
<= marker_position (opoint_marker
))
4700 SET_PT_BOTH (marker_position (opoint_marker
),
4701 marker_byte_position (opoint_marker
));
4702 else if (!NILP (Vscroll_preserve_screen_position
))
4704 SET_PT_BOTH (pos
, pos_byte
);
4705 Fvertical_motion (original_pos
, window
);
4708 SET_PT (top_margin
);
4714 /* If we scrolled backward, put point near the end of the window
4715 but not within the scroll margin. */
4716 SET_PT_BOTH (pos
, pos_byte
);
4717 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4718 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4721 bottom_margin
= PT
+ 1;
4723 if (bottom_margin
> marker_position (opoint_marker
))
4724 SET_PT_BOTH (marker_position (opoint_marker
),
4725 marker_byte_position (opoint_marker
));
4728 if (!NILP (Vscroll_preserve_screen_position
))
4730 SET_PT_BOTH (pos
, pos_byte
);
4731 Fvertical_motion (original_pos
, window
);
4734 Fvertical_motion (make_number (-1), window
);
4743 xsignal0 (Qend_of_buffer
);
4748 /* Scroll selected_window up or down. If N is nil, scroll a
4749 screen-full which is defined as the height of the window minus
4750 next_screen_context_lines. If N is the symbol `-', scroll.
4751 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4752 up. This is the guts of Fscroll_up and Fscroll_down. */
4755 scroll_command (Lisp_Object n
, int direction
)
4757 ptrdiff_t count
= SPECPDL_INDEX ();
4759 xassert (eabs (direction
) == 1);
4761 /* If selected window's buffer isn't current, make it current for
4762 the moment. But don't screw up if window_scroll gets an error. */
4763 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4765 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4766 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4768 /* Make redisplay consider other windows than just selected_window. */
4769 ++windows_or_buffers_changed
;
4773 window_scroll (selected_window
, direction
, 1, 0);
4774 else if (EQ (n
, Qminus
))
4775 window_scroll (selected_window
, -direction
, 1, 0);
4778 n
= Fprefix_numeric_value (n
);
4779 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4782 unbind_to (count
, Qnil
);
4785 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4786 doc
: /* Scroll text of selected window upward ARG lines.
4787 If ARG is omitted or nil, scroll upward by a near full screen.
4788 A near full screen is `next-screen-context-lines' less than a full screen.
4789 Negative ARG means scroll downward.
4790 If ARG is the atom `-', scroll downward by nearly full screen.
4791 When calling from a program, supply as argument a number, nil, or `-'. */)
4794 scroll_command (arg
, 1);
4798 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4799 doc
: /* Scroll text of selected window down ARG lines.
4800 If ARG is omitted or nil, scroll down by a near full screen.
4801 A near full screen is `next-screen-context-lines' less than a full screen.
4802 Negative ARG means scroll upward.
4803 If ARG is the atom `-', scroll upward by nearly full screen.
4804 When calling from a program, supply as argument a number, nil, or `-'. */)
4807 scroll_command (arg
, -1);
4811 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4812 doc
: /* Return the other window for \"other window scroll\" commands.
4813 If `other-window-scroll-buffer' is non-nil, a window
4814 showing that buffer is used.
4815 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4816 specifies the window. This takes precedence over
4817 `other-window-scroll-buffer'. */)
4822 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4823 && !NILP (Vminibuf_scroll_window
))
4824 window
= Vminibuf_scroll_window
;
4825 /* If buffer is specified, scroll that buffer. */
4826 else if (!NILP (Vother_window_scroll_buffer
))
4828 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4830 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4834 /* Nothing specified; look for a neighboring window on the same
4836 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4838 if (EQ (window
, selected_window
))
4839 /* That didn't get us anywhere; look for a window on another
4842 window
= Fnext_window (window
, Qnil
, Qt
);
4843 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4844 && ! EQ (window
, selected_window
));
4847 CHECK_LIVE_WINDOW (window
);
4849 if (EQ (window
, selected_window
))
4850 error ("There is no other window");
4855 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4856 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4857 A near full screen is `next-screen-context-lines' less than a full screen.
4858 The next window is the one below the current one; or the one at the top
4859 if the current one is at the bottom. Negative ARG means scroll downward.
4860 If ARG is the atom `-', scroll downward by nearly full screen.
4861 When calling from a program, supply as argument a number, nil, or `-'.
4863 If `other-window-scroll-buffer' is non-nil, scroll the window
4864 showing that buffer, popping the buffer up if necessary.
4865 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4866 specifies the window to scroll. This takes precedence over
4867 `other-window-scroll-buffer'. */)
4872 ptrdiff_t count
= SPECPDL_INDEX ();
4874 window
= Fother_window_for_scrolling ();
4875 w
= XWINDOW (window
);
4877 /* Don't screw up if window_scroll gets an error. */
4878 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4879 ++windows_or_buffers_changed
;
4881 Fset_buffer (w
->buffer
);
4882 SET_PT (marker_position (w
->pointm
));
4885 window_scroll (window
, 1, 1, 1);
4886 else if (EQ (arg
, Qminus
))
4887 window_scroll (window
, -1, 1, 1);
4893 window_scroll (window
, XINT (arg
), 0, 1);
4896 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4897 unbind_to (count
, Qnil
);
4902 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
4903 doc
: /* Scroll selected window display ARG columns left.
4904 Default for ARG is window width minus 2.
4905 Value is the total amount of leftward horizontal scrolling in
4906 effect after the change.
4907 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4908 lower bound for automatic scrolling, i.e. automatic scrolling
4909 will not scroll a window to a column less than the value returned
4910 by this function. This happens in an interactive call. */)
4911 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4915 struct window
*w
= XWINDOW (selected_window
);
4918 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4920 arg
= Fprefix_numeric_value (arg
);
4922 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
4923 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4925 if (!NILP (set_minimum
))
4926 w
->min_hscroll
= w
->hscroll
;
4931 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
4932 doc
: /* Scroll selected window display ARG columns right.
4933 Default for ARG is window width minus 2.
4934 Value is the total amount of leftward horizontal scrolling in
4935 effect after the change.
4936 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4937 lower bound for automatic scrolling, i.e. automatic scrolling
4938 will not scroll a window to a column less than the value returned
4939 by this function. This happens in an interactive call. */)
4940 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4944 struct window
*w
= XWINDOW (selected_window
);
4947 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4949 arg
= Fprefix_numeric_value (arg
);
4951 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
4952 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4954 if (!NILP (set_minimum
))
4955 w
->min_hscroll
= w
->hscroll
;
4960 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
4961 doc
: /* Return the window which was selected when entering the minibuffer.
4962 Returns nil, if selected window is not a minibuffer window. */)
4965 if (minibuf_level
> 0
4966 && MINI_WINDOW_P (XWINDOW (selected_window
))
4967 && WINDOW_LIVE_P (minibuf_selected_window
))
4968 return minibuf_selected_window
;
4973 /* Value is the number of lines actually displayed in window W,
4974 as opposed to its height. */
4977 displayed_window_lines (struct window
*w
)
4980 struct text_pos start
;
4981 int height
= window_box_height (w
);
4982 struct buffer
*old_buffer
;
4984 void *itdata
= NULL
;
4986 if (XBUFFER (w
->buffer
) != current_buffer
)
4988 old_buffer
= current_buffer
;
4989 set_buffer_internal (XBUFFER (w
->buffer
));
4994 /* In case W->start is out of the accessible range, do something
4995 reasonable. This happens in Info mode when Info-scroll-down
4996 calls (recenter -1) while W->start is 1. */
4997 if (XMARKER (w
->start
)->charpos
< BEGV
)
4998 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4999 else if (XMARKER (w
->start
)->charpos
> ZV
)
5000 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5002 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5004 itdata
= bidi_shelve_cache ();
5005 start_display (&it
, w
, start
);
5006 move_it_vertically (&it
, height
);
5007 bottom_y
= line_bottom_y (&it
);
5008 bidi_unshelve_cache (itdata
, 0);
5010 /* rms: On a non-window display,
5011 the value of it.vpos at the bottom of the screen
5012 seems to be 1 larger than window_box_height (w).
5013 This kludge fixes a bug whereby (move-to-window-line -1)
5014 when ZV is on the last screen line
5015 moves to the previous screen line instead of the last one. */
5016 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5019 /* Add in empty lines at the bottom of the window. */
5020 if (bottom_y
< height
)
5022 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5023 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5027 set_buffer_internal (old_buffer
);
5033 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5034 doc
: /* Center point in selected window and maybe redisplay frame.
5035 With prefix argument ARG, recenter putting point on screen line ARG
5036 relative to the selected window. If ARG is negative, it counts up from the
5037 bottom of the window. (ARG should be less than the height of the window.)
5039 If ARG is omitted or nil, then recenter with point on the middle line of
5040 the selected window; if the variable `recenter-redisplay' is non-nil,
5041 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5042 is set to `grow-only', this resets the tool-bar's height to the minimum
5043 height needed); if `recenter-redisplay' has the special value `tty',
5044 then only tty frame are redrawn.
5046 Just C-u as prefix means put point in the center of the window
5047 and redisplay normally--don't erase and redraw the frame. */)
5048 (register Lisp_Object arg
)
5050 struct window
*w
= XWINDOW (selected_window
);
5051 struct buffer
*buf
= XBUFFER (w
->buffer
);
5052 struct buffer
*obuf
= current_buffer
;
5054 ptrdiff_t charpos
, bytepos
;
5055 EMACS_INT iarg
IF_LINT (= 0);
5056 int this_scroll_margin
;
5058 /* If redisplay is suppressed due to an error, try again. */
5059 obuf
->display_error_modiff
= 0;
5063 if (!NILP (Vrecenter_redisplay
)
5064 && (!EQ (Vrecenter_redisplay
, Qtty
)
5065 || !NILP (Ftty_type (selected_frame
))))
5069 /* Invalidate pixel data calculated for all compositions. */
5070 for (i
= 0; i
< n_compositions
; i
++)
5071 composition_table
[i
]->font
= NULL
;
5073 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5075 Fredraw_frame (WINDOW_FRAME (w
));
5076 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5081 else if (CONSP (arg
)) /* Just C-u. */
5085 arg
= Fprefix_numeric_value (arg
);
5090 set_buffer_internal (buf
);
5092 /* Do this after making BUF current
5093 in case scroll_margin is buffer-local. */
5094 this_scroll_margin
=
5095 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5097 /* Handle centering on a graphical frame specially. Such frames can
5098 have variable-height lines and centering point on the basis of
5099 line counts would lead to strange effects. */
5100 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5106 void *itdata
= bidi_shelve_cache ();
5108 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5109 start_display (&it
, w
, pt
);
5110 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5111 charpos
= IT_CHARPOS (it
);
5112 bytepos
= IT_BYTEPOS (it
);
5113 bidi_unshelve_cache (itdata
, 0);
5119 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5120 int extra_line_spacing
;
5121 int h
= window_box_height (w
);
5122 void *itdata
= bidi_shelve_cache ();
5124 iarg
= - max (-iarg
, this_scroll_margin
);
5126 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5127 start_display (&it
, w
, pt
);
5129 /* Be sure we have the exact height of the full line containing PT. */
5130 move_it_by_lines (&it
, 0);
5132 /* The amount of pixels we have to move back is the window
5133 height minus what's displayed in the line containing PT,
5134 and the lines below. */
5137 move_it_by_lines (&it
, nlines
);
5139 if (it
.vpos
== nlines
)
5143 /* Last line has no newline */
5144 h
-= line_bottom_y (&it
);
5148 /* Don't reserve space for extra line spacing of last line. */
5149 extra_line_spacing
= it
.max_extra_line_spacing
;
5151 /* If we can't move down NLINES lines because we hit
5152 the end of the buffer, count in some empty lines. */
5153 if (it
.vpos
< nlines
)
5156 extra_line_spacing
= it
.extra_line_spacing
;
5157 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5161 bidi_unshelve_cache (itdata
, 0);
5165 /* Now find the new top line (starting position) of the window. */
5166 start_display (&it
, w
, pt
);
5168 move_it_vertically_backward (&it
, h
);
5170 /* If extra line spacing is present, we may move too far
5171 back. This causes the last line to be only partially
5172 visible (which triggers redisplay to recenter that line
5173 in the middle), so move forward.
5174 But ignore extra line spacing on last line, as it is not
5175 considered to be part of the visible height of the line.
5177 h
+= extra_line_spacing
;
5178 while (-it
.current_y
> h
)
5179 move_it_by_lines (&it
, 1);
5181 charpos
= IT_CHARPOS (it
);
5182 bytepos
= IT_BYTEPOS (it
);
5184 bidi_unshelve_cache (itdata
, 0);
5188 struct position pos
;
5190 iarg
= max (iarg
, this_scroll_margin
);
5192 pos
= *vmotion (PT
, -iarg
, w
);
5193 charpos
= pos
.bufpos
;
5194 bytepos
= pos
.bytepos
;
5199 struct position pos
;
5200 int ht
= window_internal_height (w
);
5207 /* Don't let it get into the margin at either top or bottom. */
5208 iarg
= max (iarg
, this_scroll_margin
);
5209 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5211 pos
= *vmotion (PT
, - iarg
, w
);
5212 charpos
= pos
.bufpos
;
5213 bytepos
= pos
.bytepos
;
5216 /* Set the new window start. */
5217 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5218 w
->window_end_valid
= Qnil
;
5220 w
->optional_new_start
= Qt
;
5222 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5223 w
->start_at_line_beg
= Qt
;
5225 w
->start_at_line_beg
= Qnil
;
5227 set_buffer_internal (obuf
);
5231 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5233 doc
: /* Return the height in lines of the text display area of WINDOW.
5234 WINDOW defaults to the selected window.
5236 The return value does not include the mode line, any header line, nor
5237 any partial-height lines in the text display area. */)
5238 (Lisp_Object window
)
5240 struct window
*w
= decode_window (window
);
5241 int pixel_height
= window_box_height (w
);
5242 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5243 return make_number (line_height
);
5248 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5250 doc
: /* Position point relative to window.
5251 With no argument, position point at center of window.
5252 An argument specifies vertical position within the window;
5253 zero means top of window, negative means relative to bottom of window. */)
5256 struct window
*w
= XWINDOW (selected_window
);
5260 int this_scroll_margin
;
5263 if (!(BUFFERP (w
->buffer
)
5264 && XBUFFER (w
->buffer
) == current_buffer
))
5265 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5266 when passed below to set_marker_both. */
5267 error ("move-to-window-line called from unrelated buffer");
5269 window
= selected_window
;
5270 start
= marker_position (w
->start
);
5271 if (start
< BEGV
|| start
> ZV
)
5273 int height
= window_internal_height (w
);
5274 Fvertical_motion (make_number (- (height
/ 2)), window
);
5275 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5276 w
->start_at_line_beg
= Fbolp ();
5277 w
->force_start
= Qt
;
5280 Fgoto_char (w
->start
);
5282 lines
= displayed_window_lines (w
);
5285 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5289 XSETFASTINT (arg
, lines
/ 2);
5292 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5295 iarg
= iarg
+ lines
;
5297 #if 0 /* This code would prevent move-to-window-line from moving point
5298 to a place inside the scroll margins (which would cause the
5299 next redisplay to scroll). I wrote this code, but then concluded
5300 it is probably better not to install it. However, it is here
5301 inside #if 0 so as not to lose it. -- rms. */
5303 /* Don't let it get into the margin at either top or bottom. */
5304 iarg
= max (iarg
, this_scroll_margin
);
5305 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5308 arg
= make_number (iarg
);
5311 /* Skip past a partially visible first line. */
5313 XSETINT (arg
, XINT (arg
) + 1);
5315 return Fvertical_motion (arg
, window
);
5320 /***********************************************************************
5321 Window Configuration
5322 ***********************************************************************/
5324 struct save_window_data
5326 struct vectorlike_header header
;
5327 Lisp_Object selected_frame
;
5328 Lisp_Object current_window
;
5329 Lisp_Object current_buffer
;
5330 Lisp_Object minibuf_scroll_window
;
5331 Lisp_Object minibuf_selected_window
;
5332 Lisp_Object root_window
;
5333 Lisp_Object focus_frame
;
5334 /* A vector, each of whose elements is a struct saved_window
5336 Lisp_Object saved_windows
;
5338 /* All fields above are traced by the GC.
5339 From `fame-cols' down, the fields are ignored by the GC. */
5341 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5342 int frame_tool_bar_lines
;
5345 /* This is saved as a Lisp_Vector */
5348 struct vectorlike_header header
;
5350 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5351 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5352 Lisp_Object normal_cols
, normal_lines
;
5353 Lisp_Object hscroll
, min_hscroll
;
5354 Lisp_Object parent
, prev
;
5355 Lisp_Object start_at_line_beg
;
5356 Lisp_Object display_table
;
5357 Lisp_Object left_margin_cols
, right_margin_cols
;
5358 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5359 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5360 Lisp_Object splits
, nest
, window_parameters
;
5363 #define SAVED_WINDOW_N(swv,n) \
5364 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5366 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5367 doc
: /* Return t if OBJECT is a window-configuration object. */)
5368 (Lisp_Object object
)
5370 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5373 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5374 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5375 (Lisp_Object config
)
5377 register struct save_window_data
*data
;
5378 struct Lisp_Vector
*saved_windows
;
5380 CHECK_WINDOW_CONFIGURATION (config
);
5382 data
= (struct save_window_data
*) XVECTOR (config
);
5383 saved_windows
= XVECTOR (data
->saved_windows
);
5384 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5387 DEFUN ("set-window-configuration", Fset_window_configuration
,
5388 Sset_window_configuration
, 1, 1, 0,
5389 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5390 CONFIGURATION must be a value previously returned
5391 by `current-window-configuration' (which see).
5392 If CONFIGURATION was made from a frame that is now deleted,
5393 only frame-independent values can be restored. In this case,
5394 the return value is nil. Otherwise the value is t. */)
5395 (Lisp_Object configuration
)
5397 register struct save_window_data
*data
;
5398 struct Lisp_Vector
*saved_windows
;
5399 Lisp_Object new_current_buffer
;
5401 Lisp_Object auto_buffer_name
;
5403 ptrdiff_t old_point
= -1;
5405 CHECK_WINDOW_CONFIGURATION (configuration
);
5407 data
= (struct save_window_data
*) XVECTOR (configuration
);
5408 saved_windows
= XVECTOR (data
->saved_windows
);
5410 new_current_buffer
= data
->current_buffer
;
5411 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5412 new_current_buffer
= Qnil
;
5415 if (XBUFFER (new_current_buffer
) == current_buffer
)
5416 /* The code further down "preserves point" by saving here PT in
5417 old_point and then setting it later back into PT. When the
5418 current-selected-window and the final-selected-window both show
5419 the current buffer, this suffers from the problem that the
5420 current PT is the window-point of the current-selected-window,
5421 while the final PT is the point of the final-selected-window, so
5422 this copy from one PT to the other would end up moving the
5423 window-point of the final-selected-window to the window-point of
5424 the current-selected-window. So we have to be careful which
5425 point of the current-buffer we copy into old_point. */
5426 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5427 && WINDOWP (selected_window
)
5428 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5429 && !EQ (selected_window
, data
->current_window
))
5430 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5434 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5435 point in new_current_buffer as of the last time this buffer was
5436 used. This can be non-deterministic since it can be changed by
5437 things like jit-lock by mere temporary selection of some random
5438 window that happens to show this buffer.
5439 So if possible we want this arbitrary choice of "which point" to
5440 be the one from the to-be-selected-window so as to prevent this
5441 window's cursor from being copied from another window. */
5442 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5443 /* If current_window = selected_window, its point is in BUF_PT. */
5444 && !EQ (selected_window
, data
->current_window
))
5445 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5447 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5450 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5453 /* If f is a dead frame, don't bother rebuilding its window tree.
5454 However, there is other stuff we should still try to do below. */
5455 if (FRAME_LIVE_P (f
))
5458 Lisp_Object dead_windows
= Qnil
;
5459 register struct window
*w
;
5460 register struct saved_window
*p
;
5461 struct window
*root_window
;
5462 struct window
**leaf_windows
;
5467 /* If the frame has been resized since this window configuration was
5468 made, we change the frame to the size specified in the
5469 configuration, restore the configuration, and then resize it
5470 back. We keep track of the prevailing height in these variables. */
5471 int previous_frame_lines
= FRAME_LINES (f
);
5472 int previous_frame_cols
= FRAME_COLS (f
);
5473 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5474 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5476 /* The mouse highlighting code could get screwed up
5477 if it runs during this. */
5480 if (data
->frame_lines
!= previous_frame_lines
5481 || data
->frame_cols
!= previous_frame_cols
)
5482 change_frame_size (f
, data
->frame_lines
,
5483 data
->frame_cols
, 0, 0, 0);
5484 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5485 if (data
->frame_menu_bar_lines
5486 != previous_frame_menu_bar_lines
)
5487 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5489 #ifdef HAVE_WINDOW_SYSTEM
5490 if (data
->frame_tool_bar_lines
5491 != previous_frame_tool_bar_lines
)
5492 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5497 /* "Swap out" point from the selected window's buffer
5498 into the window itself. (Normally the pointm of the selected
5499 window holds garbage.) We do this now, before
5500 restoring the window contents, and prevent it from
5501 being done later on when we select a new window. */
5502 if (! NILP (XWINDOW (selected_window
)->buffer
))
5504 w
= XWINDOW (selected_window
);
5505 set_marker_both (w
->pointm
,
5507 BUF_PT (XBUFFER (w
->buffer
)),
5508 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5511 windows_or_buffers_changed
++;
5512 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5514 /* Problem: Freeing all matrices and later allocating them again
5515 is a serious redisplay flickering problem. What we would
5516 really like to do is to free only those matrices not reused
5518 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5520 = (struct window
**) alloca (count_windows (root_window
)
5521 * sizeof (struct window
*));
5522 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5525 Mark all windows now on frame as "deleted".
5526 Restoring the new configuration "undeletes" any that are in it.
5528 Save their current buffers in their height fields, since we may
5529 need it later, if a buffer saved in the configuration is now
5531 delete_all_subwindows (FRAME_ROOT_WINDOW (f
));
5533 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5535 p
= SAVED_WINDOW_N (saved_windows
, k
);
5537 w
= XWINDOW (window
);
5540 if (!NILP (p
->parent
))
5541 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5542 XFASTINT (p
->parent
))->window
;
5546 if (!NILP (p
->prev
))
5548 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5549 XFASTINT (p
->prev
))->window
;
5550 XWINDOW (w
->prev
)->next
= p
->window
;
5555 if (!NILP (w
->parent
))
5557 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5559 XWINDOW (w
->parent
)->vchild
= p
->window
;
5560 XWINDOW (w
->parent
)->hchild
= Qnil
;
5564 XWINDOW (w
->parent
)->hchild
= p
->window
;
5565 XWINDOW (w
->parent
)->vchild
= Qnil
;
5570 /* If we squirreled away the buffer in the window's height,
5572 if (BUFFERP (w
->total_lines
))
5573 w
->buffer
= w
->total_lines
;
5574 w
->left_col
= p
->left_col
;
5575 w
->top_line
= p
->top_line
;
5576 w
->total_cols
= p
->total_cols
;
5577 w
->total_lines
= p
->total_lines
;
5578 w
->normal_cols
= p
->normal_cols
;
5579 w
->normal_lines
= p
->normal_lines
;
5580 w
->hscroll
= p
->hscroll
;
5581 w
->min_hscroll
= p
->min_hscroll
;
5582 w
->display_table
= p
->display_table
;
5583 w
->left_margin_cols
= p
->left_margin_cols
;
5584 w
->right_margin_cols
= p
->right_margin_cols
;
5585 w
->left_fringe_width
= p
->left_fringe_width
;
5586 w
->right_fringe_width
= p
->right_fringe_width
;
5587 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5588 w
->scroll_bar_width
= p
->scroll_bar_width
;
5589 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5590 w
->dedicated
= p
->dedicated
;
5591 w
->splits
= p
->splits
;
5593 w
->window_parameters
= p
->window_parameters
;
5594 XSETFASTINT (w
->last_modified
, 0);
5595 XSETFASTINT (w
->last_overlay_modified
, 0);
5597 /* Reinstall the saved buffer and pointers into it. */
5598 if (NILP (p
->buffer
))
5599 /* An internal window. */
5600 w
->buffer
= p
->buffer
;
5601 else if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5602 /* If saved buffer is alive, install it. */
5604 w
->buffer
= p
->buffer
;
5605 w
->start_at_line_beg
= p
->start_at_line_beg
;
5606 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5607 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5608 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5609 p
->mark
, w
->buffer
);
5611 /* As documented in Fcurrent_window_configuration, don't
5612 restore the location of point in the buffer which was
5613 current when the window configuration was recorded. */
5614 if (!EQ (p
->buffer
, new_current_buffer
)
5615 && XBUFFER (p
->buffer
) == current_buffer
)
5616 Fgoto_char (w
->pointm
);
5618 else if (!NILP (w
->buffer
) && !NILP (BVAR (XBUFFER (w
->buffer
), name
)))
5619 /* Keep window's old buffer; make sure the markers are
5622 /* Set window markers at start of visible range. */
5623 if (XMARKER (w
->start
)->buffer
== 0)
5624 set_marker_restricted (w
->start
, make_number (0),
5626 if (XMARKER (w
->pointm
)->buffer
== 0)
5627 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5628 BUF_PT (XBUFFER (w
->buffer
)),
5629 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5630 w
->start_at_line_beg
= Qt
;
5632 else if (STRINGP (auto_buffer_name
=
5633 Fwindow_parameter (window
, Qauto_buffer_name
))
5634 && SCHARS (auto_buffer_name
) != 0
5635 && !NILP (w
->buffer
= Fget_buffer_create (auto_buffer_name
)))
5637 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5638 set_marker_restricted (w
->pointm
, make_number (0), w
->buffer
);
5639 w
->start_at_line_beg
= Qt
;
5642 /* Window has no live buffer, get one. */
5644 /* Get the buffer via other_buffer_safely in order to
5645 avoid showing an unimportant buffer and, if necessary, to
5646 recreate *scratch* in the course (part of Juanma's bs-show
5647 scenario from March 2011). */
5648 w
->buffer
= other_buffer_safely (Fcurrent_buffer ());
5649 /* This will set the markers to beginning of visible
5651 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5652 set_marker_restricted (w
->pointm
, make_number (0), w
->buffer
);
5653 w
->start_at_line_beg
= Qt
;
5654 if (!NILP (w
->dedicated
))
5655 /* Record this window as dead. */
5656 dead_windows
= Fcons (window
, dead_windows
);
5657 /* Make sure window is no more dedicated. */
5658 w
->dedicated
= Qnil
;
5662 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5663 /* Arrange *not* to restore point in the buffer that was
5664 current when the window configuration was saved. */
5665 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5666 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5667 make_number (old_point
),
5668 XWINDOW (data
->current_window
)->buffer
);
5670 /* In the following call to `select-window', prevent "swapping out
5671 point" in the old selected window using the buffer that has
5672 been restored into it. We already swapped out that point from
5673 that window's old buffer. */
5674 select_window (data
->current_window
, Qnil
, 1);
5675 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5678 if (NILP (data
->focus_frame
)
5679 || (FRAMEP (data
->focus_frame
)
5680 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5681 Fredirect_frame_focus (frame
, data
->focus_frame
);
5683 /* Set the screen height to the value it had before this function. */
5684 if (previous_frame_lines
!= FRAME_LINES (f
)
5685 || previous_frame_cols
!= FRAME_COLS (f
))
5686 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5688 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5689 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5690 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5692 #ifdef HAVE_WINDOW_SYSTEM
5693 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5694 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5699 /* Now, free glyph matrices in windows that were not reused. */
5700 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5702 if (NILP (leaf_windows
[i
]->buffer
))
5704 /* Assert it's not reused as a combination. */
5705 xassert (NILP (leaf_windows
[i
]->hchild
)
5706 && NILP (leaf_windows
[i
]->vchild
));
5707 free_window_matrices (leaf_windows
[i
]);
5709 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5716 /* Scan dead buffer windows. */
5717 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5719 window
= XCAR (dead_windows
);
5720 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5721 delete_deletable_window (window
);
5724 /* Fselect_window will have made f the selected frame, so we
5725 reselect the proper frame here. Fhandle_switch_frame will change the
5726 selected window too, but that doesn't make the call to
5727 Fselect_window above totally superfluous; it still sets f's
5729 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5730 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5732 run_window_configuration_change_hook (f
);
5735 if (!NILP (new_current_buffer
))
5736 Fset_buffer (new_current_buffer
);
5738 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5739 minibuf_selected_window
= data
->minibuf_selected_window
;
5741 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5745 /* Delete all subwindows reachable via the next, vchild, and hchild
5748 delete_all_subwindows (Lisp_Object window
)
5750 register struct window
*w
;
5752 w
= XWINDOW (window
);
5754 if (!NILP (w
->next
))
5755 /* Delete WINDOW's siblings (we traverse postorderly). */
5756 delete_all_subwindows (w
->next
);
5758 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5760 if (!NILP (w
->vchild
))
5762 delete_all_subwindows (w
->vchild
);
5765 else if (!NILP (w
->hchild
))
5767 delete_all_subwindows (w
->hchild
);
5770 else if (!NILP (w
->buffer
))
5773 unchain_marker (XMARKER (w
->pointm
));
5774 unchain_marker (XMARKER (w
->start
));
5778 Vwindow_list
= Qnil
;
5782 count_windows (register struct window
*window
)
5784 register int count
= 1;
5785 if (!NILP (window
->next
))
5786 count
+= count_windows (XWINDOW (window
->next
));
5787 if (!NILP (window
->vchild
))
5788 count
+= count_windows (XWINDOW (window
->vchild
));
5789 if (!NILP (window
->hchild
))
5790 count
+= count_windows (XWINDOW (window
->hchild
));
5795 /* Fill vector FLAT with leaf windows under W, starting at index I.
5796 Value is last index + 1. */
5798 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5802 if (!NILP (w
->hchild
))
5803 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5804 else if (!NILP (w
->vchild
))
5805 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5809 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5816 /* Return a pointer to the glyph W's physical cursor is on. Value is
5817 null if W's current matrix is invalid, so that no meaningfull glyph
5820 get_phys_cursor_glyph (struct window
*w
)
5822 struct glyph_row
*row
;
5823 struct glyph
*glyph
;
5825 if (w
->phys_cursor
.vpos
>= 0
5826 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5827 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5829 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5830 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5839 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
5841 register struct saved_window
*p
;
5842 register struct window
*w
;
5843 register Lisp_Object tem
;
5845 for (;!NILP (window
); window
= w
->next
)
5847 p
= SAVED_WINDOW_N (vector
, i
);
5848 w
= XWINDOW (window
);
5850 XSETFASTINT (w
->temslot
, i
); i
++;
5852 p
->buffer
= w
->buffer
;
5853 p
->left_col
= w
->left_col
;
5854 p
->top_line
= w
->top_line
;
5855 p
->total_cols
= w
->total_cols
;
5856 p
->total_lines
= w
->total_lines
;
5857 p
->normal_cols
= w
->normal_cols
;
5858 p
->normal_lines
= w
->normal_lines
;
5859 p
->hscroll
= w
->hscroll
;
5860 p
->min_hscroll
= w
->min_hscroll
;
5861 p
->display_table
= w
->display_table
;
5862 p
->left_margin_cols
= w
->left_margin_cols
;
5863 p
->right_margin_cols
= w
->right_margin_cols
;
5864 p
->left_fringe_width
= w
->left_fringe_width
;
5865 p
->right_fringe_width
= w
->right_fringe_width
;
5866 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
5867 p
->scroll_bar_width
= w
->scroll_bar_width
;
5868 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5869 p
->dedicated
= w
->dedicated
;
5870 p
->splits
= w
->splits
;
5872 p
->window_parameters
= w
->window_parameters
;
5873 if (!NILP (w
->buffer
))
5875 /* Save w's value of point in the window configuration.
5876 If w is the selected window, then get the value of point
5877 from the buffer; pointm is garbage in the selected window. */
5878 if (EQ (window
, selected_window
))
5880 p
->pointm
= Fmake_marker ();
5881 set_marker_both (p
->pointm
, w
->buffer
,
5882 BUF_PT (XBUFFER (w
->buffer
)),
5883 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5886 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5888 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5889 p
->start_at_line_beg
= w
->start_at_line_beg
;
5891 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
5892 p
->mark
= Fcopy_marker (tem
, Qnil
);
5899 p
->start_at_line_beg
= Qnil
;
5902 if (NILP (w
->parent
))
5905 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5910 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5912 if (!NILP (w
->vchild
))
5913 i
= save_window_save (w
->vchild
, vector
, i
);
5914 if (!NILP (w
->hchild
))
5915 i
= save_window_save (w
->hchild
, vector
, i
);
5921 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5922 Scurrent_window_configuration
, 0, 1, 0,
5923 doc
: /* Return an object representing the current window configuration of FRAME.
5924 If FRAME is nil or omitted, use the selected frame.
5925 This describes the number of windows, their sizes and current buffers,
5926 and for each displayed buffer, where display starts, and the positions of
5927 point and mark. An exception is made for point in the current buffer:
5928 its value is -not- saved.
5929 This also records the currently selected frame, and FRAME's focus
5930 redirection (see `redirect-frame-focus'). */)
5933 register Lisp_Object tem
;
5934 register int n_windows
;
5935 register struct save_window_data
*data
;
5940 frame
= selected_frame
;
5941 CHECK_LIVE_FRAME (frame
);
5944 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5945 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
5946 PVEC_WINDOW_CONFIGURATION
);
5948 data
->frame_cols
= FRAME_COLS (f
);
5949 data
->frame_lines
= FRAME_LINES (f
);
5950 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5951 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5952 data
->selected_frame
= selected_frame
;
5953 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5954 XSETBUFFER (data
->current_buffer
, current_buffer
);
5955 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
5956 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
5957 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5958 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5959 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5960 data
->saved_windows
= tem
;
5961 for (i
= 0; i
< n_windows
; i
++)
5962 XVECTOR (tem
)->contents
[i
]
5963 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
5964 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5965 XSETWINDOW_CONFIGURATION (tem
, data
);
5969 /***********************************************************************
5971 ***********************************************************************/
5973 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5975 doc
: /* Set width of marginal areas of window WINDOW.
5976 If WINDOW is nil, set margins of the currently selected window.
5977 Second arg LEFT-WIDTH specifies the number of character cells to
5978 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
5979 does the same for the right marginal area. A nil width parameter
5980 means no margin. */)
5981 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
5983 struct window
*w
= decode_window (window
);
5985 /* Translate negative or zero widths to nil.
5986 Margins that are too wide have to be checked elsewhere. */
5988 if (!NILP (left_width
))
5990 CHECK_NUMBER (left_width
);
5991 if (XINT (left_width
) <= 0)
5995 if (!NILP (right_width
))
5997 CHECK_NUMBER (right_width
);
5998 if (XINT (right_width
) <= 0)
6002 if (!EQ (w
->left_margin_cols
, left_width
)
6003 || !EQ (w
->right_margin_cols
, right_width
))
6005 w
->left_margin_cols
= left_width
;
6006 w
->right_margin_cols
= right_width
;
6008 adjust_window_margins (w
);
6010 ++windows_or_buffers_changed
;
6011 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6018 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6020 doc
: /* Get width of marginal areas of window WINDOW.
6021 If WINDOW is omitted or nil, use the currently selected window.
6022 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6023 If a marginal area does not exist, its width will be returned
6025 (Lisp_Object window
)
6027 struct window
*w
= decode_window (window
);
6028 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6033 /***********************************************************************
6035 ***********************************************************************/
6037 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6039 doc
: /* Set the fringe widths of window WINDOW.
6040 If WINDOW is nil, set the fringe widths of the currently selected
6042 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6043 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6044 fringe width. If a fringe width arg is nil, that means to use the
6045 frame's default fringe width. Default fringe widths can be set with
6046 the command `set-fringe-style'.
6047 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6048 outside of the display margins. By default, fringes are drawn between
6049 display marginal areas and the text area. */)
6050 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6052 struct window
*w
= decode_window (window
);
6054 if (!NILP (left_width
))
6055 CHECK_NATNUM (left_width
);
6056 if (!NILP (right_width
))
6057 CHECK_NATNUM (right_width
);
6059 /* Do nothing on a tty. */
6060 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6061 && (!EQ (w
->left_fringe_width
, left_width
)
6062 || !EQ (w
->right_fringe_width
, right_width
)
6063 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6065 w
->left_fringe_width
= left_width
;
6066 w
->right_fringe_width
= right_width
;
6067 w
->fringes_outside_margins
= outside_margins
;
6069 adjust_window_margins (w
);
6071 clear_glyph_matrix (w
->current_matrix
);
6072 w
->window_end_valid
= Qnil
;
6074 ++windows_or_buffers_changed
;
6075 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6082 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6084 doc
: /* Get width of fringes of window WINDOW.
6085 If WINDOW is omitted or nil, use the currently selected window.
6086 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6087 (Lisp_Object window
)
6089 struct window
*w
= decode_window (window
);
6091 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6092 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6093 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6094 ? Qt
: Qnil
), Qnil
)));
6099 /***********************************************************************
6101 ***********************************************************************/
6103 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6104 Sset_window_scroll_bars
, 2, 4, 0,
6105 doc
: /* Set width and type of scroll bars of window WINDOW.
6106 If window is nil, set scroll bars of the currently selected window.
6107 Second parameter WIDTH specifies the pixel width for the scroll bar;
6108 this is automatically adjusted to a multiple of the frame column width.
6109 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6110 bar: left, right, or nil.
6111 If WIDTH is nil, use the frame's scroll-bar width.
6112 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6113 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6114 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6116 struct window
*w
= decode_window (window
);
6120 CHECK_RANGED_INTEGER (0, width
, INT_MAX
);
6122 if (XINT (width
) == 0)
6123 vertical_type
= Qnil
;
6126 if (!(NILP (vertical_type
)
6127 || EQ (vertical_type
, Qleft
)
6128 || EQ (vertical_type
, Qright
)
6129 || EQ (vertical_type
, Qt
)))
6130 error ("Invalid type of vertical scroll bar");
6132 if (!EQ (w
->scroll_bar_width
, width
)
6133 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6135 w
->scroll_bar_width
= width
;
6136 w
->vertical_scroll_bar_type
= vertical_type
;
6138 adjust_window_margins (w
);
6140 clear_glyph_matrix (w
->current_matrix
);
6141 w
->window_end_valid
= Qnil
;
6143 ++windows_or_buffers_changed
;
6144 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6151 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6153 doc
: /* Get width and type of scroll bars of window WINDOW.
6154 If WINDOW is omitted or nil, use the currently selected window.
6155 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6156 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6158 (Lisp_Object window
)
6160 struct window
*w
= decode_window (window
);
6161 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6162 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6163 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6164 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6165 Fcons (w
->vertical_scroll_bar_type
,
6166 Fcons (Qnil
, Qnil
))));
6171 /***********************************************************************
6173 ***********************************************************************/
6175 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6176 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6177 Use the selected window if WINDOW is nil or omitted.
6178 Normally, value is a multiple of the canonical character height of WINDOW;
6179 optional second arg PIXELS-P means value is measured in pixels. */)
6180 (Lisp_Object window
, Lisp_Object pixels_p
)
6187 window
= selected_window
;
6189 CHECK_WINDOW (window
);
6190 w
= XWINDOW (window
);
6191 f
= XFRAME (w
->frame
);
6193 if (FRAME_WINDOW_P (f
))
6194 result
= (NILP (pixels_p
)
6195 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6196 : make_number (-w
->vscroll
));
6198 result
= make_number (0);
6203 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6205 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6206 WINDOW nil means use the selected window. Normally, VSCROLL is a
6207 non-negative multiple of the canonical character height of WINDOW;
6208 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6209 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6210 corresponds to an integral number of pixels. The return value is the
6211 result of this rounding.
6212 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6213 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6219 window
= selected_window
;
6221 CHECK_WINDOW (window
);
6222 CHECK_NUMBER_OR_FLOAT (vscroll
);
6224 w
= XWINDOW (window
);
6225 f
= XFRAME (w
->frame
);
6227 if (FRAME_WINDOW_P (f
))
6229 int old_dy
= w
->vscroll
;
6231 w
->vscroll
= - (NILP (pixels_p
)
6232 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6233 : XFLOATINT (vscroll
));
6234 w
->vscroll
= min (w
->vscroll
, 0);
6236 if (w
->vscroll
!= old_dy
)
6238 /* Adjust glyph matrix of the frame if the virtual display
6239 area becomes larger than before. */
6240 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6243 /* Prevent redisplay shortcuts. */
6244 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6248 return Fwindow_vscroll (window
, pixels_p
);
6252 /* Call FN for all leaf windows on frame F. FN is called with the
6253 first argument being a pointer to the leaf window, and with
6254 additional argument USER_DATA. Stops when FN returns 0. */
6257 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6260 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6261 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6262 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6266 /* Helper function for foreach_window. Call FN for all leaf windows
6267 reachable from W. FN is called with the first argument being a
6268 pointer to the leaf window, and with additional argument USER_DATA.
6269 Stop when FN returns 0. Value is 0 if stopped by FN. */
6272 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6276 for (cont
= 1; w
&& cont
;)
6278 if (!NILP (w
->hchild
))
6279 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6280 else if (!NILP (w
->vchild
))
6281 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6283 cont
= fn (w
, user_data
);
6285 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6292 /* Freeze or unfreeze the window start of W unless it is a
6293 mini-window or the selected window. FREEZE_P non-null means freeze
6294 the window start. */
6297 freeze_window_start (struct window
*w
, void *freeze_p
)
6299 if (MINI_WINDOW_P (w
)
6300 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6301 && (w
== XWINDOW (selected_window
)
6302 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6303 && ! NILP (Vminibuf_scroll_window
)
6304 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6307 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6312 /* Freeze or unfreeze the window starts of all leaf windows on frame
6313 F, except the selected window and a mini-window. FREEZE_P non-zero
6314 means freeze the window start. */
6317 freeze_window_starts (struct frame
*f
, int freeze_p
)
6319 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6323 /***********************************************************************
6325 ***********************************************************************/
6327 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6328 describe the same state of affairs. This is used by Fequal.
6330 ignore_positions non-zero means ignore non-matching scroll positions
6333 This ignores a couple of things like the dedicatedness status of
6334 window, splits, nest and the like. This might have to be fixed. */
6337 compare_window_configurations (Lisp_Object configuration1
, Lisp_Object configuration2
, int ignore_positions
)
6339 register struct save_window_data
*d1
, *d2
;
6340 struct Lisp_Vector
*sws1
, *sws2
;
6343 CHECK_WINDOW_CONFIGURATION (configuration1
);
6344 CHECK_WINDOW_CONFIGURATION (configuration2
);
6346 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6347 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6348 sws1
= XVECTOR (d1
->saved_windows
);
6349 sws2
= XVECTOR (d2
->saved_windows
);
6351 /* Frame settings must match. */
6352 if (d1
->frame_cols
!= d2
->frame_cols
6353 || d1
->frame_lines
!= d2
->frame_lines
6354 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6355 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6356 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6357 || (!ignore_positions
6358 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6359 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6360 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6361 /* Verify that the two configurations have the same number of windows. */
6362 || sws1
->header
.size
!= sws2
->header
.size
)
6365 for (i
= 0; i
< sws1
->header
.size
; i
++)
6367 struct saved_window
*sw1
, *sw2
;
6369 sw1
= SAVED_WINDOW_N (sws1
, i
);
6370 sw2
= SAVED_WINDOW_N (sws2
, i
);
6373 /* The "current" windows in the two configurations must
6374 correspond to each other. */
6375 EQ (d1
->current_window
, sw1
->window
)
6376 != EQ (d2
->current_window
, sw2
->window
)
6377 /* Windows' buffers must match. */
6378 || !EQ (sw1
->buffer
, sw2
->buffer
)
6379 || !EQ (sw1
->left_col
, sw2
->left_col
)
6380 || !EQ (sw1
->top_line
, sw2
->top_line
)
6381 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6382 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6383 || !EQ (sw1
->display_table
, sw2
->display_table
)
6384 /* The next two disjuncts check the window structure for
6386 || !EQ (sw1
->parent
, sw2
->parent
)
6387 || !EQ (sw1
->prev
, sw2
->prev
)
6388 || (!ignore_positions
6389 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6390 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6391 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6392 || NILP (Fequal (sw1
->start
, sw2
->start
))
6393 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6394 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6395 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6396 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6397 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6398 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6399 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6400 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6401 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6408 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6409 Scompare_window_configurations
, 2, 2, 0,
6410 doc
: /* Compare two window configurations as regards the structure of windows.
6411 This function ignores details such as the values of point and mark
6412 and scrolling positions. */)
6413 (Lisp_Object x
, Lisp_Object y
)
6415 if (compare_window_configurations (x
, y
, 1))
6421 init_window_once (void)
6423 struct frame
*f
= make_initial_frame ();
6424 XSETFRAME (selected_frame
, f
);
6425 Vterminal_frame
= selected_frame
;
6426 minibuf_window
= f
->minibuffer_window
;
6427 selected_window
= f
->selected_window
;
6428 last_nonminibuf_frame
= f
;
6430 window_initialized
= 1;
6436 Vwindow_list
= Qnil
;
6440 syms_of_window (void)
6442 DEFSYM (Qscroll_up
, "scroll-up");
6443 DEFSYM (Qscroll_down
, "scroll-down");
6444 DEFSYM (Qscroll_command
, "scroll-command");
6446 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6447 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6449 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6450 DEFSYM (Qwindowp
, "windowp");
6451 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6452 DEFSYM (Qwindow_live_p
, "window-live-p");
6453 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6454 DEFSYM (Qdelete_window
, "delete-window");
6455 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6456 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6457 DEFSYM (Qsafe
, "safe");
6458 DEFSYM (Qdisplay_buffer
, "display-buffer");
6459 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6460 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6461 DEFSYM (Qget_mru_window
, "get-mru-window");
6462 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6463 DEFSYM (Qabove
, "above");
6464 DEFSYM (Qbelow
, "below");
6465 DEFSYM (Qauto_buffer_name
, "auto-buffer-name");
6467 staticpro (&Vwindow_list
);
6469 minibuf_selected_window
= Qnil
;
6470 staticpro (&minibuf_selected_window
);
6472 window_scroll_pixel_based_preserve_x
= -1;
6473 window_scroll_pixel_based_preserve_y
= -1;
6474 window_scroll_preserve_hpos
= -1;
6475 window_scroll_preserve_vpos
= -1;
6477 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6478 doc
: /* Non-nil means call as function to display a help buffer.
6479 The function is called with one argument, the buffer to be displayed.
6480 Used by `with-output-to-temp-buffer'.
6481 If this function is used, then it must do the entire job of showing
6482 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6483 Vtemp_buffer_show_function
= Qnil
;
6485 DEFVAR_LISP ("temp-buffer-show-specifiers", Vtemp_buffer_show_specifiers
,
6486 doc
: /* Buffer display specifiers used by `with-output-to-temp-buffer'.
6487 These specifiers are passed by `with-output-to-temp-buffer' as second
6488 argument to `display-buffer'. Applications should only let-bind this
6489 around a call to `with-output-to-temp-buffer'.
6491 For a description of buffer display specifiers see the variable
6492 `display-buffer-alist'. */);
6493 Vtemp_buffer_show_specifiers
= Qnil
;
6495 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6496 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6497 Vminibuf_scroll_window
= Qnil
;
6499 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6500 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6501 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6502 is displayed in the `mode-line' face. */);
6503 mode_line_in_non_selected_windows
= 1;
6505 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6506 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6507 Vother_window_scroll_buffer
= Qnil
;
6509 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6510 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6511 auto_window_vscroll_p
= 1;
6513 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6514 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6515 next_screen_context_lines
= 2;
6517 DEFVAR_LISP ("scroll-preserve-screen-position",
6518 Vscroll_preserve_screen_position
,
6519 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6520 A value of nil means point does not keep its screen position except
6521 at the scroll margin or window boundary respectively.
6522 A value of t means point keeps its screen position if the scroll
6523 command moved it vertically out of the window, e.g. when scrolling
6525 Any other value means point always keeps its screen position.
6526 Scroll commands should have the `scroll-command' property
6527 on their symbols to be controlled by this variable. */);
6528 Vscroll_preserve_screen_position
= Qnil
;
6530 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6531 doc
: /* Type of marker to use for `window-point'. */);
6532 Vwindow_point_insertion_type
= Qnil
;
6534 DEFVAR_LISP ("window-configuration-change-hook",
6535 Vwindow_configuration_change_hook
,
6536 doc
: /* Functions to call when window configuration changes.
6537 The buffer-local part is run once per window, with the relevant window
6538 selected; while the global part is run only once for the modified frame,
6539 with the relevant frame selected. */);
6540 Vwindow_configuration_change_hook
= Qnil
;
6542 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6543 doc
: /* If non-nil, then the `recenter' command with a nil argument
6544 will redraw the entire frame; the special value `tty' causes the
6545 frame to be redrawn only if it is a tty frame. */);
6546 Vrecenter_redisplay
= Qtty
;
6548 DEFVAR_LISP ("window-splits", Vwindow_splits
,
6549 doc
: /* Non-nil means splitting windows is handled specially.
6550 If this variable is nil, splitting a window gets the entire screen space
6551 for displaying the new window from the window to split. If this
6552 variable is non-nil, splitting a window may resize all windows in the
6553 same combination. This also allows to split a window that is otherwise
6554 too small or of fixed size.
6556 The value of this variable is also assigned to the split status of the
6557 new window and, provided the old and new window form a new combination,
6558 to the window that was split as well. The split status of a window can
6559 be retrieved with the function `window-splits' and altered by the
6560 function `set-window-splits'.
6562 If the value of the variable `window-nest' is non-nil, the space for the
6563 new window is exclusively taken from the window that shall be split, but
6564 the split status of the window that is split as well as that of the new
6565 window are still set to the value of this variable. */);
6566 Vwindow_splits
= Qnil
;
6568 DEFVAR_LISP ("window-nest", Vwindow_nest
,
6569 doc
: /* Non-nil means splitting a window makes a new parent window.
6570 If this variable is nil, splitting a window will create a new parent
6571 window only if the window has no parent window or the window shall
6572 become a combination orthogonal to the one it it is part of.
6574 If this variable is non-nil, splitting a window always creates a new
6575 parent window. If all splits behave this way, each frame's window tree
6576 is a binary tree and every window but the frame's root window has
6577 exactly one sibling.
6579 The value of this variable is also assigned to the nest status of the
6580 new parent window. The nest status of a window can be retrieved via the
6581 function `window-nest' and altered by the function `set-window-nest'. */);
6582 Vwindow_nest
= Qnil
;
6584 defsubr (&Sselected_window
);
6585 defsubr (&Sminibuffer_window
);
6586 defsubr (&Swindow_minibuffer_p
);
6587 defsubr (&Swindowp
);
6588 defsubr (&Swindow_live_p
);
6589 defsubr (&Swindow_frame
);
6590 defsubr (&Sframe_root_window
);
6591 defsubr (&Sframe_first_window
);
6592 defsubr (&Sframe_selected_window
);
6593 defsubr (&Sset_frame_selected_window
);
6594 defsubr (&Spos_visible_in_window_p
);
6595 defsubr (&Swindow_line_height
);
6596 defsubr (&Swindow_buffer
);
6597 defsubr (&Swindow_parent
);
6598 defsubr (&Swindow_top_child
);
6599 defsubr (&Swindow_left_child
);
6600 defsubr (&Swindow_next_sibling
);
6601 defsubr (&Swindow_prev_sibling
);
6602 defsubr (&Swindow_splits
);
6603 defsubr (&Sset_window_splits
);
6604 defsubr (&Swindow_nest
);
6605 defsubr (&Sset_window_nest
);
6606 defsubr (&Swindow_use_time
);
6607 defsubr (&Swindow_top_line
);
6608 defsubr (&Swindow_left_column
);
6609 defsubr (&Swindow_total_size
);
6610 defsubr (&Swindow_normal_size
);
6611 defsubr (&Swindow_new_total
);
6612 defsubr (&Swindow_new_normal
);
6613 defsubr (&Sset_window_new_total
);
6614 defsubr (&Sset_window_new_normal
);
6615 defsubr (&Swindow_resize_apply
);
6616 defsubr (&Swindow_body_size
);
6617 defsubr (&Swindow_hscroll
);
6618 defsubr (&Sset_window_hscroll
);
6619 defsubr (&Swindow_redisplay_end_trigger
);
6620 defsubr (&Sset_window_redisplay_end_trigger
);
6621 defsubr (&Swindow_edges
);
6622 defsubr (&Swindow_pixel_edges
);
6623 defsubr (&Swindow_absolute_pixel_edges
);
6624 defsubr (&Swindow_inside_edges
);
6625 defsubr (&Swindow_inside_pixel_edges
);
6626 defsubr (&Swindow_inside_absolute_pixel_edges
);
6627 defsubr (&Scoordinates_in_window_p
);
6628 defsubr (&Swindow_at
);
6629 defsubr (&Swindow_point
);
6630 defsubr (&Swindow_start
);
6631 defsubr (&Swindow_end
);
6632 defsubr (&Sset_window_point
);
6633 defsubr (&Sset_window_start
);
6634 defsubr (&Swindow_dedicated_p
);
6635 defsubr (&Sset_window_dedicated_p
);
6636 defsubr (&Swindow_display_table
);
6637 defsubr (&Sset_window_display_table
);
6638 defsubr (&Snext_window
);
6639 defsubr (&Sprevious_window
);
6640 defsubr (&Sget_buffer_window
);
6641 defsubr (&Sdelete_other_windows_internal
);
6642 defsubr (&Sdelete_window_internal
);
6643 defsubr (&Sresize_mini_window_internal
);
6644 defsubr (&Sset_window_buffer
);
6645 defsubr (&Srun_window_configuration_change_hook
);
6646 defsubr (&Sselect_window
);
6647 defsubr (&Sforce_window_update
);
6648 defsubr (&Stemp_output_buffer_show
);
6649 defsubr (&Ssplit_window_internal
);
6650 defsubr (&Sscroll_up
);
6651 defsubr (&Sscroll_down
);
6652 defsubr (&Sscroll_left
);
6653 defsubr (&Sscroll_right
);
6654 defsubr (&Sother_window_for_scrolling
);
6655 defsubr (&Sscroll_other_window
);
6656 defsubr (&Sminibuffer_selected_window
);
6657 defsubr (&Srecenter
);
6658 defsubr (&Swindow_text_height
);
6659 defsubr (&Smove_to_window_line
);
6660 defsubr (&Swindow_configuration_p
);
6661 defsubr (&Swindow_configuration_frame
);
6662 defsubr (&Sset_window_configuration
);
6663 defsubr (&Scurrent_window_configuration
);
6664 defsubr (&Sset_window_margins
);
6665 defsubr (&Swindow_margins
);
6666 defsubr (&Sset_window_fringes
);
6667 defsubr (&Swindow_fringes
);
6668 defsubr (&Sset_window_scroll_bars
);
6669 defsubr (&Swindow_scroll_bars
);
6670 defsubr (&Swindow_vscroll
);
6671 defsubr (&Sset_window_vscroll
);
6672 defsubr (&Scompare_window_configurations
);
6673 defsubr (&Swindow_list
);
6674 defsubr (&Swindow_list_1
);
6675 defsubr (&Swindow_prev_buffers
);
6676 defsubr (&Sset_window_prev_buffers
);
6677 defsubr (&Swindow_next_buffers
);
6678 defsubr (&Sset_window_next_buffers
);
6679 defsubr (&Swindow_parameters
);
6680 defsubr (&Swindow_parameter
);
6681 defsubr (&Sset_window_parameter
);
6685 keys_of_window (void)
6687 initial_define_key (control_x_map
, '<', "scroll-left");
6688 initial_define_key (control_x_map
, '>', "scroll-right");
6690 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6691 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6692 initial_define_key (meta_map
, 'v', "scroll-down-command");