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 Qresize_root_window
, Qresize_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
, 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 resize_window_check (struct window
*, int);
86 static void resize_window_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 int window_scroll_preserve_hpos
;
131 static 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 EMACS_INT 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-clone-number", Fwindow_clone_number
, Swindow_clone_number
, 0, 1, 0,
412 doc
: /* Return WINDOW's clone number.
413 WINDOW can be any window and defaults to the selected one. */)
416 return decode_any_window (window
)->clone_number
;
419 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
420 doc
: /* Return the buffer that WINDOW is displaying.
421 WINDOW can be any window and defaults to the selected one.
422 If WINDOW is an internal window return nil. */)
425 return decode_any_window (window
)->buffer
;
428 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
429 doc
: /* Return WINDOW's parent window.
430 WINDOW can be any window and defaults to the selected one.
431 Return nil if WINDOW has no parent. */)
434 return decode_any_window (window
)->parent
;
437 DEFUN ("window-vchild", Fwindow_vchild
, Swindow_vchild
, 0, 1, 0,
438 doc
: /* Return WINDOW's first vertical child window.
439 WINDOW can be any window and defaults to the selected one.
440 Return nil if WINDOW has no vertical child. */)
443 return decode_any_window (window
)->vchild
;
446 DEFUN ("window-hchild", Fwindow_hchild
, Swindow_hchild
, 0, 1, 0,
447 doc
: /* Return WINDOW's first horizontal child window.
448 WINDOW can be any window and defaults to the selected one.
449 Return nil if WINDOW has no horizontal child. */)
452 return decode_any_window (window
)->hchild
;
455 DEFUN ("window-next", Fwindow_next
, Swindow_next
, 0, 1, 0,
456 doc
: /* Return WINDOW's right sibling window.
457 WINDOW can be any window and defaults to the selected one.
458 Return nil if WINDOW has no right sibling. */)
461 return decode_any_window (window
)->next
;
464 DEFUN ("window-prev", Fwindow_prev
, Swindow_prev
, 0, 1, 0,
465 doc
: /* Return WINDOW's left sibling window.
466 WINDOW can be any window and defaults to the selected one.
467 Return nil if WINDOW has no left sibling. */)
470 return decode_any_window (window
)->prev
;
473 DEFUN ("window-splits", Fwindow_splits
, Swindow_splits
, 0, 1, 0,
474 doc
: /* Return splits status for WINDOW.
475 WINDOW can be any window and defaults to the selected one.
477 If the value returned by this function is nil and WINDOW is resized, the
478 corresponding space is preferably taken from (or given to) WINDOW's
479 right sibling. When WINDOW is deleted, its space is given to its left
482 If the value returned by this function is non-nil, resizing and deleting
483 WINDOW may resize all windows in the same combination. */)
486 return decode_any_window (window
)->splits
;
489 DEFUN ("set-window-splits", Fset_window_splits
, Sset_window_splits
, 2, 2, 0,
490 doc
: /* Set splits status of WINDOW to STATUS.
491 WINDOW can be any window and defaults to the selected one. Return
494 If STATUS is nil and WINDOW is later resized, the corresponding space is
495 preferably taken from (or given to) WINDOW's right sibling. When WINDOW
496 is deleted, its space is given to its left sibling.
498 If STATUS is non-nil, resizing and deleting WINDOW may resize all
499 windows in the same combination. */)
500 (Lisp_Object window
, Lisp_Object status
)
502 register struct window
*w
= decode_any_window (window
);
509 DEFUN ("window-nest", Fwindow_nest
, Swindow_nest
, 0, 1, 0,
510 doc
: /* Return nest status of WINDOW.
511 WINDOW can be any window and defaults to the selected one.
513 If the return value is nil, subwindows of WINDOW can be recombined with
514 WINDOW's siblings. A return value of non-nil means that subwindows of
515 WINDOW are never \(re-)combined with WINDOW's siblings. */)
518 return decode_any_window (window
)->nest
;
521 DEFUN ("set-window-nest", Fset_window_nest
, Sset_window_nest
, 2, 2, 0,
522 doc
: /* Set nest status of WINDOW to STATUS.
523 WINDOW can be any window and defaults to the selected one. Return
526 If STATUS is nil, subwindows of WINDOW can be recombined with WINDOW's
527 siblings. STATUS non-nil means that subwindows of WINDOW are never
528 \(re-)combined with WINDOW's siblings. */)
529 (Lisp_Object window
, Lisp_Object status
)
531 register struct window
*w
= decode_any_window (window
);
538 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
539 doc
: /* Return WINDOW's use time.
540 WINDOW defaults to the selected window. The window with the highest use
541 time is the most recently selected one. The window with the lowest use
542 time is the least recently selected one. */)
545 return decode_window (window
)->use_time
;
548 DEFUN ("window-total-size", Fwindow_total_size
, Swindow_total_size
, 0, 2, 0,
549 doc
: /* Return the total number of lines of WINDOW.
550 WINDOW can be any window and defaults to the selected one. The return
551 value includes WINDOW's mode line and header line, if any. If WINDOW
552 is internal, the return value is the sum of the total number of lines
553 of WINDOW's child windows if these are vertically combined and the
554 height of WINDOW's first child otherwise.
556 Optional argument HORIZONTAL non-nil means return the total number of
557 columns of WINDOW. In this case the return value includes any vertical
558 dividers or scrollbars of WINDOW. If WINDOW is internal, the return
559 value is the sum of the total number of columns of WINDOW's child
560 windows if they are horizontally combined and the width of WINDOW's
561 first child otherwise. */)
562 (Lisp_Object window
, Lisp_Object horizontal
)
564 if (NILP (horizontal
))
565 return decode_any_window (window
)->total_lines
;
567 return decode_any_window (window
)->total_cols
;
570 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
571 doc
: /* Return new total size of WINDOW.
572 WINDOW defaults to the selected window. */)
575 return decode_any_window (window
)->new_total
;
578 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
579 doc
: /* Return normal height of WINDOW.
580 WINDOW can be any window and defaults to the selected one. Optional
581 argument HORIZONTAL non-nil means return normal width of WINDOW. */)
582 (Lisp_Object window
, Lisp_Object horizontal
)
584 if (NILP (horizontal
))
585 return decode_any_window (window
)->normal_lines
;
587 return decode_any_window (window
)->normal_cols
;
590 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
591 doc
: /* Return new normal size of WINDOW.
592 WINDOW can be any window and defaults to the selected one. */)
595 return decode_any_window (window
)->new_normal
;
598 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
599 doc
: /* Return left column of WINDOW.
600 WINDOW can be any window and defaults to the selected one. */)
603 return decode_any_window (window
)->left_col
;
606 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
607 doc
: /* Return top line of WINDOW.
608 WINDOW can be any window and defaults to the selected one. */)
611 return decode_any_window (window
)->top_line
;
614 /* Return the number of lines of W's body. Don't count any mode or
618 window_body_lines (struct window
*w
)
620 int height
= XFASTINT (w
->total_lines
);
622 if (!MINI_WINDOW_P (w
))
624 if (WINDOW_WANTS_MODELINE_P (w
))
626 if (WINDOW_WANTS_HEADER_LINE_P (w
))
633 /* Return the number of columns of W's body. Don't count columns
634 occupied by the scroll bar or the vertical bar separating W from its
635 right sibling. On window-systems don't count fringes or display
639 window_body_cols (struct window
*w
)
641 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
642 int width
= XINT (w
->total_cols
);
644 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
645 /* Scroll bars occupy a few columns. */
646 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
647 else if (!FRAME_WINDOW_P (f
)
648 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
649 /* The column of `|' characters separating side-by-side windows
650 occupies one column only. */
653 if (FRAME_WINDOW_P (f
))
654 /* On window-systems, fringes and display margins cannot be
655 used for normal text. */
656 width
-= (WINDOW_FRINGE_COLS (w
)
657 + WINDOW_LEFT_MARGIN_COLS (w
)
658 + WINDOW_RIGHT_MARGIN_COLS (w
));
663 DEFUN ("window-body-size", Fwindow_body_size
, Swindow_body_size
, 0, 2, 0,
664 doc
: /* Return the number of lines of WINDOW's body.
665 WINDOW must be a live window and defaults to the selected one. The
666 return value does not include WINDOW's mode line and header line, if
669 Optional argument HORIZONTAL non-nil means return the number of columns
670 of WINDOW's body. In this case, the return value does not include any
671 vertical dividers or scroll bars owned by WINDOW. On a window-system
672 the return value does not include the number of columns used for
673 WINDOW's fringes or display margins either. */)
674 (Lisp_Object window
, Lisp_Object horizontal
)
676 struct window
*w
= decode_any_window (window
);
678 if (NILP (horizontal
))
679 return make_number (window_body_lines (w
));
681 return make_number (window_body_cols (w
));
684 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
685 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
686 WINDOW must be a live window and defaults to the selected one. */)
689 return decode_window (window
)->hscroll
;
692 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
693 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
694 Return NCOL. NCOL should be zero or positive.
696 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
697 window so that the location of point moves off-window. */)
698 (Lisp_Object window
, Lisp_Object ncol
)
700 struct window
*w
= decode_window (window
);
704 hscroll
= max (0, XINT (ncol
));
706 /* Prevent redisplay shortcuts when changing the hscroll. */
707 if (XINT (w
->hscroll
) != hscroll
)
708 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
710 w
->hscroll
= make_number (hscroll
);
714 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
715 Swindow_redisplay_end_trigger
, 0, 1, 0,
716 doc
: /* Return WINDOW's redisplay end trigger value.
717 WINDOW defaults to the selected window.
718 See `set-window-redisplay-end-trigger' for more information. */)
721 return decode_window (window
)->redisplay_end_trigger
;
724 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
725 Sset_window_redisplay_end_trigger
, 2, 2, 0,
726 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
727 VALUE should be a buffer position (typically a marker) or nil.
728 If it is a buffer position, then if redisplay in WINDOW reaches a position
729 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
730 with two arguments: WINDOW, and the end trigger value.
731 Afterwards the end-trigger value is reset to nil. */)
732 (register Lisp_Object window
, Lisp_Object value
)
734 register struct window
*w
;
736 w
= decode_window (window
);
737 w
->redisplay_end_trigger
= value
;
741 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
742 doc
: /* Return a list of the edge coordinates of WINDOW.
743 The list has the form (LEFT TOP RIGHT BOTTOM).
744 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
745 all relative to 0, 0 at top left corner of frame.
747 RIGHT is one more than the rightmost column occupied by WINDOW.
748 BOTTOM is one more than the bottommost row occupied by WINDOW.
749 The edges include the space used by WINDOW's scroll bar, display
750 margins, fringes, header line, and/or mode line. For the edges of
751 just the text area, use `window-inside-edges'. */)
754 register struct window
*w
= decode_any_window (window
);
756 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
757 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
758 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
759 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
763 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
764 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
765 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
766 the top left corner of the frame.
768 RIGHT is one more than the rightmost x position occupied by WINDOW.
769 BOTTOM is one more than the bottommost y position occupied by WINDOW.
770 The pixel edges include the space used by WINDOW's scroll bar, display
771 margins, fringes, header line, and/or mode line. For the pixel edges
772 of just the text area, use `window-inside-pixel-edges'. */)
775 register struct window
*w
= decode_any_window (window
);
777 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
778 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
779 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
780 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
785 calc_absolute_offset(struct window
*w
, int *add_x
, int *add_y
)
787 struct frame
*f
= XFRAME (w
->frame
);
789 #ifdef FRAME_MENUBAR_HEIGHT
790 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
792 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
793 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
794 #elif FRAME_TOOLBAR_HEIGHT
795 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
797 #ifdef FRAME_NS_TITLEBAR_HEIGHT
798 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
800 *add_x
= f
->left_pos
;
801 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
802 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
806 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
807 Swindow_absolute_pixel_edges
, 0, 1, 0,
808 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
809 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
810 the top left corner of the display.
812 RIGHT is one more than the rightmost x position occupied by WINDOW.
813 BOTTOM is one more than the bottommost y position occupied by WINDOW.
814 The pixel edges include the space used by WINDOW's scroll bar, display
815 margins, fringes, header line, and/or mode line. For the pixel edges
816 of just the text area, use `window-inside-absolute-pixel-edges'. */)
819 register struct window
*w
= decode_any_window (window
);
821 calc_absolute_offset (w
, &add_x
, &add_y
);
823 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
824 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
825 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
826 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
830 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
831 doc
: /* Return a list of the edge coordinates of WINDOW.
832 The list has the form (LEFT TOP RIGHT BOTTOM).
833 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
834 all relative to 0, 0 at top left corner of frame.
836 RIGHT is one more than the rightmost column of WINDOW's text area.
837 BOTTOM is one more than the bottommost row of WINDOW's text area.
838 The inside edges do not include the space used by the WINDOW's scroll
839 bar, display margins, fringes, header line, and/or mode line. */)
842 register struct window
*w
= decode_any_window (window
);
844 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
845 + WINDOW_LEFT_MARGIN_COLS (w
)
846 + WINDOW_LEFT_FRINGE_COLS (w
)),
847 make_number (WINDOW_TOP_EDGE_LINE (w
)
848 + WINDOW_HEADER_LINE_LINES (w
)),
849 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
850 - WINDOW_RIGHT_MARGIN_COLS (w
)
851 - WINDOW_RIGHT_FRINGE_COLS (w
)),
852 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
853 - WINDOW_MODE_LINE_LINES (w
)));
856 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
857 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
858 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
859 the top left corner of the frame.
861 RIGHT is one more than the rightmost x position of WINDOW's text area.
862 BOTTOM is one more than the bottommost y position of WINDOW's text area.
863 The inside edges do not include the space used by WINDOW's scroll bar,
864 display margins, fringes, header line, and/or mode line. */)
867 register struct window
*w
= decode_any_window (window
);
869 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
870 + WINDOW_LEFT_MARGIN_WIDTH (w
)
871 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
872 make_number (WINDOW_TOP_EDGE_Y (w
)
873 + WINDOW_HEADER_LINE_HEIGHT (w
)),
874 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
875 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
876 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
877 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
878 - WINDOW_MODE_LINE_HEIGHT (w
)));
881 DEFUN ("window-inside-absolute-pixel-edges",
882 Fwindow_inside_absolute_pixel_edges
,
883 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
884 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
885 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
886 the top left corner of the display.
888 RIGHT is one more than the rightmost x position of WINDOW's text area.
889 BOTTOM is one more than the bottommost y position of WINDOW's text area.
890 The inside edges do not include the space used by WINDOW's scroll bar,
891 display margins, fringes, header line, and/or mode line. */)
894 register struct window
*w
= decode_any_window (window
);
896 calc_absolute_offset (w
, &add_x
, &add_y
);
898 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
899 + WINDOW_LEFT_MARGIN_WIDTH (w
)
900 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
901 make_number (WINDOW_TOP_EDGE_Y (w
)
902 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
903 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
904 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
905 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
906 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
907 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
910 /* Test if the character at column X, row Y is within window W.
911 If it is not, return ON_NOTHING;
912 if it is in the window's text area, return ON_TEXT;
913 if it is on the window's modeline, return ON_MODE_LINE;
914 if it is on the border between the window and its right sibling,
915 return ON_VERTICAL_BORDER.
916 if it is on a scroll bar, return ON_SCROLL_BAR.
917 if it is on the window's top line, return ON_HEADER_LINE;
918 if it is in left or right fringe of the window,
919 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
920 if it is in the marginal area to the left/right of the window,
921 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
923 X and Y are frame relative pixel coordinates. */
925 static enum window_part
926 coordinates_in_window (register struct window
*w
, int x
, int y
)
928 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
930 enum window_part part
;
931 int ux
= FRAME_COLUMN_WIDTH (f
);
932 int x0
= WINDOW_LEFT_EDGE_X (w
);
933 int x1
= WINDOW_RIGHT_EDGE_X (w
);
934 /* The width of the area where the vertical line can be dragged.
935 (Between mode lines for instance. */
936 int grabbable_width
= ux
;
937 int lmargin_width
, rmargin_width
, text_left
, text_right
;
938 int top_y
= WINDOW_TOP_EDGE_Y (w
);
939 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
941 /* Outside any interesting row? */
942 if (y
< top_y
|| y
>= bottom_y
)
945 /* In what's below, we subtract 1 when computing right_x because we
946 want the rightmost pixel, which is given by left_pixel+width-1. */
947 if (w
->pseudo_window_p
)
950 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
954 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
955 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
958 /* On the mode line or header line? If it's near the start of
959 the mode or header line of window that's has a horizontal
960 sibling, say it's on the vertical line. That's to be able
961 to resize windows horizontally in case we're using toolkit
964 if (WINDOW_WANTS_MODELINE_P (w
)
965 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
969 header_vertical_border_check
:
970 /* We're somewhere on the mode line. We consider the place
971 between mode lines of horizontally adjacent mode lines
972 as the vertical border. If scroll bars on the left,
973 return the right window. */
974 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
975 || WINDOW_RIGHTMOST_P (w
))
976 && !WINDOW_LEFTMOST_P (w
)
977 && eabs (x
- x0
) < grabbable_width
)
978 return ON_VERTICAL_BORDER
;
980 /* Make sure we're not at the rightmost position of a
981 mode-/header-line and there's yet another window on the
983 else if ((WINDOW_RIGHTMOST_P (w
) || x
< x1
)
984 && eabs (x
- x1
) < grabbable_width
)
985 return ON_VERTICAL_BORDER
;
987 if (x
< x0
|| x
>= x1
)
993 if (WINDOW_WANTS_HEADER_LINE_P (w
)
994 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
996 part
= ON_HEADER_LINE
;
997 goto header_vertical_border_check
;
1000 if (x
< x0
|| x
>= x1
) return ON_NOTHING
;
1002 /* Outside any interesting column? */
1003 if (x
< left_x
|| x
> right_x
)
1004 return ON_SCROLL_BAR
;
1006 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1007 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1009 text_left
= window_box_left (w
, TEXT_AREA
);
1010 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1012 if (FRAME_WINDOW_P (f
))
1014 if (!w
->pseudo_window_p
1015 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1016 && !WINDOW_RIGHTMOST_P (w
)
1017 && (eabs (x
- right_x
) < grabbable_width
))
1018 return ON_VERTICAL_BORDER
;
1020 /* Need to say "x > right_x" rather than >=, since on character
1021 terminals, the vertical line's x coordinate is right_x. */
1022 else if (!w
->pseudo_window_p
1023 && !WINDOW_RIGHTMOST_P (w
)
1024 && x
> right_x
- ux
)
1025 return ON_VERTICAL_BORDER
;
1029 if (lmargin_width
> 0
1030 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1031 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1032 : (x
< left_x
+ lmargin_width
)))
1033 return ON_LEFT_MARGIN
;
1035 return ON_LEFT_FRINGE
;
1038 if (x
>= text_right
)
1040 if (rmargin_width
> 0
1041 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1042 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1043 : (x
>= right_x
- rmargin_width
)))
1044 return ON_RIGHT_MARGIN
;
1046 return ON_RIGHT_FRINGE
;
1049 /* Everything special ruled out - must be on text area */
1053 /* Take X is the frame-relative pixel x-coordinate, and return the
1054 x-coordinate relative to part PART of window W. */
1056 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1058 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1063 return x
- window_box_left (w
, TEXT_AREA
);
1065 case ON_LEFT_FRINGE
:
1068 case ON_RIGHT_FRINGE
:
1069 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1071 case ON_LEFT_MARGIN
:
1073 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1074 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1076 case ON_RIGHT_MARGIN
:
1078 - ((w
->pseudo_window_p
)
1079 ? WINDOW_TOTAL_WIDTH (w
)
1080 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1081 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1082 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1083 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1086 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1091 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1092 Scoordinates_in_window_p
, 2, 2, 0,
1093 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1094 COORDINATES is a cons of the form (X . Y), X and Y being distances
1095 measured in characters from the upper-left corner of the frame.
1096 \(0 . 0) denotes the character in the upper left corner of the
1098 If COORDINATES are in the text portion of WINDOW,
1099 the coordinates relative to the window are returned.
1100 If they are in the mode line of WINDOW, `mode-line' is returned.
1101 If they are in the top mode line of WINDOW, `header-line' is returned.
1102 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1103 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1104 If they are on the border between WINDOW and its right sibling,
1105 `vertical-line' is returned.
1106 If they are in the windows's left or right marginal areas, `left-margin'\n\
1107 or `right-margin' is returned. */)
1108 (register Lisp_Object coordinates
, Lisp_Object window
)
1115 CHECK_WINDOW (window
);
1116 w
= XWINDOW (window
);
1117 f
= XFRAME (w
->frame
);
1118 CHECK_CONS (coordinates
);
1119 lx
= Fcar (coordinates
);
1120 ly
= Fcdr (coordinates
);
1121 CHECK_NUMBER_OR_FLOAT (lx
);
1122 CHECK_NUMBER_OR_FLOAT (ly
);
1123 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1124 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1126 switch (coordinates_in_window (w
, x
, y
))
1132 /* Convert X and Y to window relative pixel coordinates, and
1133 return the canonical char units. */
1134 x
-= window_box_left (w
, TEXT_AREA
);
1135 y
-= WINDOW_TOP_EDGE_Y (w
);
1136 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1137 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1142 case ON_VERTICAL_BORDER
:
1143 return Qvertical_line
;
1145 case ON_HEADER_LINE
:
1146 return Qheader_line
;
1148 case ON_LEFT_FRINGE
:
1149 return Qleft_fringe
;
1151 case ON_RIGHT_FRINGE
:
1152 return Qright_fringe
;
1154 case ON_LEFT_MARGIN
:
1155 return Qleft_margin
;
1157 case ON_RIGHT_MARGIN
:
1158 return Qright_margin
;
1161 /* Historically we are supposed to return nil in this case. */
1170 /* Callback for foreach_window, used in window_from_coordinates.
1171 Check if window W contains coordinates specified by USER_DATA which
1172 is actually a pointer to a struct check_window_data CW.
1174 Check if window W contains coordinates *CW->x and *CW->y. If it
1175 does, return W in *CW->window, as Lisp_Object, and return in
1176 *CW->part the part of the window under coordinates *X,*Y. Return
1177 zero from this function to stop iterating over windows. */
1179 struct check_window_data
1181 Lisp_Object
*window
;
1183 enum window_part
*part
;
1187 check_window_containing (struct window
*w
, void *user_data
)
1189 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1190 enum window_part found
;
1193 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1194 if (found
!= ON_NOTHING
)
1197 XSETWINDOW (*cw
->window
, w
);
1205 /* Find the window containing frame-relative pixel position X/Y and
1206 return it as a Lisp_Object.
1208 If X, Y is on one of the window's special `window_part' elements,
1209 set *PART to the id of that element.
1211 If there is no window under X, Y return nil and leave *PART
1212 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1214 This function was previously implemented with a loop cycling over
1215 windows with Fnext_window, and starting with the frame's selected
1216 window. It turned out that this doesn't work with an
1217 implementation of next_window using Vwindow_list, because
1218 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1219 tree of F when this function is called asynchronously from
1220 note_mouse_highlight. The original loop didn't terminate in this
1224 window_from_coordinates (struct frame
*f
, int x
, int y
,
1225 enum window_part
*part
, int tool_bar_p
)
1228 struct check_window_data cw
;
1229 enum window_part dummy
;
1235 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1236 foreach_window (f
, check_window_containing
, &cw
);
1238 /* If not found above, see if it's in the tool bar window, if a tool
1242 && WINDOWP (f
->tool_bar_window
)
1243 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1244 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1248 window
= f
->tool_bar_window
;
1254 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1255 doc
: /* Return window containing coordinates X and Y on FRAME.
1256 FRAME must be a live frame and defaults to the selected one.
1257 The top left corner of the frame is considered to be row 0,
1259 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1264 frame
= selected_frame
;
1265 CHECK_LIVE_FRAME (frame
);
1268 /* Check that arguments are integers or floats. */
1269 CHECK_NUMBER_OR_FLOAT (x
);
1270 CHECK_NUMBER_OR_FLOAT (y
);
1272 return window_from_coordinates (f
,
1273 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1274 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1275 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1276 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1280 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1281 doc
: /* Return current value of point in WINDOW.
1282 WINDOW must be a live window and defaults to the selected one.
1284 For a nonselected window, this is the value point would have
1285 if that window were selected.
1287 Note that, when WINDOW is the selected window and its buffer
1288 is also currently selected, the value returned is the same as (point).
1289 It would be more strictly correct to return the `top-level' value
1290 of point, outside of any save-excursion forms.
1291 But that is hard to define. */)
1292 (Lisp_Object window
)
1294 register struct window
*w
= decode_window (window
);
1296 if (w
== XWINDOW (selected_window
)
1297 && current_buffer
== XBUFFER (w
->buffer
))
1299 return Fmarker_position (w
->pointm
);
1302 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1303 doc
: /* Return position at which display currently starts in WINDOW.
1304 WINDOW must be a live window and defaults to the selected one.
1305 This is updated by redisplay or by calling `set-window-start'. */)
1306 (Lisp_Object window
)
1308 return Fmarker_position (decode_window (window
)->start
);
1311 /* This is text temporarily removed from the doc string below.
1313 This function returns nil if the position is not currently known.
1314 That happens when redisplay is preempted and doesn't finish.
1315 If in that case you want to compute where the end of the window would
1316 have been if redisplay had finished, do this:
1318 (goto-char (window-start window))
1319 (vertical-motion (1- (window-height window)) window)
1322 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1323 doc
: /* Return position at which display currently ends in WINDOW.
1324 WINDOW must be a live window and defaults to the selected one.
1325 This is updated by redisplay, when it runs to completion.
1326 Simply changing the buffer text or setting `window-start'
1327 does not update this value.
1328 Return nil if there is no recorded value. \(This can happen if the
1329 last redisplay of WINDOW was preempted, and did not finish.)
1330 If UPDATE is non-nil, compute the up-to-date position
1331 if it isn't already recorded. */)
1332 (Lisp_Object window
, Lisp_Object update
)
1335 struct window
*w
= decode_window (window
);
1343 #if 0 /* This change broke some things. We should make it later. */
1344 /* If we don't know the end position, return nil.
1345 The user can compute it with vertical-motion if he wants to.
1346 It would be nicer to do it automatically,
1347 but that's so slow that it would probably bother people. */
1348 if (NILP (w
->window_end_valid
))
1353 && ! (! NILP (w
->window_end_valid
)
1354 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1355 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1358 struct text_pos startp
;
1360 struct buffer
*old_buffer
= NULL
;
1362 /* Cannot use Fvertical_motion because that function doesn't
1363 cope with variable-height lines. */
1364 if (b
!= current_buffer
)
1366 old_buffer
= current_buffer
;
1367 set_buffer_internal (b
);
1370 /* In case W->start is out of the range, use something
1371 reasonable. This situation occurred when loading a file with
1372 `-l' containing a call to `rmail' with subsequent other
1373 commands. At the end, W->start happened to be BEG, while
1374 rmail had already narrowed the buffer. */
1375 if (XMARKER (w
->start
)->charpos
< BEGV
)
1376 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1377 else if (XMARKER (w
->start
)->charpos
> ZV
)
1378 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1380 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1382 start_display (&it
, w
, startp
);
1383 move_it_vertically (&it
, window_box_height (w
));
1384 if (it
.current_y
< it
.last_visible_y
)
1385 move_it_past_eol (&it
);
1386 value
= make_number (IT_CHARPOS (it
));
1389 set_buffer_internal (old_buffer
);
1392 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1397 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1398 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1400 (Lisp_Object window
, Lisp_Object pos
)
1402 register struct window
*w
= decode_window (window
);
1404 CHECK_NUMBER_COERCE_MARKER (pos
);
1405 if (w
== XWINDOW (selected_window
)
1406 && XBUFFER (w
->buffer
) == current_buffer
)
1409 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1411 /* We have to make sure that redisplay updates the window to show
1412 the new value of point. */
1413 if (!EQ (window
, selected_window
))
1414 ++windows_or_buffers_changed
;
1419 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1420 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1421 WINDOW defaults to the selected window. Return POS.
1422 Optional third arg NOFORCE non-nil inhibits next redisplay from
1423 overriding motion of point in order to display at this exact start. */)
1424 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1426 register struct window
*w
= decode_window (window
);
1428 CHECK_NUMBER_COERCE_MARKER (pos
);
1429 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1430 /* this is not right, but much easier than doing what is right. */
1431 w
->start_at_line_beg
= Qnil
;
1433 w
->force_start
= Qt
;
1434 w
->update_mode_line
= Qt
;
1435 XSETFASTINT (w
->last_modified
, 0);
1436 XSETFASTINT (w
->last_overlay_modified
, 0);
1437 if (!EQ (window
, selected_window
))
1438 windows_or_buffers_changed
++;
1443 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1444 Spos_visible_in_window_p
, 0, 3, 0,
1445 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1446 Return nil if that position is scrolled vertically out of view.
1447 If a character is only partially visible, nil is returned, unless the
1448 optional argument PARTIALLY is non-nil.
1449 If POS is only out of view because of horizontal scrolling, return non-nil.
1450 If POS is t, it specifies the position of the last visible glyph in WINDOW.
1451 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
1453 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1454 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1455 where X and Y are the pixel coordinates relative to the top left corner
1456 of the window. The remaining elements are omitted if the character after
1457 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1458 off-window at the top and bottom of the row, ROWH is the height of the
1459 display row, and VPOS is the row number (0-based) containing POS. */)
1460 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1462 register struct window
*w
;
1463 register EMACS_INT posint
;
1464 register struct buffer
*buf
;
1465 struct text_pos top
;
1466 Lisp_Object in_window
= Qnil
;
1467 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1470 w
= decode_window (window
);
1471 buf
= XBUFFER (w
->buffer
);
1472 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1476 else if (!NILP (pos
))
1478 CHECK_NUMBER_COERCE_MARKER (pos
);
1479 posint
= XINT (pos
);
1481 else if (w
== XWINDOW (selected_window
))
1484 posint
= XMARKER (w
->pointm
)->charpos
;
1486 /* If position is above window start or outside buffer boundaries,
1487 or if window start is out of range, position is not visible. */
1489 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1490 && CHARPOS (top
) >= BUF_BEGV (buf
)
1491 && CHARPOS (top
) <= BUF_ZV (buf
)
1492 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1493 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1496 if (!NILP (in_window
) && !NILP (partially
))
1498 Lisp_Object part
= Qnil
;
1500 part
= list4 (make_number (rtop
), make_number (rbot
),
1501 make_number (rowh
), make_number (vpos
));
1502 in_window
= Fcons (make_number (x
),
1503 Fcons (make_number (y
), part
));
1509 DEFUN ("window-line-height", Fwindow_line_height
,
1510 Swindow_line_height
, 0, 2, 0,
1511 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1512 WINDOW defaults to the selected window.
1514 Return height of current line if LINE is omitted or nil. Return height of
1515 header or mode line if LINE is `header-line' or `mode-line'.
1516 Otherwise, LINE is a text line number starting from 0. A negative number
1517 counts from the end of the window.
1519 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1520 in pixels of the visible part of the line, VPOS and YPOS are the
1521 vertical position in lines and pixels of the line, relative to the top
1522 of the first text line, and OFFBOT is the number of off-window pixels at
1523 the bottom of the text line. If there are off-window pixels at the top
1524 of the (first) text line, YPOS is negative.
1526 Return nil if window display is not up-to-date. In that case, use
1527 `pos-visible-in-window-p' to obtain the information. */)
1528 (Lisp_Object line
, Lisp_Object window
)
1530 register struct window
*w
;
1531 register struct buffer
*b
;
1532 struct glyph_row
*row
, *end_row
;
1533 int max_y
, crop
, i
, n
;
1535 w
= decode_window (window
);
1537 if (noninteractive
|| w
->pseudo_window_p
)
1540 CHECK_BUFFER (w
->buffer
);
1541 b
= XBUFFER (w
->buffer
);
1543 /* Fail if current matrix is not up-to-date. */
1544 if (NILP (w
->window_end_valid
)
1545 || current_buffer
->clip_changed
1546 || current_buffer
->prevent_redisplay_optimizations_p
1547 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
1548 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
1554 if (i
< 0 || i
>= w
->current_matrix
->nrows
1555 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1557 max_y
= window_text_bottom_y (w
);
1561 if (EQ (line
, Qheader_line
))
1563 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1565 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1566 if (!row
->enabled_p
)
1568 return list4 (make_number (row
->height
),
1569 make_number (0), make_number (0),
1573 if (EQ (line
, Qmode_line
))
1575 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1576 if (!row
->enabled_p
)
1578 return list4 (make_number (row
->height
),
1579 make_number (0), /* not accurate */
1580 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
1581 + window_text_bottom_y (w
)),
1585 CHECK_NUMBER (line
);
1588 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1589 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1590 max_y
= window_text_bottom_y (w
);
1593 while ((n
< 0 || i
< n
)
1594 && row
<= end_row
&& row
->enabled_p
1595 && row
->y
+ row
->height
< max_y
)
1598 if (row
> end_row
|| !row
->enabled_p
)
1610 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1611 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
1613 make_number (row
->y
),
1614 make_number (crop
));
1617 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1619 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1620 More precisely, return the value assigned by the last call of
1621 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1622 never called with WINDOW as its argument, or the value set by that
1623 function was internally reset since its last call. WINDOW defaults to
1624 the selected window.
1626 When a window is dedicated to its buffer, `display-buffer' will refrain
1627 from displaying another buffer in it. `get-lru-window' and
1628 `get-largest-window' treat dedicated windows specially.
1629 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1630 `kill-buffer' can delete a dedicated window and the containing frame.
1632 Functions like `set-window-buffer' may change the buffer displayed by a
1633 window, unless that window is "strongly" dedicated to its buffer, that
1634 is the value returned by `window-dedicated-p' is t. */)
1635 (Lisp_Object window
)
1637 return decode_window (window
)->dedicated
;
1640 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1641 Sset_window_dedicated_p
, 2, 2, 0,
1642 doc
: /* Mark WINDOW as dedicated according to FLAG.
1643 WINDOW must be a live window and defaults to the selected one. FLAG
1644 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1645 mark WINDOW as non-dedicated. Return FLAG.
1647 When a window is dedicated to its buffer, `display-buffer' will refrain
1648 from displaying another buffer in it. `get-lru-window' and
1649 `get-largest-window' treat dedicated windows specially.
1650 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1651 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1652 and the containing frame.
1654 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1655 its buffer. Functions like `set-window-buffer' may change the buffer
1656 displayed by a window, unless that window is strongly dedicated to its
1657 buffer. If and when `set-window-buffer' displays another buffer in a
1658 window, it also makes sure that the window is no more dedicated. */)
1659 (Lisp_Object window
, Lisp_Object flag
)
1661 register struct window
*w
= decode_window (window
);
1663 w
->dedicated
= flag
;
1664 return w
->dedicated
;
1667 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1669 doc
: /* Return buffers previously shown in WINDOW.
1670 WINDOW must be a live window and defaults to the selected one.
1672 The return value is either nil or a list of <buffer, window-start,
1673 window-point> triples where buffer was previously shown in WINDOW. */)
1674 (Lisp_Object window
)
1676 return decode_window (window
)->prev_buffers
;
1679 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1680 Sset_window_prev_buffers
, 2, 2, 0,
1681 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1682 WINDOW must be a live window and defaults to the selected one. Return
1685 PREV-BUFFERS should be either nil or a list of <buffer, window-start,
1686 window-point> triples where buffer was previously shown in WINDOW. */)
1687 (Lisp_Object window
, Lisp_Object prev_buffers
)
1689 return decode_any_window (window
)->prev_buffers
= prev_buffers
;
1692 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1694 doc
: /* Return list of buffers recently re-shown in WINDOW.
1695 WINDOW must be a live window and defaults to the selected one. */)
1696 (Lisp_Object window
)
1698 return decode_window (window
)->next_buffers
;
1701 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1702 Sset_window_next_buffers
, 2, 2, 0,
1703 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1704 WINDOW must be a live window and defaults to the selected one. Return
1707 NEXT-BUFFERS should be either nil or a list of buffers that have been
1708 recently re-shown in WINDOW. */)
1709 (Lisp_Object window
, Lisp_Object next_buffers
)
1711 return decode_any_window (window
)->next_buffers
= next_buffers
;
1714 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1716 doc
: /* Return the parameters of WINDOW and their values.
1717 WINDOW defaults to the selected window. The return value is a list of
1718 elements of the form (PARAMETER . VALUE). */)
1719 (Lisp_Object window
)
1721 return Fcopy_alist (decode_any_window (window
)->window_parameters
);
1724 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1726 doc
: /* Return WINDOW's value for PARAMETER.
1727 WINDOW defaults to the selected window. */)
1728 (Lisp_Object window
, Lisp_Object parameter
)
1732 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1733 return CDR_SAFE (result
);
1736 DEFUN ("set-window-parameter", Fset_window_parameter
,
1737 Sset_window_parameter
, 3, 3, 0,
1738 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1739 WINDOW defaults to the selected window. Return VALUE. */)
1740 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1742 register struct window
*w
= decode_any_window (window
);
1743 Lisp_Object old_alist_elt
;
1745 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1746 if (NILP (old_alist_elt
))
1747 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1749 Fsetcdr (old_alist_elt
, value
);
1753 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1755 doc
: /* Return the display-table that WINDOW is using.
1756 WINDOW defaults to the selected window. */)
1757 (Lisp_Object window
)
1759 return decode_window (window
)->display_table
;
1762 /* Get the display table for use on window W. This is either W's
1763 display table or W's buffer's display table. Ignore the specified
1764 tables if they are not valid; if no valid table is specified,
1767 struct Lisp_Char_Table
*
1768 window_display_table (struct window
*w
)
1770 struct Lisp_Char_Table
*dp
= NULL
;
1772 if (DISP_TABLE_P (w
->display_table
))
1773 dp
= XCHAR_TABLE (w
->display_table
);
1774 else if (BUFFERP (w
->buffer
))
1776 struct buffer
*b
= XBUFFER (w
->buffer
);
1778 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1779 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1780 else if (DISP_TABLE_P (Vstandard_display_table
))
1781 dp
= XCHAR_TABLE (Vstandard_display_table
);
1787 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1788 doc
: /* Set WINDOW's display-table to TABLE. */)
1789 (register Lisp_Object window
, Lisp_Object table
)
1791 register struct window
*w
;
1793 w
= decode_window (window
);
1794 w
->display_table
= table
;
1798 /* Record info on buffer window W is displaying
1799 when it is about to cease to display that buffer. */
1801 unshow_buffer (register struct window
*w
)
1808 if (b
!= XMARKER (w
->pointm
)->buffer
)
1812 if (w
== XWINDOW (selected_window
)
1813 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1814 /* Do this except when the selected window's buffer
1815 is being removed from some other window. */
1817 /* last_window_start records the start position that this buffer
1818 had in the last window to be disconnected from it.
1819 Now that this statement is unconditional,
1820 it is possible for the buffer to be displayed in the
1821 selected window, while last_window_start reflects another
1822 window which was recently showing the same buffer.
1823 Some people might say that might be a good thing. Let's see. */
1824 b
->last_window_start
= marker_position (w
->start
);
1826 /* Point in the selected window's buffer
1827 is actually stored in that buffer, and the window's pointm isn't used.
1828 So don't clobber point in that buffer. */
1829 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1830 /* This line helps to fix Horsley's testbug.el bug. */
1831 && !(WINDOWP (BVAR (b
, last_selected_window
))
1832 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1833 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1834 temp_set_point_both (b
,
1835 clip_to_bounds (BUF_BEGV (b
),
1836 XMARKER (w
->pointm
)->charpos
,
1838 clip_to_bounds (BUF_BEGV_BYTE (b
),
1839 marker_byte_position (w
->pointm
),
1842 if (WINDOWP (BVAR (b
, last_selected_window
))
1843 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1844 BVAR (b
, last_selected_window
) = Qnil
;
1847 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1848 means change window structure only. Otherwise store geometry and
1849 other settings as well. */
1851 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1853 register Lisp_Object tem
;
1854 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1856 /* If OLD is its frame's root window, then NEW is the new
1857 root window for that frame. */
1858 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1859 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = new;
1863 n
->left_col
= o
->left_col
;
1864 n
->top_line
= o
->top_line
;
1865 n
->total_cols
= o
->total_cols
;
1866 n
->total_lines
= o
->total_lines
;
1867 n
->normal_cols
= o
->normal_cols
;
1868 o
->normal_cols
= make_float (1.0);
1869 n
->normal_lines
= o
->normal_lines
;
1870 o
->normal_lines
= make_float (1.0);
1871 n
->desired_matrix
= n
->current_matrix
= 0;
1873 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1874 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1875 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1876 n
->phys_cursor_type
= -1;
1877 n
->phys_cursor_width
= -1;
1878 n
->must_be_updated_p
= 0;
1879 n
->pseudo_window_p
= 0;
1880 XSETFASTINT (n
->window_end_vpos
, 0);
1881 XSETFASTINT (n
->window_end_pos
, 0);
1882 n
->window_end_valid
= Qnil
;
1883 n
->frozen_window_start_p
= 0;
1886 n
->next
= tem
= o
->next
;
1888 XWINDOW (tem
)->prev
= new;
1890 n
->prev
= tem
= o
->prev
;
1892 XWINDOW (tem
)->next
= new;
1894 n
->parent
= tem
= o
->parent
;
1897 if (EQ (XWINDOW (tem
)->vchild
, old
))
1898 XWINDOW (tem
)->vchild
= new;
1899 if (EQ (XWINDOW (tem
)->hchild
, old
))
1900 XWINDOW (tem
)->hchild
= new;
1904 /* If window WINDOW and its parent window are iso-combined, merge
1905 WINDOW's children into those of its parent window and mark WINDOW as
1909 recombine_windows (Lisp_Object window
)
1911 struct window
*w
, *p
, *c
;
1912 Lisp_Object parent
, child
;
1915 w
= XWINDOW (window
);
1917 if (!NILP (parent
) && NILP (w
->nest
))
1919 p
= XWINDOW (parent
);
1920 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
1921 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
1922 /* WINDOW and PARENT are both either a vertical or a horizontal
1925 horflag
= NILP (w
->vchild
);
1926 child
= horflag
? w
->hchild
: w
->vchild
;
1927 c
= XWINDOW (child
);
1929 /* Splice WINDOW's children into its parent's children and
1930 assign new normal sizes. */
1939 XWINDOW (w
->prev
)->next
= child
;
1948 = make_float (XFLOATINT (c
->total_cols
)
1949 / XFLOATINT (p
->total_cols
));
1952 = make_float (XFLOATINT (c
->total_lines
)
1953 / XFLOATINT (p
->total_lines
));
1957 if (!NILP (w
->next
))
1960 XWINDOW (c
->next
)->prev
= child
;
1968 c
= XWINDOW (child
);
1972 /* WINDOW can be deleted now. */
1973 w
->vchild
= w
->hchild
= Qnil
;
1978 /***********************************************************************
1980 ***********************************************************************/
1982 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1983 pointer. This is a callback function for foreach_window, used in
1984 the window_list function. */
1987 add_window_to_list (struct window
*w
, void *user_data
)
1989 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1991 XSETWINDOW (window
, w
);
1992 *list
= Fcons (window
, *list
);
1997 /* Return a list of all windows, for use by next_window. If
1998 Vwindow_list is a list, return that list. Otherwise, build a new
1999 list, cache it in Vwindow_list, and return that. */
2004 if (!CONSP (Vwindow_list
))
2008 Vwindow_list
= Qnil
;
2009 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
2011 Lisp_Object args
[2];
2013 /* We are visiting windows in canonical order, and add
2014 new windows at the front of args[1], which means we
2015 have to reverse this list at the end. */
2017 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
2018 args
[0] = Vwindow_list
;
2019 args
[1] = Fnreverse (args
[1]);
2020 Vwindow_list
= Fnconc (2, args
);
2024 return Vwindow_list
;
2028 /* Value is non-zero if WINDOW satisfies the constraints given by
2029 OWINDOW, MINIBUF and ALL_FRAMES.
2031 MINIBUF t means WINDOW may be minibuffer windows.
2032 `lambda' means WINDOW may not be a minibuffer window.
2033 a window means a specific minibuffer window
2035 ALL_FRAMES t means search all frames,
2036 nil means search just current frame,
2037 `visible' means search just visible frames on the
2039 0 means search visible and iconified frames on the
2041 a window means search the frame that window belongs to,
2042 a frame means consider windows on that frame, only. */
2045 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2047 struct window
*w
= XWINDOW (window
);
2048 struct frame
*f
= XFRAME (w
->frame
);
2049 int candidate_p
= 1;
2051 if (!BUFFERP (w
->buffer
))
2053 else if (MINI_WINDOW_P (w
)
2054 && (EQ (minibuf
, Qlambda
)
2055 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2057 /* If MINIBUF is `lambda' don't consider any mini-windows.
2058 If it is a window, consider only that one. */
2061 else if (EQ (all_frames
, Qt
))
2063 else if (NILP (all_frames
))
2065 xassert (WINDOWP (owindow
));
2066 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2068 else if (EQ (all_frames
, Qvisible
))
2070 FRAME_SAMPLE_VISIBILITY (f
);
2071 candidate_p
= FRAME_VISIBLE_P (f
)
2072 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2073 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2076 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2078 FRAME_SAMPLE_VISIBILITY (f
);
2079 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2080 #ifdef HAVE_X_WINDOWS
2081 /* Yuck!! If we've just created the frame and the
2082 window-manager requested the user to place it
2083 manually, the window may still not be considered
2084 `visible'. I'd argue it should be at least
2085 something like `iconified', but don't know how to do
2087 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2088 && !f
->output_data
.x
->has_been_visible
)
2091 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2092 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2094 else if (WINDOWP (all_frames
))
2095 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2096 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2097 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2098 else if (FRAMEP (all_frames
))
2099 candidate_p
= EQ (all_frames
, w
->frame
);
2105 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2106 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2107 MINIBUF, and ALL_FRAMES. */
2110 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2113 *window
= selected_window
;
2115 CHECK_LIVE_WINDOW (*window
);
2117 /* MINIBUF nil may or may not include minibuffers. Decide if it
2119 if (NILP (*minibuf
))
2120 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2121 else if (!EQ (*minibuf
, Qt
))
2124 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2125 => count none of them, or a specific minibuffer window (the
2126 active one) to count. */
2128 /* ALL_FRAMES nil doesn't specify which frames to include. */
2129 if (NILP (*all_frames
))
2130 *all_frames
= (!EQ (*minibuf
, Qlambda
)
2131 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
2133 else if (EQ (*all_frames
, Qvisible
))
2135 else if (EQ (*all_frames
, make_number (0)))
2137 else if (FRAMEP (*all_frames
))
2139 else if (!EQ (*all_frames
, Qt
))
2144 /* Return the next or previous window of WINDOW in cyclic ordering
2145 of windows. NEXT_P non-zero means return the next window. See the
2146 documentation string of next-window for the meaning of MINIBUF and
2150 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2152 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2154 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2155 return the first window on the frame. */
2156 if (FRAMEP (all_frames
)
2157 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2158 return Fframe_first_window (all_frames
);
2164 /* Find WINDOW in the list of all windows. */
2165 list
= Fmemq (window
, window_list ());
2167 /* Scan forward from WINDOW to the end of the window list. */
2169 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2170 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2173 /* Scan from the start of the window list up to WINDOW. */
2175 for (list
= Vwindow_list
;
2176 CONSP (list
) && !EQ (XCAR (list
), window
);
2178 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2182 window
= XCAR (list
);
2186 Lisp_Object candidate
, list
;
2188 /* Scan through the list of windows for candidates. If there are
2189 candidate windows in front of WINDOW, the last one of these
2190 is the one we want. If there are candidates following WINDOW
2191 in the list, again the last one of these is the one we want. */
2193 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2195 if (EQ (XCAR (list
), window
))
2197 if (WINDOWP (candidate
))
2200 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2202 candidate
= XCAR (list
);
2205 if (WINDOWP (candidate
))
2213 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2214 doc
: /* Return window following WINDOW in cyclic ordering of windows.
2215 WINDOW must be a live window and defaults to the selected one. The
2216 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2219 MINIBUF nil or omitted means consider the minibuffer window only if the
2220 minibuffer is active. MINIBUF t means consider the minibuffer window
2221 even if the minibuffer is not active. Any other value means do not
2222 consider the minibuffer window even if the minibuffer is active.
2224 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2225 plus the minibuffer window if specified by the MINIBUF argument. If the
2226 minibuffer counts, consider all windows on all frames that share that
2227 minibuffer too. The following non-nil values of ALL-FRAMES have special
2230 - t means consider all windows on all existing frames.
2232 - `visible' means consider all windows on all visible frames.
2234 - 0 (the number zero) means consider all windows on all visible and
2237 - A frame means consider all windows on that frame only.
2239 Anything else means consider all windows on WINDOW's frame and no
2242 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2243 `next-window' to iterate through the entire cycle of acceptable
2244 windows, eventually ending up back at the window you started with.
2245 `previous-window' traverses the same cycle, in the reverse order. */)
2246 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2248 return next_window (window
, minibuf
, all_frames
, 1);
2252 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2253 doc
: /* Return window preceding WINDOW in cyclic ordering of windows.
2254 WINDOW must be a live window and defaults to the selected one. The
2255 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2258 MINIBUF nil or omitted means consider the minibuffer window only if the
2259 minibuffer is active. MINIBUF t means consider the minibuffer window
2260 even if the minibuffer is not active. Any other value means do not
2261 consider the minibuffer window even if the minibuffer is active.
2263 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2264 plus the minibuffer window if specified by the MINIBUF argument. If the
2265 minibuffer counts, consider all windows on all frames that share that
2266 minibuffer too. The following non-nil values of ALL-FRAMES have special
2269 - t means consider all windows on all existing frames.
2271 - `visible' means consider all windows on all visible frames.
2273 - 0 (the number zero) means consider all windows on all visible and
2276 - A frame means consider all windows on that frame only.
2278 Anything else means consider all windows on WINDOW's frame and no
2281 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2282 use `previous-window' to iterate through the entire cycle of
2283 acceptable windows, eventually ending up back at the window you
2284 started with. `next-window' traverses the same cycle, in the
2286 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2288 return next_window (window
, minibuf
, all_frames
, 0);
2292 /* Return a list of windows in cyclic ordering. Arguments are like
2293 for `next-window'. */
2296 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2298 Lisp_Object tail
, list
, rest
;
2300 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2303 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2304 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2305 list
= Fcons (XCAR (tail
), list
);
2307 /* Rotate the list to start with WINDOW. */
2308 list
= Fnreverse (list
);
2309 rest
= Fmemq (window
, list
);
2310 if (!NILP (rest
) && !EQ (rest
, list
))
2312 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2314 XSETCDR (tail
, Qnil
);
2315 list
= nconc2 (rest
, list
);
2321 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2322 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2323 FRAME nil or omitted means use the selected frame.
2324 WINDOW nil or omitted means use the selected window.
2325 MINIBUF t means include the minibuffer window, even if it isn't active.
2326 MINIBUF nil or omitted means include the minibuffer window only
2328 MINIBUF neither nil nor t means never include the minibuffer window. */)
2329 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2332 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2333 CHECK_WINDOW (window
);
2335 frame
= selected_frame
;
2337 if (!EQ (frame
, XWINDOW (window
)->frame
))
2338 error ("Window is on a different frame");
2340 return window_list_1 (window
, minibuf
, frame
);
2344 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2345 doc
: /* Return a list of all live windows.
2346 WINDOW specifies the first window to list and defaults to the selected
2349 Optional argument MINIBUF nil or omitted means consider the minibuffer
2350 window only if the minibuffer is active. MINIBUF t means consider the
2351 minibuffer window even if the minibuffer is not active. Any other value
2352 means do not consider the minibuffer window even if the minibuffer is
2355 Optional argument ALL-FRAMES nil or omitted means consider all windows
2356 on WINDOW's frame, plus the minibuffer window if specified by the
2357 MINIBUF argument. If the minibuffer counts, consider all windows on all
2358 frames that share that minibuffer too. The following non-nil values of
2359 ALL-FRAMES have special meanings:
2361 - t means consider all windows on all existing frames.
2363 - `visible' means consider all windows on all visible frames.
2365 - 0 (the number zero) means consider all windows on all visible and
2368 - A frame means consider all windows on that frame only.
2370 Anything else means consider all windows on WINDOW's frame and no
2373 If WINDOW is not on the list of windows returned, some other window will
2374 be listed first but no error is signalled. */)
2375 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2377 return window_list_1 (window
, minibuf
, all_frames
);
2380 /* Look at all windows, performing an operation specified by TYPE
2382 If FRAMES is Qt, look at all frames;
2383 Qnil, look at just the selected frame;
2384 Qvisible, look at visible frames;
2385 a frame, just look at windows on that frame.
2386 If MINI is non-zero, perform the operation on minibuffer windows too. */
2391 GET_BUFFER_WINDOW
, /* Arg is buffer */
2392 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2393 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2398 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2400 Lisp_Object window
, windows
, best_window
, frame_arg
;
2401 int frame_best_window_flag
= 0;
2403 struct gcpro gcpro1
;
2405 /* If we're only looping through windows on a particular frame,
2406 frame points to that frame. If we're looping through windows
2407 on all frames, frame is 0. */
2408 if (FRAMEP (frames
))
2409 f
= XFRAME (frames
);
2410 else if (NILP (frames
))
2411 f
= SELECTED_FRAME ();
2416 frame_arg
= Qlambda
;
2417 else if (EQ (frames
, make_number (0)))
2419 else if (EQ (frames
, Qvisible
))
2424 /* frame_arg is Qlambda to stick to one frame,
2425 Qvisible to consider all visible frames,
2428 /* Pick a window to start with. */
2432 window
= FRAME_SELECTED_WINDOW (f
);
2434 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2436 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2440 for (; CONSP (windows
); windows
= XCDR (windows
))
2444 window
= XCAR (windows
);
2445 w
= XWINDOW (window
);
2447 /* Note that we do not pay attention here to whether the frame
2448 is visible, since Fwindow_list skips non-visible frames if
2449 that is desired, under the control of frame_arg. */
2450 if (!MINI_WINDOW_P (w
)
2451 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2452 consider all windows. */
2453 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2454 || (mini
&& minibuf_level
> 0))
2457 case GET_BUFFER_WINDOW
:
2458 if (EQ (w
->buffer
, obj
)
2459 /* Don't find any minibuffer window except the one that
2460 is currently in use. */
2461 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2463 if (EQ (window
, selected_window
))
2464 /* Preferably return the selected window. */
2465 RETURN_UNGCPRO (window
);
2466 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2467 && !frame_best_window_flag
)
2468 /* Prefer windows on the current frame (but don't
2469 choose another one if we have one already). */
2471 best_window
= window
;
2472 frame_best_window_flag
= 1;
2474 else if (NILP (best_window
))
2475 best_window
= window
;
2479 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2480 /* We could simply check whether the buffer shown by window
2481 is live, and show another buffer in case it isn't. */
2482 if (EQ (w
->buffer
, obj
))
2484 /* Undedicate WINDOW. */
2485 w
->dedicated
= Qnil
;
2486 /* Make WINDOW show the buffer returned by
2487 other_buffer_safely, don't run any hooks. */
2489 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2490 /* If WINDOW is the selected window, make its buffer
2491 current. But do so only if the window shows the
2492 current buffer (Bug#6454). */
2493 if (EQ (window
, selected_window
)
2494 && XBUFFER (w
->buffer
) == current_buffer
)
2495 Fset_buffer (w
->buffer
);
2499 case REDISPLAY_BUFFER_WINDOWS
:
2500 if (EQ (w
->buffer
, obj
))
2502 mark_window_display_accurate (window
, 0);
2503 w
->update_mode_line
= Qt
;
2504 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2505 ++update_mode_lines
;
2506 best_window
= window
;
2510 /* Check for a window that has a killed buffer. */
2511 case CHECK_ALL_WINDOWS
:
2512 if (! NILP (w
->buffer
)
2513 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2517 case WINDOW_LOOP_UNUSED
:
2526 /* Used for debugging. Abort if any window has a dead buffer. */
2528 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2530 check_all_windows (void)
2532 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2535 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2536 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2537 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2540 The optional argument ALL-FRAMES specifies the frames to consider:
2542 - t means consider all windows on all existing frames.
2544 - `visible' means consider all windows on all visible frames.
2546 - 0 (the number zero) means consider all windows on all visible
2547 and iconified frames.
2549 - A frame means consider all windows on that frame only.
2551 Any other value of ALL-FRAMES means consider all windows on the
2552 selected frame and no others. */)
2553 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2557 if (NILP (buffer_or_name
))
2558 buffer
= Fcurrent_buffer ();
2560 buffer
= Fget_buffer (buffer_or_name
);
2562 if (BUFFERP (buffer
))
2563 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2569 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2571 return call4 (Qresize_root_window
, window
, delta
, horizontal
, ignore
);
2575 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2576 Sdelete_other_windows_internal
, 0, 2, "",
2577 doc
: /* Make WINDOW fill its frame.
2578 Only the frame WINDOW is on is affected. WINDOW may be any window and
2579 defaults to the selected one.
2581 Optional argument ROOT, if non-nil, must specify an internal window
2582 containing WINDOW as a subwindow. If this is the case, replace ROOT by
2583 WINDOW and leave alone any windows not contained in ROOT.
2585 When WINDOW is live try to reduce display jumps by keeping the text
2586 previously visible in WINDOW in the same place on the frame. Doing this
2587 depends on the value of (window-start WINDOW), so if calling this
2588 function in a program gives strange scrolling, make sure the
2589 window-start value is reasonable when this function is called. */)
2590 (Lisp_Object window
, Lisp_Object root
)
2592 struct window
*w
, *r
, *s
;
2594 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2595 EMACS_INT startpos
IF_LINT (= 0);
2596 int top
IF_LINT (= 0), new_top
, resize_failed
;
2598 w
= decode_any_window (window
);
2599 XSETWINDOW (window
, w
);
2600 f
= XFRAME (w
->frame
);
2603 /* ROOT is the frame's root window. */
2605 root
= FRAME_ROOT_WINDOW (f
);
2609 /* ROOT must be an ancestor of WINDOW. */
2611 r
= decode_any_window (root
);
2612 pwindow
= XWINDOW (window
)->parent
;
2613 while (!NILP (pwindow
))
2614 if (EQ (pwindow
, root
))
2617 pwindow
= XWINDOW (pwindow
)->parent
;
2618 if (!EQ (pwindow
, root
))
2619 error ("Specified root is not an ancestor of specified window");
2622 if (EQ (window
, root
))
2625 /* I don't understand the "top > 0" part below. If we deal with a
2626 standalone minibuffer it would have been caught by the preceding
2628 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2629 error ("Can't expand minibuffer to full frame");
2631 if (!NILP (w
->buffer
))
2633 startpos
= marker_position (w
->start
);
2634 top
= WINDOW_TOP_EDGE_LINE (w
)
2635 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2636 /* Make sure WINDOW is the frame's selected window. */
2637 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2639 if (EQ (selected_frame
, w
->frame
))
2640 Fselect_window (window
, Qnil
);
2642 FRAME_SELECTED_WINDOW (f
) = window
;
2647 /* See if the frame's selected window is a subwindow of WINDOW, by
2648 finding all the selected window's parents and comparing each
2649 one with WINDOW. If it isn't we need a new selected window for
2651 swindow
= FRAME_SELECTED_WINDOW (f
);
2655 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2656 pwindow
= XWINDOW (pwindow
)->parent
;
2658 if (EQ (window
, pwindow
))
2659 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2660 as the new selected window. */
2663 /* Else try the previous window of SWINDOW. */
2664 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2667 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2669 if (EQ (selected_frame
, w
->frame
))
2670 Fselect_window (swindow
, Qnil
);
2672 FRAME_SELECTED_WINDOW (f
) = swindow
;
2677 free_window_matrices (r
);
2679 windows_or_buffers_changed
++;
2680 Vwindow_list
= Qnil
;
2681 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2684 if (NILP (w
->buffer
))
2686 /* Resize subwindows vertically. */
2687 XSETINT (delta
, XINT (r
->total_lines
) - XINT (w
->total_lines
));
2688 w
->top_line
= r
->top_line
;
2689 resize_root_window (window
, delta
, Qnil
, Qnil
);
2690 if (resize_window_check (w
, 0))
2691 resize_window_apply (w
, 0);
2694 resize_root_window (window
, delta
, Qnil
, Qt
);
2695 if (resize_window_check (w
, 0))
2696 resize_window_apply (w
, 0);
2701 /* Resize subwindows horizontally. */
2704 w
->left_col
= r
->left_col
;
2705 XSETINT (delta
, XINT (r
->total_cols
) - XINT (w
->total_cols
));
2706 w
->left_col
= r
->left_col
;
2707 resize_root_window (window
, delta
, Qt
, Qnil
);
2708 if (resize_window_check (w
, 1))
2709 resize_window_apply (w
, 1);
2712 resize_root_window (window
, delta
, Qt
, Qt
);
2713 if (resize_window_check (w
, 1))
2714 resize_window_apply (w
, 1);
2721 /* Play safe, if we still can ... */
2724 w
= XWINDOW (window
);
2728 /* Cleanly unlink WINDOW from window-tree. */
2729 if (!NILP (w
->prev
))
2730 /* Get SIBLING above (on the left of) WINDOW. */
2733 s
= XWINDOW (sibling
);
2735 if (!NILP (s
->next
))
2736 XWINDOW (s
->next
)->prev
= sibling
;
2739 /* Get SIBLING below (on the right of) WINDOW. */
2742 s
= XWINDOW (sibling
);
2744 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2745 XWINDOW (w
->parent
)->vchild
= sibling
;
2747 XWINDOW (w
->parent
)->hchild
= sibling
;
2750 /* Delete ROOT and all subwindows of ROOT. */
2751 if (!NILP (r
->vchild
))
2753 delete_all_subwindows (r
->vchild
);
2756 else if (!NILP (r
->hchild
))
2758 delete_all_subwindows (r
->hchild
);
2762 replace_window (root
, window
, 1);
2764 /* Reset WINDOW's splits status. */
2767 /* This must become SWINDOW anyway ....... */
2768 if (!NILP (w
->buffer
) && !resize_failed
)
2770 /* Try to minimize scrolling, by setting the window start to the
2771 point will cause the text at the old window start to be at the
2772 same place on the frame. But don't try to do this if the
2773 window start is outside the visible portion (as might happen
2774 when the display is not current, due to typeahead). */
2775 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2777 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2778 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2780 struct position pos
;
2781 struct buffer
*obuf
= current_buffer
;
2783 Fset_buffer (w
->buffer
);
2784 /* This computation used to temporarily move point, but that
2785 can have unwanted side effects due to text properties. */
2786 pos
= *vmotion (startpos
, -top
, w
);
2788 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2789 w
->window_end_valid
= Qnil
;
2790 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2791 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2793 /* We need to do this, so that the window-scroll-functions
2795 w
->optional_new_start
= Qt
;
2797 set_buffer_internal (obuf
);
2804 run_window_configuration_change_hook (f
);
2811 replace_buffer_in_windows (Lisp_Object buffer
)
2813 call1 (Qreplace_buffer_in_windows
, buffer
);
2817 /* Safely replace BUFFER with some other buffer in all windows of all
2818 frames, even those on other keyboards. */
2821 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2823 Lisp_Object tail
, frame
;
2825 /* A single call to window_loop won't do the job because it only
2826 considers frames on the current keyboard. So loop manually over
2827 frames, and handle each one. */
2828 FOR_EACH_FRAME (tail
, frame
)
2829 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2832 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2833 minimum allowable size. */
2836 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2838 /* For height, we have to see:
2839 how many windows the frame has at minimum (one or two),
2840 and whether it has a menu bar or other special stuff at the top. */
2842 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2843 ? MIN_SAFE_WINDOW_HEIGHT
2844 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2846 if (FRAME_TOP_MARGIN (frame
) > 0)
2847 min_height
+= FRAME_TOP_MARGIN (frame
);
2849 if (*rows
< min_height
)
2851 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2852 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2855 /* Adjust the margins of window W if text area is too small.
2856 Return 1 if window width is ok after adjustment; 0 if window
2857 is still too narrow. */
2860 adjust_window_margins (struct window
*w
)
2862 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2863 - WINDOW_FRINGE_COLS (w
)
2864 - WINDOW_SCROLL_BAR_COLS (w
));
2865 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2866 + WINDOW_RIGHT_MARGIN_COLS (w
));
2868 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2871 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2874 /* Window's text area is too narrow, but reducing the window
2875 margins will fix that. */
2876 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2877 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2879 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2880 w
->left_margin_cols
= w
->right_margin_cols
2881 = make_number (margin_cols
/2);
2883 w
->right_margin_cols
= make_number (margin_cols
);
2886 w
->left_margin_cols
= make_number (margin_cols
);
2890 static Lisp_Object
Fset_window_margins (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2891 static Lisp_Object
Fset_window_fringes (Lisp_Object
, Lisp_Object
, Lisp_Object
,
2893 static Lisp_Object
Fset_window_scroll_bars (Lisp_Object
, Lisp_Object
,
2894 Lisp_Object
, Lisp_Object
);
2895 static Lisp_Object
Fset_window_vscroll (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2897 /* The following three routines are needed for running a window's
2898 configuration change hook. */
2900 run_funs (Lisp_Object funs
)
2902 for (; CONSP (funs
); funs
= XCDR (funs
))
2903 if (!EQ (XCAR (funs
), Qt
))
2904 call0 (XCAR (funs
));
2908 select_window_norecord (Lisp_Object window
)
2910 return WINDOW_LIVE_P (window
)
2911 ? Fselect_window (window
, Qt
) : selected_window
;
2915 select_frame_norecord (Lisp_Object frame
)
2917 return FRAME_LIVE_P (XFRAME (frame
))
2918 ? Fselect_frame (frame
, Qt
) : selected_frame
;
2922 run_window_configuration_change_hook (struct frame
*f
)
2924 int count
= SPECPDL_INDEX ();
2925 Lisp_Object frame
, global_wcch
2926 = Fdefault_value (Qwindow_configuration_change_hook
);
2927 XSETFRAME (frame
, f
);
2929 if (NILP (Vrun_hooks
))
2932 /* Use the right buffer. Matters when running the local hooks. */
2933 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
2935 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2936 Fset_buffer (Fwindow_buffer (Qnil
));
2939 if (SELECTED_FRAME () != f
)
2941 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
2942 select_frame_norecord (frame
);
2945 /* Look for buffer-local values. */
2947 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
2948 for (; CONSP (windows
); windows
= XCDR (windows
))
2950 Lisp_Object window
= XCAR (windows
);
2951 Lisp_Object buffer
= Fwindow_buffer (window
);
2952 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
2955 int inner_count
= SPECPDL_INDEX ();
2956 record_unwind_protect (select_window_norecord
, Fselected_window ());
2957 select_window_norecord (window
);
2958 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
2960 unbind_to (inner_count
, Qnil
);
2965 run_funs (global_wcch
);
2966 unbind_to (count
, Qnil
);
2969 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
2970 Srun_window_configuration_change_hook
, 1, 1, 0,
2971 doc
: /* Run `window-configuration-change-hook' for FRAME. */)
2974 CHECK_LIVE_FRAME (frame
);
2975 run_window_configuration_change_hook (XFRAME (frame
));
2979 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2980 means it's allowed to run hooks. See make_frame for a case where
2981 it's not allowed. KEEP_MARGINS_P non-zero means that the current
2982 margins, fringes, and scroll-bar settings of the window are not
2983 reset from the buffer's local settings. */
2986 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
2988 struct window
*w
= XWINDOW (window
);
2989 struct buffer
*b
= XBUFFER (buffer
);
2990 int count
= SPECPDL_INDEX ();
2991 int samebuf
= EQ (buffer
, w
->buffer
);
2995 if (EQ (window
, selected_window
))
2996 BVAR (b
, last_selected_window
) = window
;
2998 /* Let redisplay errors through. */
2999 b
->display_error_modiff
= 0;
3001 /* Update time stamps of buffer display. */
3002 if (INTEGERP (BVAR (b
, display_count
)))
3003 XSETINT (BVAR (b
, display_count
), XINT (BVAR (b
, display_count
)) + 1);
3004 BVAR (b
, display_time
) = Fcurrent_time ();
3006 XSETFASTINT (w
->window_end_pos
, 0);
3007 XSETFASTINT (w
->window_end_vpos
, 0);
3008 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3009 w
->window_end_valid
= Qnil
;
3010 if (!(keep_margins_p
&& samebuf
))
3011 { /* If we're not actually changing the buffer, don't reset hscroll and
3012 vscroll. This case happens for example when called from
3013 change_frame_size_1, where we use a dummy call to
3014 Fset_window_buffer on the frame's selected window (and no other)
3015 just in order to run window-configuration-change-hook.
3016 Resetting hscroll and vscroll here is problematic for things like
3017 image-mode and doc-view-mode since it resets the image's position
3018 whenever we resize the frame. */
3019 w
->hscroll
= w
->min_hscroll
= make_number (0);
3021 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3022 set_marker_restricted (w
->start
,
3023 make_number (b
->last_window_start
),
3025 w
->start_at_line_beg
= Qnil
;
3026 w
->force_start
= Qnil
;
3027 XSETFASTINT (w
->last_modified
, 0);
3028 XSETFASTINT (w
->last_overlay_modified
, 0);
3030 /* Maybe we could move this into the `if' but it's not obviously safe and
3031 I doubt it's worth the trouble. */
3032 windows_or_buffers_changed
++;
3034 /* We must select BUFFER for running the window-scroll-functions. */
3035 /* We can't check ! NILP (Vwindow_scroll_functions) here
3036 because that might itself be a local variable. */
3037 if (window_initialized
)
3039 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3040 Fset_buffer (buffer
);
3043 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3045 if (!keep_margins_p
)
3047 /* Set left and right marginal area width etc. from buffer. */
3049 /* This may call adjust_window_margins three times, so
3050 temporarily disable window margins. */
3051 Lisp_Object save_left
= w
->left_margin_cols
;
3052 Lisp_Object save_right
= w
->right_margin_cols
;
3054 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3056 Fset_window_fringes (window
,
3057 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3058 BVAR (b
, fringes_outside_margins
));
3060 Fset_window_scroll_bars (window
,
3061 BVAR (b
, scroll_bar_width
),
3062 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3064 w
->left_margin_cols
= save_left
;
3065 w
->right_margin_cols
= save_right
;
3067 Fset_window_margins (window
,
3068 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3073 if (! NILP (Vwindow_scroll_functions
))
3074 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3075 Fmarker_position (w
->start
));
3076 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3079 unbind_to (count
, Qnil
);
3082 DEFUN ("set-window-clone-number", Fset_window_clone_number
, Sset_window_clone_number
, 2, 2, 0,
3083 doc
: /* Set WINDOW's clone number to CLONE-NUMBER.
3084 WINDOW can be any window and defaults to the selected one. */)
3085 (Lisp_Object window
, Lisp_Object clone_number
)
3087 register struct window
*w
= decode_any_window (window
);
3089 CHECK_NUMBER (clone_number
);
3090 w
->clone_number
= clone_number
;
3091 return w
->clone_number
;
3094 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3095 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3096 WINDOW has to be a live window and defaults to the selected one.
3097 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3099 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3100 display margins, fringe widths, and scroll bar settings are preserved;
3101 the default is to reset these from the local settings for BUFFER-OR-NAME
3102 or the frame defaults. Return nil.
3104 This function throws an error when WINDOW is strongly dedicated to its
3105 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3106 already display BUFFER-OR-NAME.
3108 This function runs `window-scroll-functions' before running
3109 `window-configuration-change-hook'. */)
3110 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3112 register Lisp_Object tem
, buffer
;
3113 register struct window
*w
= decode_window (window
);
3115 XSETWINDOW (window
, w
);
3116 buffer
= Fget_buffer (buffer_or_name
);
3117 CHECK_BUFFER (buffer
);
3118 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3119 error ("Attempt to display deleted buffer");
3123 error ("Window is deleted");
3124 else if (!EQ (tem
, Qt
))
3125 /* w->buffer is t when the window is first being set up. */
3127 if (!EQ (tem
, buffer
))
3129 if (EQ (w
->dedicated
, Qt
))
3130 /* WINDOW is strongly dedicated to its buffer, signal an
3132 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3134 /* WINDOW is weakly dedicated to its buffer, reset
3136 w
->dedicated
= Qnil
;
3138 call1 (Qrecord_window_buffer
, window
);
3144 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3150 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3152 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3155 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3157 doc
: /* Force all windows to be updated on next redisplay.
3158 If optional arg OBJECT is a window, force redisplay of that window only.
3159 If OBJECT is a buffer or buffer name, force redisplay of all windows
3160 displaying that buffer. */)
3161 (Lisp_Object object
)
3165 windows_or_buffers_changed
++;
3166 update_mode_lines
++;
3170 if (WINDOWP (object
))
3172 struct window
*w
= XWINDOW (object
);
3173 mark_window_display_accurate (object
, 0);
3174 w
->update_mode_line
= Qt
;
3175 if (BUFFERP (w
->buffer
))
3176 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3177 ++update_mode_lines
;
3181 if (STRINGP (object
))
3182 object
= Fget_buffer (object
);
3183 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3185 /* Walk all windows looking for buffer, and force update
3186 of each of those windows. */
3188 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3189 return NILP (object
) ? Qnil
: Qt
;
3192 /* If nothing suitable was found, just return.
3193 We could signal an error, but this feature will typically be used
3194 asynchronously in timers or process sentinels, so we don't. */
3200 temp_output_buffer_show (register Lisp_Object buf
)
3202 register struct buffer
*old
= current_buffer
;
3203 register Lisp_Object window
;
3204 register struct window
*w
;
3206 BVAR (XBUFFER (buf
), directory
) = BVAR (current_buffer
, directory
);
3209 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3213 set_buffer_internal (old
);
3215 if (!NILP (Vtemp_buffer_show_function
))
3216 call1 (Vtemp_buffer_show_function
, buf
);
3219 window
= display_buffer (buf
, Qnil
, Qnil
);
3221 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3222 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3223 Vminibuf_scroll_window
= window
;
3224 w
= XWINDOW (window
);
3225 XSETFASTINT (w
->hscroll
, 0);
3226 XSETFASTINT (w
->min_hscroll
, 0);
3227 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3228 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3230 /* Run temp-buffer-show-hook, with the chosen window selected
3231 and its buffer current. */
3233 int count
= SPECPDL_INDEX ();
3234 Lisp_Object prev_window
, prev_buffer
;
3235 prev_window
= selected_window
;
3236 XSETBUFFER (prev_buffer
, old
);
3238 /* Select the window that was chosen, for running the hook.
3239 Note: Both Fselect_window and select_window_norecord may
3240 set-buffer to the buffer displayed in the window,
3241 so we need to save the current buffer. --stef */
3242 record_unwind_protect (Fset_buffer
, prev_buffer
);
3243 record_unwind_protect (select_window_norecord
, prev_window
);
3244 Fselect_window (window
, Qt
);
3245 Fset_buffer (w
->buffer
);
3246 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3247 unbind_to (count
, Qnil
);
3252 DEFUN ("internal-temp-output-buffer-show",
3253 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3255 doc
: /* Internal function for `with-output-to-temp-buffer''. */)
3258 temp_output_buffer_show (buf
);
3262 /* Make new window, have it replace WINDOW in window-tree, and make
3263 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3264 horizontal child). */
3266 make_parent_window (Lisp_Object window
, int horflag
)
3269 register struct window
*o
, *p
;
3272 o
= XWINDOW (window
);
3273 p
= allocate_window ();
3274 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3275 ((struct Lisp_Vector
*) p
)->contents
[i
]
3276 = ((struct Lisp_Vector
*) o
)->contents
[i
];
3277 XSETWINDOW (parent
, p
);
3280 XSETFASTINT (p
->sequence_number
, sequence_number
);
3281 XSETFASTINT (p
->clone_number
, sequence_number
);
3283 replace_window (window
, parent
, 1);
3289 p
->hchild
= horflag
? window
: Qnil
;
3290 p
->vchild
= horflag
? Qnil
: window
;
3296 p
->window_parameters
= Qnil
;
3299 /* Make new window from scratch. */
3304 register struct window
*w
;
3306 w
= allocate_window ();
3307 /* Initialize all Lisp data. */
3308 w
->frame
= w
->mini_p
= Qnil
;
3309 w
->next
= w
->prev
= w
->hchild
= w
->vchild
= w
->parent
= Qnil
;
3310 XSETFASTINT (w
->left_col
, 0);
3311 XSETFASTINT (w
->top_line
, 0);
3312 XSETFASTINT (w
->total_lines
, 0);
3313 XSETFASTINT (w
->total_cols
, 0);
3314 w
->normal_lines
= make_float (1.0);
3315 w
->normal_cols
= make_float (1.0);
3316 XSETFASTINT (w
->new_total
, 0);
3317 XSETFASTINT (w
->new_normal
, 0);
3319 w
->start
= Fmake_marker ();
3320 w
->pointm
= Fmake_marker ();
3321 w
->force_start
= w
->optional_new_start
= Qnil
;
3322 XSETFASTINT (w
->hscroll
, 0);
3323 XSETFASTINT (w
->min_hscroll
, 0);
3324 XSETFASTINT (w
->use_time
, 0);
3326 XSETFASTINT (w
->sequence_number
, sequence_number
);
3327 XSETFASTINT (w
->clone_number
, sequence_number
);
3328 w
->temslot
= w
->last_modified
= w
->last_overlay_modified
= Qnil
;
3329 XSETFASTINT (w
->last_point
, 0);
3330 w
->last_had_star
= w
->vertical_scroll_bar
= Qnil
;
3331 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3332 w
->left_fringe_width
= w
->right_fringe_width
= Qnil
;
3333 w
->fringes_outside_margins
= Qnil
;
3334 w
->scroll_bar_width
= Qnil
;
3335 w
->vertical_scroll_bar_type
= Qt
;
3336 w
->last_mark_x
= w
->last_mark_y
= Qnil
;
3337 XSETFASTINT (w
->window_end_pos
, 0);
3338 XSETFASTINT (w
->window_end_vpos
, 0);
3339 w
->window_end_valid
= w
->update_mode_line
= Qnil
;
3340 w
->start_at_line_beg
= w
->display_table
= w
->dedicated
= Qnil
;
3341 w
->base_line_number
= w
->base_line_pos
= w
->region_showing
= Qnil
;
3342 w
->column_number_displayed
= w
->redisplay_end_trigger
= Qnil
;
3343 w
->splits
= w
->nest
= w
->window_parameters
= Qnil
;
3344 w
->prev_buffers
= w
->next_buffers
= Qnil
;
3345 /* Initialize non-Lisp data. */
3346 w
->desired_matrix
= w
->current_matrix
= 0;
3347 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3348 memset (&w
->cursor
, 0, sizeof (w
->cursor
));
3349 memset (&w
->last_cursor
, 0, sizeof (w
->last_cursor
));
3350 memset (&w
->phys_cursor
, 0, sizeof (w
->phys_cursor
));
3351 w
->phys_cursor_type
= -1;
3352 w
->phys_cursor_width
= -1;
3353 w
->last_cursor_off_p
= w
->cursor_off_p
= 0;
3354 w
->must_be_updated_p
= 0;
3355 w
->pseudo_window_p
= 0;
3356 w
->frozen_window_start_p
= 0;
3358 /* Reset window_list. */
3359 Vwindow_list
= Qnil
;
3360 /* Return window. */
3361 XSETWINDOW (window
, w
);
3365 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3366 doc
: /* Set new total size of WINDOW to SIZE.
3369 Optional argument ADD non-nil means add SIZE to the new total size of
3370 WINDOW and return the sum.
3372 Note: This function does not operate on any subwindows of WINDOW. */)
3373 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3375 struct window
*w
= decode_any_window (window
);
3377 CHECK_NUMBER (size
);
3379 XSETINT (w
->new_total
, XINT (size
));
3381 XSETINT (w
->new_total
, XINT (w
->new_total
) + XINT (size
));
3383 return w
->new_total
;
3386 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3387 doc
: /* Set new normal size of WINDOW to SIZE.
3390 Note: This function does not operate on any subwindows of WINDOW. */)
3391 (Lisp_Object window
, Lisp_Object size
)
3393 struct window
*w
= decode_any_window (window
);
3395 w
->new_normal
= size
;
3396 return w
->new_normal
;
3399 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3400 non-zero) to w->new_total would result in correct heights (widths)
3401 for window W and recursively all subwindows of W.
3403 Note: This function does not check any of `window-fixed-size-p',
3404 `window-min-height' or `window-min-width'. It does check that window
3405 sizes do not drop below one line (two columns). */
3407 resize_window_check (struct window
*w
, int horflag
)
3411 if (!NILP (w
->vchild
))
3412 /* W is a vertical combination. */
3414 c
= XWINDOW (w
->vchild
);
3416 /* All subwindows of W must have the same width as W. */
3420 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3421 || !resize_window_check (c
, horflag
))
3423 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3428 /* The sum of the heights of the subwindows of W must equal W's
3431 int sum_of_sizes
= 0;
3434 if (!resize_window_check (c
, horflag
))
3436 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3437 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3439 return (sum_of_sizes
== XINT (w
->new_total
));
3442 else if (!NILP (w
->hchild
))
3443 /* W is a horizontal combination. */
3445 c
= XWINDOW (w
->hchild
);
3447 /* The sum of the widths of the subwindows of W must equal W's
3450 int sum_of_sizes
= 0;
3453 if (!resize_window_check (c
, horflag
))
3455 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3456 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3458 return (sum_of_sizes
== XINT (w
->new_total
));
3461 /* All subwindows of W must have the same height as W. */
3465 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3466 || !resize_window_check (c
, horflag
))
3468 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3474 /* A leaf window. Make sure it's not too small. The following
3475 hardcodes the values of `window-safe-min-width' (2) and
3476 `window-safe-min-height' (1) which are defined in window.el. */
3477 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3480 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3481 w->new_total for window W and recursively all subwindows of W. Also
3482 calculate and assign the new vertical (horizontal) start positions of
3483 each of these windows.
3485 This function does not perform any error checks. Make sure you have
3486 run resize_window_check on W before applying this function. */
3488 resize_window_apply (struct window
*w
, int horflag
)
3493 /* Note: Assigning new_normal requires that the new total size of the
3494 parent window has been set *before*. */
3497 w
->total_cols
= w
->new_total
;
3498 if (NUMBERP (w
->new_normal
))
3499 w
->normal_cols
= w
->new_normal
;
3501 pos
= XINT (w
->left_col
);
3505 w
->total_lines
= w
->new_total
;
3506 if (NUMBERP (w
->new_normal
))
3507 w
->normal_lines
= w
->new_normal
;
3509 pos
= XINT (w
->top_line
);
3512 if (!NILP (w
->vchild
))
3513 /* W is a vertical combination. */
3515 c
= XWINDOW (w
->vchild
);
3519 XSETFASTINT (c
->left_col
, pos
);
3521 XSETFASTINT (c
->top_line
, pos
);
3522 resize_window_apply (c
, horflag
);
3524 pos
= pos
+ XINT (c
->total_lines
);
3525 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3528 else if (!NILP (w
->hchild
))
3529 /* W is a horizontal combination. */
3531 c
= XWINDOW (w
->hchild
);
3535 XSETFASTINT (c
->left_col
, pos
);
3537 XSETFASTINT (c
->top_line
, pos
);
3538 resize_window_apply (c
, horflag
);
3540 pos
= pos
+ XINT (c
->total_cols
);
3541 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3545 /* Clear out some redisplay caches. */
3546 XSETFASTINT (w
->last_modified
, 0);
3547 XSETFASTINT (w
->last_overlay_modified
, 0);
3551 DEFUN ("resize-window-apply", Fresize_window_apply
, Sresize_window_apply
, 1, 2, 0,
3552 doc
: /* Apply requested size values for window-tree of FRAME.
3553 Optional argument HORIZONTAL omitted or nil means apply requested height
3554 values. HORIZONTAL non-nil means apply requested width values.
3556 This function checks whether the requested values sum up to a valid
3557 window layout, recursively assigns the new sizes of all subwindows and
3558 calculates and assigns the new start positions of these windows.
3560 Note: This function does not check any of `window-fixed-size-p',
3561 `window-min-height' or `window-min-width'. All these checks have to
3562 be applied on the Elisp level. */)
3563 (Lisp_Object frame
, Lisp_Object horizontal
)
3567 int horflag
= !NILP (horizontal
);
3570 frame
= selected_frame
;
3571 CHECK_LIVE_FRAME (frame
);
3574 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3576 if (!resize_window_check (r
, horflag
)
3577 || ! EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3581 resize_window_apply (r
, horflag
);
3583 windows_or_buffers_changed
++;
3584 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3589 run_window_configuration_change_hook (f
);
3595 /* Resize frame F's windows when number of lines of F is set to SIZE.
3596 HORFLAG 1 means resize windows when number of columns of F is set to
3599 This function can delete all windows but the selected one in order to
3600 satisfy the request. The result will be meaningful if and only if
3601 F's windows have meaningful sizes when you call this. */
3603 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3605 Lisp_Object root
= f
->root_window
;
3606 struct window
*r
= XWINDOW (root
);
3607 Lisp_Object mini
= f
->minibuffer_window
;
3609 /* new_size is the new size of the frame's root window. */
3610 int new_size
= (horflag
3613 - FRAME_TOP_MARGIN (f
)
3614 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3617 XSETFASTINT (r
->top_line
, FRAME_TOP_MARGIN (f
));
3618 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3619 /* For a leaf root window just set the size. */
3621 XSETFASTINT (r
->total_cols
, new_size
);
3623 XSETFASTINT (r
->total_lines
, new_size
);
3626 /* old_size is the old size of the frame's root window. */
3627 int old_size
= XFASTINT (horflag
? r
->total_cols
: r
->total_lines
);
3630 XSETINT (delta
, new_size
- old_size
);
3631 /* Try a "normal" resize first. */
3632 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3633 if (resize_window_check (r
, horflag
) && new_size
== XINT (r
->new_total
))
3634 resize_window_apply (r
, horflag
);
3637 /* Try with "reasonable" minimum sizes next. */
3638 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3639 if (resize_window_check (r
, horflag
)
3640 && new_size
== XINT (r
->new_total
))
3641 resize_window_apply (r
, horflag
);
3644 /* Finally, try with "safe" minimum sizes. */
3645 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3646 if (resize_window_check (r
, horflag
)
3647 && new_size
== XINT (r
->new_total
))
3648 resize_window_apply (r
, horflag
);
3651 /* We lost. Delete all windows but the frame's
3653 root
= f
->selected_window
;
3654 Fdelete_other_windows_internal (root
, Qnil
);
3656 XSETFASTINT (XWINDOW (root
)->total_cols
, new_size
);
3658 XSETFASTINT (XWINDOW (root
)->total_lines
, new_size
);
3664 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3668 XSETFASTINT (m
->total_cols
, size
);
3671 /* Are we sure we always want 1 line here? */
3672 XSETFASTINT (m
->total_lines
, 1);
3673 XSETFASTINT (m
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
3679 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3680 doc
: /* Split window OLD.
3681 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3682 new window. In any case TOTAL-SIZE must be a positive integer.
3684 Third argument SIDE nil (or `below') specifies that the new window shall
3685 be located below WINDOW. SIDE `above' means the new window shall be
3686 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3687 lines of the new window including space reserved for the mode and/or
3690 SIDE t (or `right') specifies that the new window shall be located on
3691 the right side of WINDOW. SIDE `left' means the new window shall be
3692 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3693 number of columns of the new window including space reserved for fringes
3694 and the scrollbar or a divider column.
3696 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3697 according to the SIDE argument.
3699 The new total and normal sizes of all involved windows must have been
3700 set correctly. See the code of `split-window' for how this is done. */)
3701 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3703 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3704 parent window or an internal window we have to install as OLD's new
3705 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3706 provided OLD is a leaf window, or to the frame's selected window.
3707 NEW (*n) is the new window created with some parameters taken from
3709 register Lisp_Object
new, frame
, reference
;
3710 register struct window
*o
, *p
, *n
, *r
;
3713 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3714 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3719 frame
= WINDOW_FRAME (o
);
3722 CHECK_NUMBER (total_size
);
3724 /* Set do_nest to 1 if we have to make a new parent window. We do
3725 that if either `window-nest' is non-nil, or OLD has no parent, or
3726 OLD is ortho-combined. */
3728 !NILP (Vwindow_nest
)
3731 ? (XWINDOW (o
->parent
)->hchild
)
3732 : (XWINDOW (o
->parent
)->vchild
));
3734 /* We need a live reference window to initialize some parameters. */
3735 if (WINDOW_LIVE_P (old
))
3736 /* OLD is live, use it as reference window. */
3739 /* Use the frame's selected window as reference window. */
3740 reference
= FRAME_SELECTED_WINDOW (f
);
3741 r
= XWINDOW (reference
);
3743 /* The following bugs are caught by `split-window'. */
3744 if (MINI_WINDOW_P (o
))
3745 error ("Attempt to split minibuffer window");
3746 else if (XINT (total_size
) < (horflag
? 2 : 1))
3747 error ("Size of new window too small (after split)");
3748 else if (!do_nest
&& !NILP (Vwindow_splits
))
3749 /* `window-splits' non-nil means try to resize OLD's siblings
3752 p
= XWINDOW (o
->parent
);
3753 /* Temporarily pretend we split the parent window. */
3754 XSETINT (p
->new_total
,
3755 XINT (horflag
? p
->total_cols
: p
->total_lines
)
3756 - XINT (total_size
));
3757 if (!resize_window_check (p
, horflag
))
3758 error ("Window sizes don't fit");
3760 /* Undo the temporary pretension. */
3761 p
->new_total
= horflag
? p
->total_cols
: p
->total_lines
;
3765 if (!resize_window_check (o
, horflag
))
3766 error ("Resizing old window failed");
3767 else if (XINT (total_size
) + XINT (o
->new_total
)
3768 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3769 error ("Sum of sizes of old and new window don't fit");
3772 /* This is our point of no return. */
3775 /* Save the old value of o->normal_cols/lines. It gets corrupted
3776 by make_parent_window and we need it below for assigning it to
3778 Lisp_Object new_normal
= horflag
? o
->normal_cols
: o
->normal_lines
;
3780 make_parent_window (old
, horflag
);
3781 p
= XWINDOW (o
->parent
);
3782 /* Store value of `window-nest' in new parent's nest slot. */
3783 p
->nest
= Vwindow_nest
;
3784 /* Have PARENT inherit splits slot value from OLD. */
3785 p
->splits
= o
->splits
;
3786 /* Store value of `window-splits' in OLD's splits slot. */
3787 o
->splits
= Vwindow_splits
;
3788 /* These get applied below. */
3789 p
->new_total
= horflag
? o
->total_cols
: o
->total_lines
;
3790 p
->new_normal
= new_normal
;
3793 p
= XWINDOW (o
->parent
);
3795 windows_or_buffers_changed
++;
3796 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3797 new = make_window ();
3800 n
->parent
= o
->parent
;
3801 n
->vchild
= n
->hchild
= Qnil
;
3803 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3812 XWINDOW (n
->prev
)->next
= new;
3819 if (!NILP (n
->next
))
3820 XWINDOW (n
->next
)->prev
= new;
3826 n
->window_end_valid
= Qnil
;
3827 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3829 /* Get special geometry settings from reference window. */
3830 n
->left_margin_cols
= r
->left_margin_cols
;
3831 n
->right_margin_cols
= r
->right_margin_cols
;
3832 n
->left_fringe_width
= r
->left_fringe_width
;
3833 n
->right_fringe_width
= r
->right_fringe_width
;
3834 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3835 n
->scroll_bar_width
= r
->scroll_bar_width
;
3836 n
->vertical_scroll_bar_type
= r
->vertical_scroll_bar_type
;
3838 /* Store `window-splits' in NEW's splits slot. */
3839 n
->splits
= Vwindow_splits
;
3841 /* Directly assign orthogonal coordinates and sizes. */
3844 n
->top_line
= o
->top_line
;
3845 n
->total_lines
= o
->total_lines
;
3849 n
->left_col
= o
->left_col
;
3850 n
->total_cols
= o
->total_cols
;
3853 /* Iso-coordinates and sizes are assigned by resize_window_apply,
3854 get them ready here. */
3855 n
->new_total
= total_size
;
3856 n
->new_normal
= normal_size
;
3859 resize_window_apply (p
, horflag
);
3861 /* Set buffer of NEW to buffer of reference window. Don't run
3863 set_window_buffer (new, r
->buffer
, 0, 1);
3866 /* Maybe we should run the scroll functions in Elisp (which already
3867 runs the configuration change hook). */
3868 if (! NILP (Vwindow_scroll_functions
))
3869 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3870 Fmarker_position (n
->start
));
3876 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3877 doc
: /* Remove WINDOW from its frame.
3878 WINDOW defaults to the selected window. Return nil. Signal an error
3879 when WINDOW is the only window on its frame. */)
3880 (register Lisp_Object window
)
3882 register Lisp_Object parent
, sibling
, frame
, root
;
3883 struct window
*w
, *p
, *s
, *r
;
3886 int before_sibling
= 0;
3888 w
= decode_any_window (window
);
3889 XSETWINDOW (window
, w
);
3890 if (NILP (w
->buffer
) && NILP (w
->hchild
) && NILP (w
->vchild
))
3891 /* It's a no-op to delete an already deleted window. */
3896 /* Never delete a minibuffer or frame root window. */
3897 error ("Attempt to delete minibuffer or sole ordinary window");
3898 else if (NILP (w
->prev
) && NILP (w
->next
))
3899 /* Rather bow out here, this case should be handled on the Elisp
3901 error ("Attempt to delete sole window of parent");
3903 p
= XWINDOW (parent
);
3904 horflag
= NILP (p
->vchild
);
3906 frame
= WINDOW_FRAME (w
);
3909 root
= FRAME_ROOT_WINDOW (f
);
3912 /* Unlink WINDOW from window tree. */
3914 /* Get SIBLING below (on the right of) WINDOW. */
3916 /* before_sibling 1 means WINDOW is the first child of its
3917 parent and thus before the sibling. */
3920 s
= XWINDOW (sibling
);
3923 p
->hchild
= sibling
;
3925 p
->vchild
= sibling
;
3928 /* Get SIBLING above (on the left of) WINDOW. */
3931 s
= XWINDOW (sibling
);
3933 if (!NILP (s
->next
))
3934 XWINDOW (s
->next
)->prev
= sibling
;
3937 if (resize_window_check (r
, horflag
)
3938 && EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3939 /* We can delete WINDOW now. */
3943 resize_window_apply (p
, horflag
);
3945 windows_or_buffers_changed
++;
3946 Vwindow_list
= Qnil
;
3947 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3949 w
->next
= Qnil
; /* Don't delete w->next too. */
3950 free_window_matrices (w
);
3952 if (!NILP (w
->vchild
))
3954 delete_all_subwindows (w
->vchild
);
3957 else if (!NILP (w
->hchild
))
3959 delete_all_subwindows (w
->hchild
);
3962 else if (!NILP (w
->buffer
))
3965 unchain_marker (XMARKER (w
->pointm
));
3966 unchain_marker (XMARKER (w
->start
));
3970 if (NILP (s
->prev
) && NILP (s
->next
))
3971 /* A matrjoshka where SIBLING has become the only child of
3974 /* Put SIBLING into PARENT's place. */
3975 replace_window (parent
, sibling
, 0);
3976 /* Have SIBLING inherit the following three slot values from
3977 PARENT (the nest slot is not inherited). */
3978 s
->normal_cols
= p
->normal_cols
;
3979 s
->normal_lines
= p
->normal_lines
;
3980 s
->splits
= p
->splits
;
3981 /* Mark PARENT as deleted. */
3982 p
->vchild
= p
->hchild
= Qnil
;
3983 /* Try to merge SIBLING into its new parent. */
3984 recombine_windows (sibling
);
3989 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
3990 /* We deleted the frame's selected window. */
3992 /* Use the frame's first window as fallback ... */
3993 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
3994 /* ... but preferably use its most recently used window. */
3995 Lisp_Object mru_window
;
3997 /* `get-mru-window' might fail for some reason so play it safe
3998 - promote the first window _without recording it_ first. */
3999 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4000 Fselect_window (new_selected_window
, Qt
);
4002 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
4006 /* Now look whether `get-mru-window' gets us something. */
4007 mru_window
= call1 (Qget_mru_window
, frame
);
4008 if (WINDOW_LIVE_P (mru_window
)
4009 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4010 new_selected_window
= mru_window
;
4012 /* If all ended up well, we now promote the mru window. */
4013 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4014 Fselect_window (new_selected_window
, Qnil
);
4016 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
4021 /* Must be run by the caller:
4022 run_window_configuration_change_hook (f); */
4025 /* We failed: Relink WINDOW into window tree. */
4038 if (!NILP (w
->next
))
4039 XWINDOW (w
->next
)->prev
= window
;
4041 error ("Deletion failed");
4047 /***********************************************************************
4048 Resizing Mini-Windows
4049 ***********************************************************************/
4051 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4054 grow_mini_window (struct window
*w
, int delta
)
4056 struct frame
*f
= XFRAME (w
->frame
);
4058 Lisp_Object root
, value
;
4060 xassert (MINI_WINDOW_P (w
));
4061 xassert (delta
>= 0);
4063 root
= FRAME_ROOT_WINDOW (f
);
4065 value
= call2 (Qresize_root_window_vertically
, root
, make_number (- delta
));
4066 if (INTEGERP (value
) && resize_window_check (r
, 0))
4069 resize_window_apply (r
, 0);
4071 /* Grow the mini-window. */
4072 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4073 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - XINT (value
));
4074 XSETFASTINT (w
->last_modified
, 0);
4075 XSETFASTINT (w
->last_overlay_modified
, 0);
4083 /* Shrink mini-window W. */
4085 shrink_mini_window (struct window
*w
)
4087 struct frame
*f
= XFRAME (w
->frame
);
4089 Lisp_Object root
, value
;
4092 xassert (MINI_WINDOW_P (w
));
4094 size
= XINT (w
->total_lines
);
4097 root
= FRAME_ROOT_WINDOW (f
);
4099 value
= call2 (Qresize_root_window_vertically
,
4100 root
, make_number (size
- 1));
4101 if (INTEGERP (value
) && resize_window_check (r
, 0))
4104 resize_window_apply (r
, 0);
4106 /* Shrink the mini-window. */
4107 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4108 XSETFASTINT (w
->total_lines
, 1);
4110 XSETFASTINT (w
->last_modified
, 0);
4111 XSETFASTINT (w
->last_overlay_modified
, 0);
4116 /* If the above failed for whatever strange reason we must make a
4117 one window frame here. The same routine will be needed when
4118 shrinking the frame (and probably when making the initial
4119 *scratch* window). For the moment leave things as they are. */
4123 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4124 doc
: /* Resize minibuffer window WINDOW. */)
4125 (Lisp_Object window
)
4127 struct window
*w
= XWINDOW (window
);
4132 CHECK_WINDOW (window
);
4133 f
= XFRAME (w
->frame
);
4135 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4136 error ("Not a valid minibuffer window");
4137 else if (FRAME_MINIBUF_ONLY_P (f
))
4138 error ("Cannot resize a minibuffer-only frame");
4140 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4141 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4142 if (resize_window_check (r
, 0)
4143 && XINT (w
->new_total
) > 0
4144 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4147 resize_window_apply (r
, 0);
4149 w
->total_lines
= w
->new_total
;
4150 XSETFASTINT (w
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
4152 windows_or_buffers_changed
++;
4153 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4157 run_window_configuration_change_hook (f
);
4160 else error ("Failed to resize minibuffer window");
4163 /* Mark window cursors off for all windows in the window tree rooted
4164 at W by setting their phys_cursor_on_p flag to zero. Called from
4165 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4166 the frame are cleared. */
4169 mark_window_cursors_off (struct window
*w
)
4173 if (!NILP (w
->hchild
))
4174 mark_window_cursors_off (XWINDOW (w
->hchild
));
4175 else if (!NILP (w
->vchild
))
4176 mark_window_cursors_off (XWINDOW (w
->vchild
));
4178 w
->phys_cursor_on_p
= 0;
4180 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4185 /* Return number of lines of text (not counting mode lines) in W. */
4188 window_internal_height (struct window
*w
)
4190 int ht
= XFASTINT (w
->total_lines
);
4192 if (!MINI_WINDOW_P (w
))
4194 if (!NILP (w
->parent
)
4195 || !NILP (w
->vchild
)
4196 || !NILP (w
->hchild
)
4199 || WINDOW_WANTS_MODELINE_P (w
))
4202 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4209 /************************************************************************
4211 ***********************************************************************/
4213 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4214 N screen-fulls, which is defined as the height of the window minus
4215 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4216 instead. Negative values of N mean scroll down. NOERROR non-zero
4217 means don't signal an error if we try to move over BEGV or ZV,
4221 window_scroll (Lisp_Object window
, int n
, int whole
, int noerror
)
4225 /* If we must, use the pixel-based version which is much slower than
4226 the line-based one but can handle varying line heights. */
4227 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4228 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4230 window_scroll_line_based (window
, n
, whole
, noerror
);
4236 /* Implementation of window_scroll that works based on pixel line
4237 heights. See the comment of window_scroll for parameter
4241 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4244 struct window
*w
= XWINDOW (window
);
4245 struct text_pos start
;
4246 int this_scroll_margin
;
4247 /* True if we fiddled the window vscroll field without really scrolling. */
4249 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4251 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4253 /* If PT is not visible in WINDOW, move back one half of
4254 the screen. Allow PT to be partially visible, otherwise
4255 something like (scroll-down 1) with PT in the line before
4256 the partially visible one would recenter. */
4258 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4260 /* Move backward half the height of the window. Performance note:
4261 vmotion used here is about 10% faster, but would give wrong
4262 results for variable height lines. */
4263 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4264 it
.current_y
= it
.last_visible_y
;
4265 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4267 /* The function move_iterator_vertically may move over more than
4268 the specified y-distance. If it->w is small, e.g. a
4269 mini-buffer window, we may end up in front of the window's
4270 display area. This is the case when Start displaying at the
4271 start of the line containing PT in this case. */
4272 if (it
.current_y
<= 0)
4274 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4275 move_it_vertically_backward (&it
, 0);
4279 start
= it
.current
.pos
;
4281 else if (auto_window_vscroll_p
)
4283 if (rtop
|| rbot
) /* partially visible */
4286 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4288 dy
= max ((window_box_height (w
)
4289 - next_screen_context_lines
* dy
),
4295 /* Only vscroll backwards if already vscrolled forwards. */
4296 if (w
->vscroll
< 0 && rtop
> 0)
4298 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4299 Fset_window_vscroll (window
, make_number (px
), Qt
);
4305 /* Do vscroll if already vscrolled or only display line. */
4306 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4308 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4309 Fset_window_vscroll (window
, make_number (px
), Qt
);
4313 /* Maybe modify window start instead of scrolling. */
4314 if (rbot
> 0 || w
->vscroll
< 0)
4318 Fset_window_vscroll (window
, make_number (0), Qt
);
4319 /* If there are other text lines above the current row,
4320 move window start to current row. Else to next row. */
4322 spos
= XINT (Fline_beginning_position (Qnil
));
4324 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4325 set_marker_restricted (w
->start
, make_number (spos
),
4327 w
->start_at_line_beg
= Qt
;
4328 w
->update_mode_line
= Qt
;
4329 XSETFASTINT (w
->last_modified
, 0);
4330 XSETFASTINT (w
->last_overlay_modified
, 0);
4331 /* Set force_start so that redisplay_window will run the
4332 window-scroll-functions. */
4333 w
->force_start
= Qt
;
4338 /* Cancel previous vscroll. */
4339 Fset_window_vscroll (window
, make_number (0), Qt
);
4342 /* If scroll_preserve_screen_position is non-nil, we try to set
4343 point in the same window line as it is now, so get that line. */
4344 if (!NILP (Vscroll_preserve_screen_position
))
4346 /* We preserve the goal pixel coordinate across consecutive
4347 calls to scroll-up, scroll-down and other commands that
4348 have the `scroll-command' property. This avoids the
4349 possibility of point becoming "stuck" on a tall line when
4350 scrolling by one line. */
4351 if (window_scroll_pixel_based_preserve_y
< 0
4352 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4353 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4355 start_display (&it
, w
, start
);
4356 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4357 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4358 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4362 window_scroll_pixel_based_preserve_y
4363 = window_scroll_pixel_based_preserve_x
= -1;
4365 /* Move iterator it from start the specified distance forward or
4366 backward. The result is the new window start. */
4367 start_display (&it
, w
, start
);
4370 EMACS_INT start_pos
= IT_CHARPOS (it
);
4371 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4372 dy
= max ((window_box_height (w
)
4373 - next_screen_context_lines
* dy
),
4376 /* Note that move_it_vertically always moves the iterator to the
4377 start of a line. So, if the last line doesn't have a newline,
4378 we would end up at the start of the line ending at ZV. */
4381 move_it_vertically_backward (&it
, -dy
);
4382 /* Ensure we actually do move, e.g. in case we are currently
4383 looking at an image that is taller that the window height. */
4384 while (start_pos
== IT_CHARPOS (it
)
4385 && start_pos
> BEGV
)
4386 move_it_by_lines (&it
, -1);
4390 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4391 MOVE_TO_POS
| MOVE_TO_Y
);
4392 /* Ensure we actually do move, e.g. in case we are currently
4393 looking at an image that is taller that the window height. */
4394 while (start_pos
== IT_CHARPOS (it
)
4396 move_it_by_lines (&it
, 1);
4400 move_it_by_lines (&it
, n
);
4402 /* We failed if we find ZV is already on the screen (scrolling up,
4403 means there's nothing past the end), or if we can't start any
4404 earlier (scrolling down, means there's nothing past the top). */
4405 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4406 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4408 if (IT_CHARPOS (it
) == ZV
)
4410 if (it
.current_y
< it
.last_visible_y
4411 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4412 > it
.last_visible_y
))
4414 /* The last line was only partially visible, make it fully
4416 w
->vscroll
= (it
.last_visible_y
4417 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4418 adjust_glyphs (it
.f
);
4422 else if (n
< 0) /* could happen with empty buffers */
4423 xsignal0 (Qbeginning_of_buffer
);
4425 xsignal0 (Qend_of_buffer
);
4429 if (w
->vscroll
!= 0)
4430 /* The first line was only partially visible, make it fully
4436 xsignal0 (Qbeginning_of_buffer
);
4439 /* If control gets here, then we vscrolled. */
4441 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4443 /* Don't try to change the window start below. */
4449 EMACS_INT pos
= IT_CHARPOS (it
);
4452 /* If in the middle of a multi-glyph character move forward to
4453 the next character. */
4454 if (in_display_vector_p (&it
))
4457 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4460 /* Set the window start, and set up the window for redisplay. */
4461 set_marker_restricted (w
->start
, make_number (pos
),
4463 bytepos
= XMARKER (w
->start
)->bytepos
;
4464 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4466 w
->update_mode_line
= Qt
;
4467 XSETFASTINT (w
->last_modified
, 0);
4468 XSETFASTINT (w
->last_overlay_modified
, 0);
4469 /* Set force_start so that redisplay_window will run the
4470 window-scroll-functions. */
4471 w
->force_start
= Qt
;
4474 /* The rest of this function uses current_y in a nonstandard way,
4475 not including the height of the header line if any. */
4476 it
.current_y
= it
.vpos
= 0;
4478 /* Move PT out of scroll margins.
4479 This code wants current_y to be zero at the window start position
4480 even if there is a header line. */
4481 this_scroll_margin
= max (0, scroll_margin
);
4482 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4483 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4487 /* We moved the window start towards ZV, so PT may be now
4488 in the scroll margin at the top. */
4489 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4490 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4491 && (NILP (Vscroll_preserve_screen_position
)
4492 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4493 /* We found PT at a legitimate height. Leave it alone. */
4495 else if (window_scroll_pixel_based_preserve_y
>= 0)
4497 /* If we have a header line, take account of it.
4498 This is necessary because we set it.current_y to 0, above. */
4499 move_it_to (&it
, -1,
4500 window_scroll_pixel_based_preserve_x
,
4501 window_scroll_pixel_based_preserve_y
4502 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4503 -1, MOVE_TO_Y
| MOVE_TO_X
);
4504 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4508 while (it
.current_y
< this_scroll_margin
)
4510 int prev
= it
.current_y
;
4511 move_it_by_lines (&it
, 1);
4512 if (prev
== it
.current_y
)
4515 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4520 EMACS_INT charpos
, bytepos
;
4523 /* Save our position, for the
4524 window_scroll_pixel_based_preserve_y case. */
4525 charpos
= IT_CHARPOS (it
);
4526 bytepos
= IT_BYTEPOS (it
);
4528 /* We moved the window start towards BEGV, so PT may be now
4529 in the scroll margin at the bottom. */
4530 move_it_to (&it
, PT
, -1,
4531 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4532 - this_scroll_margin
- 1),
4534 MOVE_TO_POS
| MOVE_TO_Y
);
4536 /* Save our position, in case it's correct. */
4537 charpos
= IT_CHARPOS (it
);
4538 bytepos
= IT_BYTEPOS (it
);
4540 /* See if point is on a partially visible line at the end. */
4541 if (it
.what
== IT_EOB
)
4542 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4545 move_it_by_lines (&it
, 1);
4546 partial_p
= it
.current_y
> it
.last_visible_y
;
4549 if (charpos
== PT
&& !partial_p
4550 && (NILP (Vscroll_preserve_screen_position
)
4551 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4552 /* We found PT before we found the display margin, so PT is ok. */
4554 else if (window_scroll_pixel_based_preserve_y
>= 0)
4556 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4557 start_display (&it
, w
, start
);
4558 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4559 here because we called start_display again and did not
4560 alter it.current_y this time. */
4561 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4562 window_scroll_pixel_based_preserve_y
, -1,
4563 MOVE_TO_Y
| MOVE_TO_X
);
4564 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4569 /* The last line was only partially visible, so back up two
4570 lines to make sure we're on a fully visible line. */
4572 move_it_by_lines (&it
, -2);
4573 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4576 /* No, the position we saved is OK, so use it. */
4577 SET_PT_BOTH (charpos
, bytepos
);
4583 /* Implementation of window_scroll that works based on screen lines.
4584 See the comment of window_scroll for parameter descriptions. */
4587 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4589 register struct window
*w
= XWINDOW (window
);
4590 /* Fvertical_motion enters redisplay, which can trigger
4591 fontification, which in turn can modify buffer text (e.g., if the
4592 fontification functions replace escape sequences with faces, as
4593 in `grep-mode-font-lock-keywords'). So we use a marker to record
4594 the old point position, to prevent crashes in SET_PT_BOTH. */
4595 Lisp_Object opoint_marker
= Fpoint_marker ();
4596 register EMACS_INT pos
, pos_byte
;
4597 register int ht
= window_internal_height (w
);
4598 register Lisp_Object tem
;
4602 Lisp_Object original_pos
= Qnil
;
4604 /* If scrolling screen-fulls, compute the number of lines to
4605 scroll from the window's height. */
4607 n
*= max (1, ht
- next_screen_context_lines
);
4609 startpos
= marker_position (w
->start
);
4611 if (!NILP (Vscroll_preserve_screen_position
))
4613 if (window_scroll_preserve_vpos
<= 0
4614 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4615 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4617 struct position posit
4618 = *compute_motion (startpos
, 0, 0, 0,
4620 -1, XINT (w
->hscroll
),
4622 window_scroll_preserve_vpos
= posit
.vpos
;
4623 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
4626 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4627 make_number (window_scroll_preserve_vpos
));
4630 XSETFASTINT (tem
, PT
);
4631 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4635 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4640 lose
= n
< 0 && PT
== BEGV
;
4641 Fvertical_motion (make_number (n
), window
);
4645 SET_PT_BOTH (marker_position (opoint_marker
),
4646 marker_byte_position (opoint_marker
));
4653 xsignal0 (Qbeginning_of_buffer
);
4658 int this_scroll_margin
= scroll_margin
;
4660 /* Don't use a scroll margin that is negative or too large. */
4661 if (this_scroll_margin
< 0)
4662 this_scroll_margin
= 0;
4664 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
4665 this_scroll_margin
= XINT (w
->total_lines
) / 4;
4667 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4668 w
->start_at_line_beg
= bolp
;
4669 w
->update_mode_line
= Qt
;
4670 XSETFASTINT (w
->last_modified
, 0);
4671 XSETFASTINT (w
->last_overlay_modified
, 0);
4672 /* Set force_start so that redisplay_window will run
4673 the window-scroll-functions. */
4674 w
->force_start
= Qt
;
4676 if (!NILP (Vscroll_preserve_screen_position
)
4677 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4679 SET_PT_BOTH (pos
, pos_byte
);
4680 Fvertical_motion (original_pos
, window
);
4682 /* If we scrolled forward, put point enough lines down
4683 that it is outside the scroll margin. */
4688 if (this_scroll_margin
> 0)
4690 SET_PT_BOTH (pos
, pos_byte
);
4691 Fvertical_motion (make_number (this_scroll_margin
), window
);
4697 if (top_margin
<= marker_position (opoint_marker
))
4698 SET_PT_BOTH (marker_position (opoint_marker
),
4699 marker_byte_position (opoint_marker
));
4700 else if (!NILP (Vscroll_preserve_screen_position
))
4702 SET_PT_BOTH (pos
, pos_byte
);
4703 Fvertical_motion (original_pos
, window
);
4706 SET_PT (top_margin
);
4712 /* If we scrolled backward, put point near the end of the window
4713 but not within the scroll margin. */
4714 SET_PT_BOTH (pos
, pos_byte
);
4715 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4716 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4719 bottom_margin
= PT
+ 1;
4721 if (bottom_margin
> marker_position (opoint_marker
))
4722 SET_PT_BOTH (marker_position (opoint_marker
),
4723 marker_byte_position (opoint_marker
));
4726 if (!NILP (Vscroll_preserve_screen_position
))
4728 SET_PT_BOTH (pos
, pos_byte
);
4729 Fvertical_motion (original_pos
, window
);
4732 Fvertical_motion (make_number (-1), window
);
4741 xsignal0 (Qend_of_buffer
);
4746 /* Scroll selected_window up or down. If N is nil, scroll a
4747 screen-full which is defined as the height of the window minus
4748 next_screen_context_lines. If N is the symbol `-', scroll.
4749 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4750 up. This is the guts of Fscroll_up and Fscroll_down. */
4753 scroll_command (Lisp_Object n
, int direction
)
4755 int count
= SPECPDL_INDEX ();
4757 xassert (eabs (direction
) == 1);
4759 /* If selected window's buffer isn't current, make it current for
4760 the moment. But don't screw up if window_scroll gets an error. */
4761 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4763 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4764 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4766 /* Make redisplay consider other windows than just selected_window. */
4767 ++windows_or_buffers_changed
;
4771 window_scroll (selected_window
, direction
, 1, 0);
4772 else if (EQ (n
, Qminus
))
4773 window_scroll (selected_window
, -direction
, 1, 0);
4776 n
= Fprefix_numeric_value (n
);
4777 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4780 unbind_to (count
, Qnil
);
4783 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4784 doc
: /* Scroll text of selected window upward ARG lines.
4785 If ARG is omitted or nil, scroll upward by a near full screen.
4786 A near full screen is `next-screen-context-lines' less than a full screen.
4787 Negative ARG means scroll downward.
4788 If ARG is the atom `-', scroll downward by nearly full screen.
4789 When calling from a program, supply as argument a number, nil, or `-'. */)
4792 scroll_command (arg
, 1);
4796 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4797 doc
: /* Scroll text of selected window down ARG lines.
4798 If ARG is omitted or nil, scroll down by a near full screen.
4799 A near full screen is `next-screen-context-lines' less than a full screen.
4800 Negative ARG means scroll upward.
4801 If ARG is the atom `-', scroll upward by nearly full screen.
4802 When calling from a program, supply as argument a number, nil, or `-'. */)
4805 scroll_command (arg
, -1);
4809 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4810 doc
: /* Return the other window for \"other window scroll\" commands.
4811 If `other-window-scroll-buffer' is non-nil, a window
4812 showing that buffer is used.
4813 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4814 specifies the window. This takes precedence over
4815 `other-window-scroll-buffer'. */)
4820 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4821 && !NILP (Vminibuf_scroll_window
))
4822 window
= Vminibuf_scroll_window
;
4823 /* If buffer is specified, scroll that buffer. */
4824 else if (!NILP (Vother_window_scroll_buffer
))
4826 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4828 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4832 /* Nothing specified; look for a neighboring window on the same
4834 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4836 if (EQ (window
, selected_window
))
4837 /* That didn't get us anywhere; look for a window on another
4840 window
= Fnext_window (window
, Qnil
, Qt
);
4841 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4842 && ! EQ (window
, selected_window
));
4845 CHECK_LIVE_WINDOW (window
);
4847 if (EQ (window
, selected_window
))
4848 error ("There is no other window");
4853 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4854 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4855 A near full screen is `next-screen-context-lines' less than a full screen.
4856 The next window is the one below the current one; or the one at the top
4857 if the current one is at the bottom. Negative ARG means scroll downward.
4858 If ARG is the atom `-', scroll downward by nearly full screen.
4859 When calling from a program, supply as argument a number, nil, or `-'.
4861 If `other-window-scroll-buffer' is non-nil, scroll the window
4862 showing that buffer, popping the buffer up if necessary.
4863 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4864 specifies the window to scroll. This takes precedence over
4865 `other-window-scroll-buffer'. */)
4870 int count
= SPECPDL_INDEX ();
4872 window
= Fother_window_for_scrolling ();
4873 w
= XWINDOW (window
);
4875 /* Don't screw up if window_scroll gets an error. */
4876 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4877 ++windows_or_buffers_changed
;
4879 Fset_buffer (w
->buffer
);
4880 SET_PT (marker_position (w
->pointm
));
4883 window_scroll (window
, 1, 1, 1);
4884 else if (EQ (arg
, Qminus
))
4885 window_scroll (window
, -1, 1, 1);
4891 window_scroll (window
, XINT (arg
), 0, 1);
4894 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4895 unbind_to (count
, Qnil
);
4900 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
4901 doc
: /* Scroll selected window display ARG columns left.
4902 Default for ARG is window width minus 2.
4903 Value is the total amount of leftward horizontal scrolling in
4904 effect after the change.
4905 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4906 lower bound for automatic scrolling, i.e. automatic scrolling
4907 will not scroll a window to a column less than the value returned
4908 by this function. This happens in an interactive call. */)
4909 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4913 struct window
*w
= XWINDOW (selected_window
);
4916 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4918 arg
= Fprefix_numeric_value (arg
);
4920 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
4921 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4923 if (!NILP (set_minimum
))
4924 w
->min_hscroll
= w
->hscroll
;
4929 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
4930 doc
: /* Scroll selected window display ARG columns right.
4931 Default for ARG is window width minus 2.
4932 Value is the total amount of leftward horizontal scrolling in
4933 effect after the change.
4934 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4935 lower bound for automatic scrolling, i.e. automatic scrolling
4936 will not scroll a window to a column less than the value returned
4937 by this function. This happens in an interactive call. */)
4938 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4942 struct window
*w
= XWINDOW (selected_window
);
4945 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4947 arg
= Fprefix_numeric_value (arg
);
4949 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
4950 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4952 if (!NILP (set_minimum
))
4953 w
->min_hscroll
= w
->hscroll
;
4958 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
4959 doc
: /* Return the window which was selected when entering the minibuffer.
4960 Returns nil, if selected window is not a minibuffer window. */)
4963 if (minibuf_level
> 0
4964 && MINI_WINDOW_P (XWINDOW (selected_window
))
4965 && WINDOW_LIVE_P (minibuf_selected_window
))
4966 return minibuf_selected_window
;
4971 /* Value is the number of lines actually displayed in window W,
4972 as opposed to its height. */
4975 displayed_window_lines (struct window
*w
)
4978 struct text_pos start
;
4979 int height
= window_box_height (w
);
4980 struct buffer
*old_buffer
;
4983 if (XBUFFER (w
->buffer
) != current_buffer
)
4985 old_buffer
= current_buffer
;
4986 set_buffer_internal (XBUFFER (w
->buffer
));
4991 /* In case W->start is out of the accessible range, do something
4992 reasonable. This happens in Info mode when Info-scroll-down
4993 calls (recenter -1) while W->start is 1. */
4994 if (XMARKER (w
->start
)->charpos
< BEGV
)
4995 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4996 else if (XMARKER (w
->start
)->charpos
> ZV
)
4997 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
4999 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5001 start_display (&it
, w
, start
);
5002 move_it_vertically (&it
, height
);
5003 bottom_y
= line_bottom_y (&it
);
5005 /* rms: On a non-window display,
5006 the value of it.vpos at the bottom of the screen
5007 seems to be 1 larger than window_box_height (w).
5008 This kludge fixes a bug whereby (move-to-window-line -1)
5009 when ZV is on the last screen line
5010 moves to the previous screen line instead of the last one. */
5011 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5014 /* Add in empty lines at the bottom of the window. */
5015 if (bottom_y
< height
)
5017 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5018 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5022 set_buffer_internal (old_buffer
);
5028 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5029 doc
: /* Center point in selected window and maybe redisplay frame.
5030 With prefix argument ARG, recenter putting point on screen line ARG
5031 relative to the selected window. If ARG is negative, it counts up from the
5032 bottom of the window. (ARG should be less than the height of the window.)
5034 If ARG is omitted or nil, then recenter with point on the middle line of
5035 the selected window; if the variable `recenter-redisplay' is non-nil,
5036 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5037 is set to `grow-only', this resets the tool-bar's height to the minimum
5038 height needed); if `recenter-redisplay' has the special value `tty',
5039 then only tty frame are redrawn.
5041 Just C-u as prefix means put point in the center of the window
5042 and redisplay normally--don't erase and redraw the frame. */)
5043 (register Lisp_Object arg
)
5045 struct window
*w
= XWINDOW (selected_window
);
5046 struct buffer
*buf
= XBUFFER (w
->buffer
);
5047 struct buffer
*obuf
= current_buffer
;
5049 EMACS_INT charpos
, bytepos
;
5050 int iarg
IF_LINT (= 0);
5051 int this_scroll_margin
;
5053 /* If redisplay is suppressed due to an error, try again. */
5054 obuf
->display_error_modiff
= 0;
5058 if (!NILP (Vrecenter_redisplay
)
5059 && (!EQ (Vrecenter_redisplay
, Qtty
)
5060 || !NILP (Ftty_type (selected_frame
))))
5064 /* Invalidate pixel data calculated for all compositions. */
5065 for (i
= 0; i
< n_compositions
; i
++)
5066 composition_table
[i
]->font
= NULL
;
5068 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5070 Fredraw_frame (WINDOW_FRAME (w
));
5071 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5076 else if (CONSP (arg
)) /* Just C-u. */
5080 arg
= Fprefix_numeric_value (arg
);
5085 set_buffer_internal (buf
);
5087 /* Do this after making BUF current
5088 in case scroll_margin is buffer-local. */
5089 this_scroll_margin
= max (0, scroll_margin
);
5090 this_scroll_margin
= min (this_scroll_margin
,
5091 XFASTINT (w
->total_lines
) / 4);
5093 /* Handle centering on a graphical frame specially. Such frames can
5094 have variable-height lines and centering point on the basis of
5095 line counts would lead to strange effects. */
5096 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5103 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5104 start_display (&it
, w
, pt
);
5105 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5106 charpos
= IT_CHARPOS (it
);
5107 bytepos
= IT_BYTEPOS (it
);
5114 int extra_line_spacing
;
5115 int h
= window_box_height (w
);
5117 iarg
= - max (-iarg
, this_scroll_margin
);
5119 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5120 start_display (&it
, w
, pt
);
5122 /* Be sure we have the exact height of the full line containing PT. */
5123 move_it_by_lines (&it
, 0);
5125 /* The amount of pixels we have to move back is the window
5126 height minus what's displayed in the line containing PT,
5127 and the lines below. */
5130 move_it_by_lines (&it
, nlines
);
5132 if (it
.vpos
== nlines
)
5136 /* Last line has no newline */
5137 h
-= line_bottom_y (&it
);
5141 /* Don't reserve space for extra line spacing of last line. */
5142 extra_line_spacing
= it
.max_extra_line_spacing
;
5144 /* If we can't move down NLINES lines because we hit
5145 the end of the buffer, count in some empty lines. */
5146 if (it
.vpos
< nlines
)
5149 extra_line_spacing
= it
.extra_line_spacing
;
5150 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5155 /* Now find the new top line (starting position) of the window. */
5156 start_display (&it
, w
, pt
);
5158 move_it_vertically_backward (&it
, h
);
5160 /* If extra line spacing is present, we may move too far
5161 back. This causes the last line to be only partially
5162 visible (which triggers redisplay to recenter that line
5163 in the middle), so move forward.
5164 But ignore extra line spacing on last line, as it is not
5165 considered to be part of the visible height of the line.
5167 h
+= extra_line_spacing
;
5168 while (-it
.current_y
> h
)
5169 move_it_by_lines (&it
, 1);
5171 charpos
= IT_CHARPOS (it
);
5172 bytepos
= IT_BYTEPOS (it
);
5176 struct position pos
;
5178 iarg
= max (iarg
, this_scroll_margin
);
5180 pos
= *vmotion (PT
, -iarg
, w
);
5181 charpos
= pos
.bufpos
;
5182 bytepos
= pos
.bytepos
;
5187 struct position pos
;
5188 int ht
= window_internal_height (w
);
5195 /* Don't let it get into the margin at either top or bottom. */
5196 iarg
= max (iarg
, this_scroll_margin
);
5197 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5199 pos
= *vmotion (PT
, - iarg
, w
);
5200 charpos
= pos
.bufpos
;
5201 bytepos
= pos
.bytepos
;
5204 /* Set the new window start. */
5205 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5206 w
->window_end_valid
= Qnil
;
5208 w
->optional_new_start
= Qt
;
5210 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5211 w
->start_at_line_beg
= Qt
;
5213 w
->start_at_line_beg
= Qnil
;
5215 set_buffer_internal (obuf
);
5219 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5221 doc
: /* Return the height in lines of the text display area of WINDOW.
5222 WINDOW defaults to the selected window.
5224 The return value does not include the mode line, any header line, nor
5225 any partial-height lines in the text display area. */)
5226 (Lisp_Object window
)
5228 struct window
*w
= decode_window (window
);
5229 int pixel_height
= window_box_height (w
);
5230 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5231 return make_number (line_height
);
5236 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5238 doc
: /* Position point relative to window.
5239 With no argument, position point at center of window.
5240 An argument specifies vertical position within the window;
5241 zero means top of window, negative means relative to bottom of window. */)
5244 struct window
*w
= XWINDOW (selected_window
);
5248 int this_scroll_margin
;
5251 if (!(BUFFERP (w
->buffer
)
5252 && XBUFFER (w
->buffer
) == current_buffer
))
5253 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5254 when passed below to set_marker_both. */
5255 error ("move-to-window-line called from unrelated buffer");
5257 window
= selected_window
;
5258 start
= marker_position (w
->start
);
5259 if (start
< BEGV
|| start
> ZV
)
5261 int height
= window_internal_height (w
);
5262 Fvertical_motion (make_number (- (height
/ 2)), window
);
5263 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5264 w
->start_at_line_beg
= Fbolp ();
5265 w
->force_start
= Qt
;
5268 Fgoto_char (w
->start
);
5270 lines
= displayed_window_lines (w
);
5273 this_scroll_margin
= max (0, scroll_margin
);
5274 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5278 XSETFASTINT (arg
, lines
/ 2);
5281 int iarg
= XINT (Fprefix_numeric_value (arg
));
5284 iarg
= iarg
+ lines
;
5286 #if 0 /* This code would prevent move-to-window-line from moving point
5287 to a place inside the scroll margins (which would cause the
5288 next redisplay to scroll). I wrote this code, but then concluded
5289 it is probably better not to install it. However, it is here
5290 inside #if 0 so as not to lose it. -- rms. */
5292 /* Don't let it get into the margin at either top or bottom. */
5293 iarg
= max (iarg
, this_scroll_margin
);
5294 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5297 arg
= make_number (iarg
);
5300 /* Skip past a partially visible first line. */
5302 XSETINT (arg
, XINT (arg
) + 1);
5304 return Fvertical_motion (arg
, window
);
5309 /***********************************************************************
5310 Window Configuration
5311 ***********************************************************************/
5313 struct save_window_data
5315 struct vectorlike_header header
;
5316 Lisp_Object selected_frame
;
5317 Lisp_Object current_window
;
5318 Lisp_Object current_buffer
;
5319 Lisp_Object minibuf_scroll_window
;
5320 Lisp_Object minibuf_selected_window
;
5321 Lisp_Object root_window
;
5322 Lisp_Object focus_frame
;
5323 /* A vector, each of whose elements is a struct saved_window
5325 Lisp_Object saved_windows
;
5327 /* All fields above are traced by the GC.
5328 From `fame-cols' down, the fields are ignored by the GC. */
5330 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5331 int frame_tool_bar_lines
;
5334 /* This is saved as a Lisp_Vector */
5337 struct vectorlike_header header
;
5339 Lisp_Object window
, clone_number
;
5340 Lisp_Object buffer
, start
, pointm
, mark
;
5341 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5342 Lisp_Object normal_cols
, normal_lines
;
5343 Lisp_Object hscroll
, min_hscroll
;
5344 Lisp_Object parent
, prev
;
5345 Lisp_Object start_at_line_beg
;
5346 Lisp_Object display_table
;
5347 Lisp_Object left_margin_cols
, right_margin_cols
;
5348 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5349 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5350 Lisp_Object splits
, nest
, window_parameters
;
5353 #define SAVED_WINDOW_N(swv,n) \
5354 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5356 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5357 doc
: /* Return t if OBJECT is a window-configuration object. */)
5358 (Lisp_Object object
)
5360 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5363 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5364 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5365 (Lisp_Object config
)
5367 register struct save_window_data
*data
;
5368 struct Lisp_Vector
*saved_windows
;
5370 CHECK_WINDOW_CONFIGURATION (config
);
5372 data
= (struct save_window_data
*) XVECTOR (config
);
5373 saved_windows
= XVECTOR (data
->saved_windows
);
5374 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5377 DEFUN ("set-window-configuration", Fset_window_configuration
,
5378 Sset_window_configuration
, 1, 1, 0,
5379 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5380 CONFIGURATION must be a value previously returned
5381 by `current-window-configuration' (which see).
5382 If CONFIGURATION was made from a frame that is now deleted,
5383 only frame-independent values can be restored. In this case,
5384 the return value is nil. Otherwise the value is t. */)
5385 (Lisp_Object configuration
)
5387 register struct save_window_data
*data
;
5388 struct Lisp_Vector
*saved_windows
;
5389 Lisp_Object new_current_buffer
;
5392 EMACS_INT old_point
= -1;
5394 CHECK_WINDOW_CONFIGURATION (configuration
);
5396 data
= (struct save_window_data
*) XVECTOR (configuration
);
5397 saved_windows
= XVECTOR (data
->saved_windows
);
5399 new_current_buffer
= data
->current_buffer
;
5400 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5401 new_current_buffer
= Qnil
;
5404 if (XBUFFER (new_current_buffer
) == current_buffer
)
5405 /* The code further down "preserves point" by saving here PT in
5406 old_point and then setting it later back into PT. When the
5407 current-selected-window and the final-selected-window both show
5408 the current buffer, this suffers from the problem that the
5409 current PT is the window-point of the current-selected-window,
5410 while the final PT is the point of the final-selected-window, so
5411 this copy from one PT to the other would end up moving the
5412 window-point of the final-selected-window to the window-point of
5413 the current-selected-window. So we have to be careful which
5414 point of the current-buffer we copy into old_point. */
5415 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5416 && WINDOWP (selected_window
)
5417 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5418 && !EQ (selected_window
, data
->current_window
))
5419 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5423 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5424 point in new_current_buffer as of the last time this buffer was
5425 used. This can be non-deterministic since it can be changed by
5426 things like jit-lock by mere temporary selection of some random
5427 window that happens to show this buffer.
5428 So if possible we want this arbitrary choice of "which point" to
5429 be the one from the to-be-selected-window so as to prevent this
5430 window's cursor from being copied from another window. */
5431 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5432 /* If current_window = selected_window, its point is in BUF_PT. */
5433 && !EQ (selected_window
, data
->current_window
))
5434 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5436 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5439 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5442 /* If f is a dead frame, don't bother rebuilding its window tree.
5443 However, there is other stuff we should still try to do below. */
5444 if (FRAME_LIVE_P (f
))
5446 register struct window
*w
;
5447 register struct saved_window
*p
;
5448 struct window
*root_window
;
5449 struct window
**leaf_windows
;
5453 /* If the frame has been resized since this window configuration was
5454 made, we change the frame to the size specified in the
5455 configuration, restore the configuration, and then resize it
5456 back. We keep track of the prevailing height in these variables. */
5457 int previous_frame_lines
= FRAME_LINES (f
);
5458 int previous_frame_cols
= FRAME_COLS (f
);
5459 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5460 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5462 /* The mouse highlighting code could get screwed up
5463 if it runs during this. */
5466 if (data
->frame_lines
!= previous_frame_lines
5467 || data
->frame_cols
!= previous_frame_cols
)
5468 change_frame_size (f
, data
->frame_lines
,
5469 data
->frame_cols
, 0, 0, 0);
5470 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5471 if (data
->frame_menu_bar_lines
5472 != previous_frame_menu_bar_lines
)
5473 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5475 #ifdef HAVE_WINDOW_SYSTEM
5476 if (data
->frame_tool_bar_lines
5477 != previous_frame_tool_bar_lines
)
5478 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5483 /* "Swap out" point from the selected window's buffer
5484 into the window itself. (Normally the pointm of the selected
5485 window holds garbage.) We do this now, before
5486 restoring the window contents, and prevent it from
5487 being done later on when we select a new window. */
5488 if (! NILP (XWINDOW (selected_window
)->buffer
))
5490 w
= XWINDOW (selected_window
);
5491 set_marker_both (w
->pointm
,
5493 BUF_PT (XBUFFER (w
->buffer
)),
5494 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5497 windows_or_buffers_changed
++;
5498 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5500 /* Problem: Freeing all matrices and later allocating them again
5501 is a serious redisplay flickering problem. What we would
5502 really like to do is to free only those matrices not reused
5504 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5506 = (struct window
**) alloca (count_windows (root_window
)
5507 * sizeof (struct window
*));
5508 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5511 Mark all windows now on frame as "deleted".
5512 Restoring the new configuration "undeletes" any that are in it.
5514 Save their current buffers in their height fields, since we may
5515 need it later, if a buffer saved in the configuration is now
5517 delete_all_subwindows (FRAME_ROOT_WINDOW (f
));
5519 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5521 p
= SAVED_WINDOW_N (saved_windows
, k
);
5522 w
= XWINDOW (p
->window
);
5525 if (!NILP (p
->parent
))
5526 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5527 XFASTINT (p
->parent
))->window
;
5531 if (!NILP (p
->prev
))
5533 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5534 XFASTINT (p
->prev
))->window
;
5535 XWINDOW (w
->prev
)->next
= p
->window
;
5540 if (!NILP (w
->parent
))
5542 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5544 XWINDOW (w
->parent
)->vchild
= p
->window
;
5545 XWINDOW (w
->parent
)->hchild
= Qnil
;
5549 XWINDOW (w
->parent
)->hchild
= p
->window
;
5550 XWINDOW (w
->parent
)->vchild
= Qnil
;
5555 w
->clone_number
= p
->clone_number
;
5556 /* If we squirreled away the buffer in the window's height,
5558 if (BUFFERP (w
->total_lines
))
5559 w
->buffer
= w
->total_lines
;
5560 w
->left_col
= p
->left_col
;
5561 w
->top_line
= p
->top_line
;
5562 w
->total_cols
= p
->total_cols
;
5563 w
->total_lines
= p
->total_lines
;
5564 w
->normal_cols
= p
->normal_cols
;
5565 w
->normal_lines
= p
->normal_lines
;
5566 w
->hscroll
= p
->hscroll
;
5567 w
->min_hscroll
= p
->min_hscroll
;
5568 w
->display_table
= p
->display_table
;
5569 w
->left_margin_cols
= p
->left_margin_cols
;
5570 w
->right_margin_cols
= p
->right_margin_cols
;
5571 w
->left_fringe_width
= p
->left_fringe_width
;
5572 w
->right_fringe_width
= p
->right_fringe_width
;
5573 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5574 w
->scroll_bar_width
= p
->scroll_bar_width
;
5575 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5576 w
->dedicated
= p
->dedicated
;
5577 w
->splits
= p
->splits
;
5579 w
->window_parameters
= p
->window_parameters
;
5580 XSETFASTINT (w
->last_modified
, 0);
5581 XSETFASTINT (w
->last_overlay_modified
, 0);
5583 /* Reinstall the saved buffer and pointers into it. */
5584 if (NILP (p
->buffer
))
5585 w
->buffer
= p
->buffer
;
5588 if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5589 /* If saved buffer is alive, install it. */
5591 w
->buffer
= p
->buffer
;
5592 w
->start_at_line_beg
= p
->start_at_line_beg
;
5593 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5594 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5595 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5596 p
->mark
, w
->buffer
);
5598 /* As documented in Fcurrent_window_configuration, don't
5599 restore the location of point in the buffer which was
5600 current when the window configuration was recorded. */
5601 if (!EQ (p
->buffer
, new_current_buffer
)
5602 && XBUFFER (p
->buffer
) == current_buffer
)
5603 Fgoto_char (w
->pointm
);
5605 else if (NILP (w
->buffer
) || NILP (BVAR (XBUFFER (w
->buffer
), name
)))
5606 /* Else unless window has a live buffer, get one. */
5608 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5609 /* This will set the markers to beginning of visible
5611 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5612 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5613 w
->start_at_line_beg
= Qt
;
5616 /* Keeping window's old buffer; make sure the markers
5619 /* Set window markers at start of visible range. */
5620 if (XMARKER (w
->start
)->buffer
== 0)
5621 set_marker_restricted (w
->start
, make_number (0),
5623 if (XMARKER (w
->pointm
)->buffer
== 0)
5624 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5625 BUF_PT (XBUFFER (w
->buffer
)),
5626 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5627 w
->start_at_line_beg
= Qt
;
5632 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5634 /* Arrange *not* to restore point in the buffer that was
5635 current when the window configuration was saved. */
5636 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5637 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5638 make_number (old_point
),
5639 XWINDOW (data
->current_window
)->buffer
);
5641 /* In the following call to `select-window, prevent "swapping
5642 out point" in the old selected window using the buffer that
5643 has been restored into it. We already swapped out that point
5644 from that window's old buffer. */
5645 select_window (data
->current_window
, Qnil
, 1);
5646 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5649 if (NILP (data
->focus_frame
)
5650 || (FRAMEP (data
->focus_frame
)
5651 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5652 Fredirect_frame_focus (frame
, data
->focus_frame
);
5654 /* Set the screen height to the value it had before this function. */
5655 if (previous_frame_lines
!= FRAME_LINES (f
)
5656 || previous_frame_cols
!= FRAME_COLS (f
))
5657 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5659 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5660 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5661 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5663 #ifdef HAVE_WINDOW_SYSTEM
5664 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5665 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5670 /* Now, free glyph matrices in windows that were not reused. */
5671 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5673 if (NILP (leaf_windows
[i
]->buffer
))
5675 /* Assert it's not reused as a combination. */
5676 xassert (NILP (leaf_windows
[i
]->hchild
)
5677 && NILP (leaf_windows
[i
]->vchild
));
5678 free_window_matrices (leaf_windows
[i
]);
5680 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5688 /* Fselect_window will have made f the selected frame, so we
5689 reselect the proper frame here. Fhandle_switch_frame will change the
5690 selected window too, but that doesn't make the call to
5691 Fselect_window above totally superfluous; it still sets f's
5693 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5694 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5696 run_window_configuration_change_hook (f
);
5699 if (!NILP (new_current_buffer
))
5700 Fset_buffer (new_current_buffer
);
5702 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5703 minibuf_selected_window
= data
->minibuf_selected_window
;
5705 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5709 /* Delete all subwindows reachable via the next, vchild, and hchild
5712 delete_all_subwindows (Lisp_Object window
)
5714 register struct window
*w
;
5716 w
= XWINDOW (window
);
5718 if (!NILP (w
->next
))
5719 /* Delete WINDOW's siblings (we traverse postorderly). */
5720 delete_all_subwindows (w
->next
);
5722 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5724 if (!NILP (w
->vchild
))
5726 delete_all_subwindows (w
->vchild
);
5729 else if (!NILP (w
->hchild
))
5731 delete_all_subwindows (w
->hchild
);
5734 else if (!NILP (w
->buffer
))
5737 unchain_marker (XMARKER (w
->pointm
));
5738 unchain_marker (XMARKER (w
->start
));
5742 Vwindow_list
= Qnil
;
5746 count_windows (register struct window
*window
)
5748 register int count
= 1;
5749 if (!NILP (window
->next
))
5750 count
+= count_windows (XWINDOW (window
->next
));
5751 if (!NILP (window
->vchild
))
5752 count
+= count_windows (XWINDOW (window
->vchild
));
5753 if (!NILP (window
->hchild
))
5754 count
+= count_windows (XWINDOW (window
->hchild
));
5759 /* Fill vector FLAT with leaf windows under W, starting at index I.
5760 Value is last index + 1. */
5762 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5766 if (!NILP (w
->hchild
))
5767 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5768 else if (!NILP (w
->vchild
))
5769 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5773 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5780 /* Return a pointer to the glyph W's physical cursor is on. Value is
5781 null if W's current matrix is invalid, so that no meaningfull glyph
5784 get_phys_cursor_glyph (struct window
*w
)
5786 struct glyph_row
*row
;
5787 struct glyph
*glyph
;
5789 if (w
->phys_cursor
.vpos
>= 0
5790 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5791 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5793 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5794 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5803 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
5805 register struct saved_window
*p
;
5806 register struct window
*w
;
5807 register Lisp_Object tem
;
5809 for (;!NILP (window
); window
= w
->next
)
5811 p
= SAVED_WINDOW_N (vector
, i
);
5812 w
= XWINDOW (window
);
5814 XSETFASTINT (w
->temslot
, i
); i
++;
5816 p
->clone_number
= w
->clone_number
;
5817 p
->buffer
= w
->buffer
;
5818 p
->left_col
= w
->left_col
;
5819 p
->top_line
= w
->top_line
;
5820 p
->total_cols
= w
->total_cols
;
5821 p
->total_lines
= w
->total_lines
;
5822 p
->normal_cols
= w
->normal_cols
;
5823 p
->normal_lines
= w
->normal_lines
;
5824 p
->hscroll
= w
->hscroll
;
5825 p
->min_hscroll
= w
->min_hscroll
;
5826 p
->display_table
= w
->display_table
;
5827 p
->left_margin_cols
= w
->left_margin_cols
;
5828 p
->right_margin_cols
= w
->right_margin_cols
;
5829 p
->left_fringe_width
= w
->left_fringe_width
;
5830 p
->right_fringe_width
= w
->right_fringe_width
;
5831 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
5832 p
->scroll_bar_width
= w
->scroll_bar_width
;
5833 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5834 p
->dedicated
= w
->dedicated
;
5835 p
->splits
= w
->splits
;
5837 p
->window_parameters
= w
->window_parameters
;
5838 if (!NILP (w
->buffer
))
5840 /* Save w's value of point in the window configuration.
5841 If w is the selected window, then get the value of point
5842 from the buffer; pointm is garbage in the selected window. */
5843 if (EQ (window
, selected_window
))
5845 p
->pointm
= Fmake_marker ();
5846 set_marker_both (p
->pointm
, w
->buffer
,
5847 BUF_PT (XBUFFER (w
->buffer
)),
5848 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5851 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5853 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5854 p
->start_at_line_beg
= w
->start_at_line_beg
;
5856 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
5857 p
->mark
= Fcopy_marker (tem
, Qnil
);
5864 p
->start_at_line_beg
= Qnil
;
5867 if (NILP (w
->parent
))
5870 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5875 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5877 if (!NILP (w
->vchild
))
5878 i
= save_window_save (w
->vchild
, vector
, i
);
5879 if (!NILP (w
->hchild
))
5880 i
= save_window_save (w
->hchild
, vector
, i
);
5886 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5887 Scurrent_window_configuration
, 0, 1, 0,
5888 doc
: /* Return an object representing the current window configuration of FRAME.
5889 If FRAME is nil or omitted, use the selected frame.
5890 This describes the number of windows, their sizes and current buffers,
5891 and for each displayed buffer, where display starts, and the positions of
5892 point and mark. An exception is made for point in the current buffer:
5893 its value is -not- saved.
5894 This also records the currently selected frame, and FRAME's focus
5895 redirection (see `redirect-frame-focus'). */)
5898 register Lisp_Object tem
;
5899 register int n_windows
;
5900 register struct save_window_data
*data
;
5905 frame
= selected_frame
;
5906 CHECK_LIVE_FRAME (frame
);
5909 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5910 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
5911 PVEC_WINDOW_CONFIGURATION
);
5913 data
->frame_cols
= FRAME_COLS (f
);
5914 data
->frame_lines
= FRAME_LINES (f
);
5915 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5916 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5917 data
->selected_frame
= selected_frame
;
5918 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5919 XSETBUFFER (data
->current_buffer
, current_buffer
);
5920 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
5921 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
5922 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5923 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5924 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5925 data
->saved_windows
= tem
;
5926 for (i
= 0; i
< n_windows
; i
++)
5927 XVECTOR (tem
)->contents
[i
]
5928 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
5929 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5930 XSETWINDOW_CONFIGURATION (tem
, data
);
5935 /***********************************************************************
5937 ***********************************************************************/
5940 window_tree (struct window
*w
)
5942 Lisp_Object tail
= Qnil
;
5943 Lisp_Object result
= Qnil
;
5950 if (!NILP (w
->hchild
))
5951 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
5952 window_tree (XWINDOW (w
->hchild
))));
5953 else if (!NILP (w
->vchild
))
5954 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
5955 window_tree (XWINDOW (w
->vchild
))));
5959 result
= tail
= Fcons (wn
, Qnil
);
5963 XSETCDR (tail
, Fcons (wn
, Qnil
));
5967 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5975 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
5977 doc
: /* Return the window tree for frame FRAME.
5979 The return value is a list of the form (ROOT MINI), where ROOT
5980 represents the window tree of the frame's root window, and MINI
5981 is the frame's minibuffer window.
5983 If the root window is not split, ROOT is the root window itself.
5984 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
5985 horizontal split, and t for a vertical split, EDGES gives the combined
5986 size and position of the subwindows in the split, and the rest of the
5987 elements are the subwindows in the split. Each of the subwindows may
5988 again be a window or a list representing a window split, and so on.
5989 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
5991 If FRAME is nil or omitted, return information on the currently
5998 frame
= selected_frame
;
6000 CHECK_FRAME (frame
);
6003 if (!FRAME_LIVE_P (f
))
6006 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6010 /***********************************************************************
6012 ***********************************************************************/
6014 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6016 doc
: /* Set width of marginal areas of window WINDOW.
6017 If WINDOW is nil, set margins of the currently selected window.
6018 Second arg LEFT-WIDTH specifies the number of character cells to
6019 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6020 does the same for the right marginal area. A nil width parameter
6021 means no margin. */)
6022 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6024 struct window
*w
= decode_window (window
);
6026 /* Translate negative or zero widths to nil.
6027 Margins that are too wide have to be checked elsewhere. */
6029 if (!NILP (left_width
))
6031 CHECK_NUMBER (left_width
);
6032 if (XINT (left_width
) <= 0)
6036 if (!NILP (right_width
))
6038 CHECK_NUMBER (right_width
);
6039 if (XINT (right_width
) <= 0)
6043 if (!EQ (w
->left_margin_cols
, left_width
)
6044 || !EQ (w
->right_margin_cols
, right_width
))
6046 w
->left_margin_cols
= left_width
;
6047 w
->right_margin_cols
= right_width
;
6049 adjust_window_margins (w
);
6051 ++windows_or_buffers_changed
;
6052 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6059 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6061 doc
: /* Get width of marginal areas of window WINDOW.
6062 If WINDOW is omitted or nil, use the currently selected window.
6063 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6064 If a marginal area does not exist, its width will be returned
6066 (Lisp_Object window
)
6068 struct window
*w
= decode_window (window
);
6069 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6074 /***********************************************************************
6076 ***********************************************************************/
6078 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6080 doc
: /* Set the fringe widths of window WINDOW.
6081 If WINDOW is nil, set the fringe widths of the currently selected
6083 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6084 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6085 fringe width. If a fringe width arg is nil, that means to use the
6086 frame's default fringe width. Default fringe widths can be set with
6087 the command `set-fringe-style'.
6088 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6089 outside of the display margins. By default, fringes are drawn between
6090 display marginal areas and the text area. */)
6091 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6093 struct window
*w
= decode_window (window
);
6095 if (!NILP (left_width
))
6096 CHECK_NATNUM (left_width
);
6097 if (!NILP (right_width
))
6098 CHECK_NATNUM (right_width
);
6100 /* Do nothing on a tty. */
6101 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6102 && (!EQ (w
->left_fringe_width
, left_width
)
6103 || !EQ (w
->right_fringe_width
, right_width
)
6104 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6106 w
->left_fringe_width
= left_width
;
6107 w
->right_fringe_width
= right_width
;
6108 w
->fringes_outside_margins
= outside_margins
;
6110 adjust_window_margins (w
);
6112 clear_glyph_matrix (w
->current_matrix
);
6113 w
->window_end_valid
= Qnil
;
6115 ++windows_or_buffers_changed
;
6116 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6123 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6125 doc
: /* Get width of fringes of window WINDOW.
6126 If WINDOW is omitted or nil, use the currently selected window.
6127 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6128 (Lisp_Object window
)
6130 struct window
*w
= decode_window (window
);
6132 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6133 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6134 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6135 ? Qt
: Qnil
), Qnil
)));
6140 /***********************************************************************
6142 ***********************************************************************/
6144 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6145 Sset_window_scroll_bars
, 2, 4, 0,
6146 doc
: /* Set width and type of scroll bars of window WINDOW.
6147 If window is nil, set scroll bars of the currently selected window.
6148 Second parameter WIDTH specifies the pixel width for the scroll bar;
6149 this is automatically adjusted to a multiple of the frame column width.
6150 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6151 bar: left, right, or nil.
6152 If WIDTH is nil, use the frame's scroll-bar width.
6153 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6154 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6155 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6157 struct window
*w
= decode_window (window
);
6161 CHECK_NATNUM (width
);
6163 if (XINT (width
) == 0)
6164 vertical_type
= Qnil
;
6167 if (!(NILP (vertical_type
)
6168 || EQ (vertical_type
, Qleft
)
6169 || EQ (vertical_type
, Qright
)
6170 || EQ (vertical_type
, Qt
)))
6171 error ("Invalid type of vertical scroll bar");
6173 if (!EQ (w
->scroll_bar_width
, width
)
6174 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6176 w
->scroll_bar_width
= width
;
6177 w
->vertical_scroll_bar_type
= vertical_type
;
6179 adjust_window_margins (w
);
6181 clear_glyph_matrix (w
->current_matrix
);
6182 w
->window_end_valid
= Qnil
;
6184 ++windows_or_buffers_changed
;
6185 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6192 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6194 doc
: /* Get width and type of scroll bars of window WINDOW.
6195 If WINDOW is omitted or nil, use the currently selected window.
6196 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6197 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6199 (Lisp_Object window
)
6201 struct window
*w
= decode_window (window
);
6202 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6203 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6204 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6205 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6206 Fcons (w
->vertical_scroll_bar_type
,
6207 Fcons (Qnil
, Qnil
))));
6212 /***********************************************************************
6214 ***********************************************************************/
6216 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6217 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6218 Use the selected window if WINDOW is nil or omitted.
6219 Normally, value is a multiple of the canonical character height of WINDOW;
6220 optional second arg PIXELS-P means value is measured in pixels. */)
6221 (Lisp_Object window
, Lisp_Object pixels_p
)
6228 window
= selected_window
;
6230 CHECK_WINDOW (window
);
6231 w
= XWINDOW (window
);
6232 f
= XFRAME (w
->frame
);
6234 if (FRAME_WINDOW_P (f
))
6235 result
= (NILP (pixels_p
)
6236 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6237 : make_number (-w
->vscroll
));
6239 result
= make_number (0);
6244 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6246 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6247 WINDOW nil means use the selected window. Normally, VSCROLL is a
6248 non-negative multiple of the canonical character height of WINDOW;
6249 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6250 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6251 corresponds to an integral number of pixels. The return value is the
6252 result of this rounding.
6253 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6254 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6260 window
= selected_window
;
6262 CHECK_WINDOW (window
);
6263 CHECK_NUMBER_OR_FLOAT (vscroll
);
6265 w
= XWINDOW (window
);
6266 f
= XFRAME (w
->frame
);
6268 if (FRAME_WINDOW_P (f
))
6270 int old_dy
= w
->vscroll
;
6272 w
->vscroll
= - (NILP (pixels_p
)
6273 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6274 : XFLOATINT (vscroll
));
6275 w
->vscroll
= min (w
->vscroll
, 0);
6277 if (w
->vscroll
!= old_dy
)
6279 /* Adjust glyph matrix of the frame if the virtual display
6280 area becomes larger than before. */
6281 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6284 /* Prevent redisplay shortcuts. */
6285 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6289 return Fwindow_vscroll (window
, pixels_p
);
6293 /* Call FN for all leaf windows on frame F. FN is called with the
6294 first argument being a pointer to the leaf window, and with
6295 additional argument USER_DATA. Stops when FN returns 0. */
6298 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6301 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6302 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6303 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6307 /* Helper function for foreach_window. Call FN for all leaf windows
6308 reachable from W. FN is called with the first argument being a
6309 pointer to the leaf window, and with additional argument USER_DATA.
6310 Stop when FN returns 0. Value is 0 if stopped by FN. */
6313 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6317 for (cont
= 1; w
&& cont
;)
6319 if (!NILP (w
->hchild
))
6320 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6321 else if (!NILP (w
->vchild
))
6322 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6324 cont
= fn (w
, user_data
);
6326 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6333 /* Freeze or unfreeze the window start of W unless it is a
6334 mini-window or the selected window. FREEZE_P non-null means freeze
6335 the window start. */
6338 freeze_window_start (struct window
*w
, void *freeze_p
)
6340 if (MINI_WINDOW_P (w
)
6341 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6342 && (w
== XWINDOW (selected_window
)
6343 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6344 && ! NILP (Vminibuf_scroll_window
)
6345 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6348 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6353 /* Freeze or unfreeze the window starts of all leaf windows on frame
6354 F, except the selected window and a mini-window. FREEZE_P non-zero
6355 means freeze the window start. */
6358 freeze_window_starts (struct frame
*f
, int freeze_p
)
6360 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6364 /***********************************************************************
6366 ***********************************************************************/
6368 /* Return 1 if window configurations C1 and C2
6369 describe the same state of affairs. This is used by Fequal. */
6372 compare_window_configurations (Lisp_Object c1
, Lisp_Object c2
, int ignore_positions
)
6374 register struct save_window_data
*d1
, *d2
;
6375 struct Lisp_Vector
*sw1
, *sw2
;
6378 CHECK_WINDOW_CONFIGURATION (c1
);
6379 CHECK_WINDOW_CONFIGURATION (c2
);
6381 d1
= (struct save_window_data
*) XVECTOR (c1
);
6382 d2
= (struct save_window_data
*) XVECTOR (c2
);
6383 sw1
= XVECTOR (d1
->saved_windows
);
6384 sw2
= XVECTOR (d2
->saved_windows
);
6386 if (d1
->frame_cols
!= d2
->frame_cols
)
6388 if (d1
->frame_lines
!= d2
->frame_lines
)
6390 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
6392 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6394 /* Don't compare the current_window field directly.
6395 Instead see w1_is_current and w2_is_current, below. */
6396 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6398 if (! ignore_positions
)
6400 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6402 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6405 /* Don't compare the root_window field.
6406 We don't require the two configurations
6407 to use the same window object,
6408 and the two root windows must be equivalent
6409 if everything else compares equal. */
6410 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6413 /* Verify that the two confis have the same number of windows. */
6414 if (sw1
->header
.size
!= sw2
->header
.size
)
6417 for (i
= 0; i
< sw1
->header
.size
; i
++)
6419 struct saved_window
*p1
, *p2
;
6420 int w1_is_current
, w2_is_current
;
6422 p1
= SAVED_WINDOW_N (sw1
, i
);
6423 p2
= SAVED_WINDOW_N (sw2
, i
);
6425 /* Verify that the current windows in the two
6426 configurations correspond to each other. */
6427 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6428 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6430 if (w1_is_current
!= w2_is_current
)
6433 /* Verify that the corresponding windows do match. */
6434 if (! EQ (p1
->buffer
, p2
->buffer
))
6436 if (! EQ (p1
->left_col
, p2
->left_col
))
6438 if (! EQ (p1
->top_line
, p2
->top_line
))
6440 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6442 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6444 if (! EQ (p1
->display_table
, p2
->display_table
))
6446 if (! EQ (p1
->parent
, p2
->parent
))
6448 if (! EQ (p1
->prev
, p2
->prev
))
6450 if (! ignore_positions
)
6452 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6454 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6456 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6458 if (NILP (Fequal (p1
->start
, p2
->start
)))
6460 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6462 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6465 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6467 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6469 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6471 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6473 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6475 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6477 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6484 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6485 Scompare_window_configurations
, 2, 2, 0,
6486 doc
: /* Compare two window configurations as regards the structure of windows.
6487 This function ignores details such as the values of point and mark
6488 and scrolling positions. */)
6489 (Lisp_Object x
, Lisp_Object y
)
6491 if (compare_window_configurations (x
, y
, 1))
6497 init_window_once (void)
6499 struct frame
*f
= make_initial_frame ();
6500 XSETFRAME (selected_frame
, f
);
6501 Vterminal_frame
= selected_frame
;
6502 minibuf_window
= f
->minibuffer_window
;
6503 selected_window
= f
->selected_window
;
6504 last_nonminibuf_frame
= f
;
6506 window_initialized
= 1;
6512 Vwindow_list
= Qnil
;
6516 syms_of_window (void)
6518 Qscroll_up
= intern_c_string ("scroll-up");
6519 staticpro (&Qscroll_up
);
6521 Qscroll_down
= intern_c_string ("scroll-down");
6522 staticpro (&Qscroll_down
);
6524 Qscroll_command
= intern_c_string ("scroll-command");
6525 staticpro (&Qscroll_command
);
6527 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6528 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6530 staticpro (&Qwindow_configuration_change_hook
);
6531 Qwindow_configuration_change_hook
6532 = intern_c_string ("window-configuration-change-hook");
6534 Qwindowp
= intern_c_string ("windowp");
6535 staticpro (&Qwindowp
);
6537 Qwindow_configuration_p
= intern_c_string ("window-configuration-p");
6538 staticpro (&Qwindow_configuration_p
);
6540 Qwindow_live_p
= intern_c_string ("window-live-p");
6541 staticpro (&Qwindow_live_p
);
6543 Qwindow_deletable_p
= intern_c_string ("window-deletable-p");
6544 staticpro (&Qwindow_deletable_p
);
6546 Qdelete_window
= intern_c_string ("delete-window");
6547 staticpro (&Qdelete_window
);
6549 Qresize_root_window
= intern_c_string ("resize-root-window");
6550 staticpro (&Qresize_root_window
);
6552 Qresize_root_window_vertically
= intern_c_string ("resize-root-window-vertically");
6553 staticpro (&Qresize_root_window_vertically
);
6555 Qsafe
= intern_c_string ("safe");
6558 Qdisplay_buffer
= intern_c_string ("display-buffer");
6559 staticpro (&Qdisplay_buffer
);
6561 Qreplace_buffer_in_windows
= intern_c_string ("replace-buffer-in-windows");
6562 staticpro (&Qreplace_buffer_in_windows
);
6564 Qrecord_window_buffer
= intern_c_string ("record-window-buffer");
6565 staticpro (&Qrecord_window_buffer
);
6567 Qget_mru_window
= intern_c_string ("get-mru-window");
6568 staticpro (&Qget_mru_window
);
6570 Qtemp_buffer_show_hook
= intern_c_string ("temp-buffer-show-hook");
6571 staticpro (&Qtemp_buffer_show_hook
);
6573 Qabove
= intern_c_string ("above");
6574 staticpro (&Qabove
);
6576 Qbelow
= intern_c_string ("below");
6577 staticpro (&Qbelow
);
6579 Qauto_buffer_name
= intern_c_string ("auto-buffer-name");
6580 staticpro (&Qauto_buffer_name
);
6582 staticpro (&Vwindow_list
);
6584 minibuf_selected_window
= Qnil
;
6585 staticpro (&minibuf_selected_window
);
6587 window_scroll_pixel_based_preserve_x
= -1;
6588 window_scroll_pixel_based_preserve_y
= -1;
6589 window_scroll_preserve_hpos
= -1;
6590 window_scroll_preserve_vpos
= -1;
6592 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6593 doc
: /* Non-nil means call as function to display a help buffer.
6594 The function is called with one argument, the buffer to be displayed.
6595 Used by `with-output-to-temp-buffer'.
6596 If this function is used, then it must do the entire job of showing
6597 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6598 Vtemp_buffer_show_function
= Qnil
;
6600 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6601 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6602 Vminibuf_scroll_window
= Qnil
;
6604 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6605 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6606 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6607 is displayed in the `mode-line' face. */);
6608 mode_line_in_non_selected_windows
= 1;
6610 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6611 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6612 Vother_window_scroll_buffer
= Qnil
;
6614 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6615 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6616 auto_window_vscroll_p
= 1;
6618 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6619 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
6620 next_screen_context_lines
= 2;
6622 DEFVAR_LISP ("scroll-preserve-screen-position",
6623 Vscroll_preserve_screen_position
,
6624 doc
: /* *Controls if scroll commands move point to keep its screen position unchanged.
6625 A value of nil means point does not keep its screen position except
6626 at the scroll margin or window boundary respectively.
6627 A value of t means point keeps its screen position if the scroll
6628 command moved it vertically out of the window, e.g. when scrolling
6630 Any other value means point always keeps its screen position.
6631 Scroll commands should have the `scroll-command' property
6632 on their symbols to be controlled by this variable. */);
6633 Vscroll_preserve_screen_position
= Qnil
;
6635 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6636 doc
: /* Type of marker to use for `window-point'. */);
6637 Vwindow_point_insertion_type
= Qnil
;
6639 DEFVAR_LISP ("window-configuration-change-hook",
6640 Vwindow_configuration_change_hook
,
6641 doc
: /* Functions to call when window configuration changes.
6642 The buffer-local part is run once per window, with the relevant window
6643 selected; while the global part is run only once for the modified frame,
6644 with the relevant frame selected. */);
6645 Vwindow_configuration_change_hook
= Qnil
;
6647 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6648 doc
: /* If non-nil, then the `recenter' command with a nil argument
6649 will redraw the entire frame; the special value `tty' causes the
6650 frame to be redrawn only if it is a tty frame. */);
6651 Vrecenter_redisplay
= Qtty
;
6653 DEFVAR_LISP ("window-splits", Vwindow_splits
,
6654 doc
: /* Non-nil means splitting windows is handled specially.
6655 If this variable is nil, splitting a window gets the entire screen space
6656 for displaying the new window from the window to split. If this
6657 variable is non-nil, splitting a window may resize all windows in the
6658 same combination. This also allows to split a window that is otherwise
6659 too small or of fixed size.
6661 The value of this variable is also assigned to the split status of the
6662 new window and, provided the old and new window form a new combination,
6663 to the window that was split as well. The split status of a window can
6664 be retrieved with the function `window-splits' and altered by the
6665 function `set-window-splits'.
6667 If the value of the variable `window-nest' is non-nil, the space for the
6668 new window is exclusively taken from the window that shall be split, but
6669 the split status of the window that is split as well as that of the new
6670 window are still set to the value of this variable. */);
6671 Vwindow_splits
= Qnil
;
6673 DEFVAR_LISP ("window-nest", Vwindow_nest
,
6674 doc
: /* Non-nil means splitting a window makes a new parent window.
6675 If this variable is nil, splitting a window will create a new parent
6676 window only if the window has no parent window or the window shall
6677 become a combination orthogonal to the one it it is part of.
6679 If this variable is non-nil, splitting a window always creates a new
6680 parent window. If all splits behave this way, each frame's window tree
6681 is a binary tree and every window but the frame's root window has
6682 exactly one sibling.
6684 The value of this variable is also assigned to the nest status of the
6685 new parent window. The nest status of a window can be retrieved via the
6686 function `window-nest' and altered by the function `set-window-nest'. */);
6687 Vwindow_nest
= Qnil
;
6689 defsubr (&Sselected_window
);
6690 defsubr (&Sminibuffer_window
);
6691 defsubr (&Swindow_minibuffer_p
);
6692 defsubr (&Swindowp
);
6693 defsubr (&Swindow_live_p
);
6694 defsubr (&Swindow_frame
);
6695 defsubr (&Sframe_root_window
);
6696 defsubr (&Sframe_first_window
);
6697 defsubr (&Sframe_selected_window
);
6698 defsubr (&Sset_frame_selected_window
);
6699 defsubr (&Spos_visible_in_window_p
);
6700 defsubr (&Swindow_line_height
);
6701 defsubr (&Swindow_clone_number
);
6702 defsubr (&Swindow_buffer
);
6703 defsubr (&Swindow_parent
);
6704 defsubr (&Swindow_vchild
);
6705 defsubr (&Swindow_hchild
);
6706 defsubr (&Swindow_next
);
6707 defsubr (&Swindow_prev
);
6708 defsubr (&Swindow_splits
);
6709 defsubr (&Sset_window_splits
);
6710 defsubr (&Swindow_nest
);
6711 defsubr (&Sset_window_nest
);
6712 defsubr (&Swindow_use_time
);
6713 defsubr (&Swindow_top_line
);
6714 defsubr (&Swindow_left_column
);
6715 defsubr (&Swindow_total_size
);
6716 defsubr (&Swindow_normal_size
);
6717 defsubr (&Swindow_new_total
);
6718 defsubr (&Swindow_new_normal
);
6719 defsubr (&Sset_window_new_total
);
6720 defsubr (&Sset_window_new_normal
);
6721 defsubr (&Sresize_window_apply
);
6722 defsubr (&Swindow_body_size
);
6723 defsubr (&Swindow_hscroll
);
6724 defsubr (&Sset_window_hscroll
);
6725 defsubr (&Swindow_redisplay_end_trigger
);
6726 defsubr (&Sset_window_redisplay_end_trigger
);
6727 defsubr (&Swindow_edges
);
6728 defsubr (&Swindow_pixel_edges
);
6729 defsubr (&Swindow_absolute_pixel_edges
);
6730 defsubr (&Swindow_inside_edges
);
6731 defsubr (&Swindow_inside_pixel_edges
);
6732 defsubr (&Swindow_inside_absolute_pixel_edges
);
6733 defsubr (&Scoordinates_in_window_p
);
6734 defsubr (&Swindow_at
);
6735 defsubr (&Swindow_point
);
6736 defsubr (&Swindow_start
);
6737 defsubr (&Swindow_end
);
6738 defsubr (&Sset_window_point
);
6739 defsubr (&Sset_window_start
);
6740 defsubr (&Swindow_dedicated_p
);
6741 defsubr (&Sset_window_dedicated_p
);
6742 defsubr (&Swindow_display_table
);
6743 defsubr (&Sset_window_display_table
);
6744 defsubr (&Snext_window
);
6745 defsubr (&Sprevious_window
);
6746 defsubr (&Sget_buffer_window
);
6747 defsubr (&Sdelete_other_windows_internal
);
6748 defsubr (&Sdelete_window_internal
);
6749 defsubr (&Sresize_mini_window_internal
);
6750 defsubr (&Sset_window_buffer
);
6751 defsubr (&Sset_window_clone_number
);
6752 defsubr (&Srun_window_configuration_change_hook
);
6753 defsubr (&Sselect_window
);
6754 defsubr (&Sforce_window_update
);
6755 defsubr (&Stemp_output_buffer_show
);
6756 defsubr (&Ssplit_window_internal
);
6757 defsubr (&Sscroll_up
);
6758 defsubr (&Sscroll_down
);
6759 defsubr (&Sscroll_left
);
6760 defsubr (&Sscroll_right
);
6761 defsubr (&Sother_window_for_scrolling
);
6762 defsubr (&Sscroll_other_window
);
6763 defsubr (&Sminibuffer_selected_window
);
6764 defsubr (&Srecenter
);
6765 defsubr (&Swindow_text_height
);
6766 defsubr (&Smove_to_window_line
);
6767 defsubr (&Swindow_configuration_p
);
6768 defsubr (&Swindow_configuration_frame
);
6769 defsubr (&Sset_window_configuration
);
6770 defsubr (&Scurrent_window_configuration
);
6771 defsubr (&Swindow_tree
);
6772 defsubr (&Sset_window_margins
);
6773 defsubr (&Swindow_margins
);
6774 defsubr (&Sset_window_fringes
);
6775 defsubr (&Swindow_fringes
);
6776 defsubr (&Sset_window_scroll_bars
);
6777 defsubr (&Swindow_scroll_bars
);
6778 defsubr (&Swindow_vscroll
);
6779 defsubr (&Sset_window_vscroll
);
6780 defsubr (&Scompare_window_configurations
);
6781 defsubr (&Swindow_list
);
6782 defsubr (&Swindow_list_1
);
6783 defsubr (&Swindow_prev_buffers
);
6784 defsubr (&Sset_window_prev_buffers
);
6785 defsubr (&Swindow_next_buffers
);
6786 defsubr (&Sset_window_next_buffers
);
6787 defsubr (&Swindow_parameters
);
6788 defsubr (&Swindow_parameter
);
6789 defsubr (&Sset_window_parameter
);
6793 keys_of_window (void)
6795 initial_define_key (control_x_map
, '<', "scroll-left");
6796 initial_define_key (control_x_map
, '>', "scroll-right");
6798 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6799 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6800 initial_define_key (meta_map
, 'v', "scroll-down-command");