1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985-1987, 1993-1998, 2000-2012
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
35 #include "dispextern.h"
36 #include "blockinput.h"
37 #include "intervals.h"
38 #include "termhooks.h" /* For FRAME_TERMINAL. */
42 #endif /* HAVE_X_WINDOWS */
53 Lisp_Object Qwindowp
, Qwindow_live_p
;
54 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
55 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
56 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
57 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
58 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
59 static Lisp_Object Qsafe
, Qabove
, Qbelow
;
60 static Lisp_Object Qauto_buffer_name
, Qclone_of
;
62 static int displayed_window_lines (struct window
*);
63 static struct window
*decode_window (Lisp_Object
);
64 static int count_windows (struct window
*);
65 static int get_leaf_windows (struct window
*, struct window
**, int);
66 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
67 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
68 static void window_scroll_line_based (Lisp_Object
, int, int, int);
69 static int freeze_window_start (struct window
*, void *);
70 static Lisp_Object
window_list (void);
71 static int add_window_to_list (struct window
*, void *);
72 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
74 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
76 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
78 static void foreach_window (struct frame
*,
79 int (* fn
) (struct window
*, void *),
81 static int foreach_window_1 (struct window
*,
82 int (* fn
) (struct window
*, void *),
84 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
85 static int window_resize_check (struct window
*, int);
86 static void window_resize_apply (struct window
*, int);
87 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
89 /* This is the window in which the terminal's cursor should
90 be left when nothing is being done with it. This must
91 always be a leaf window, and its buffer is selected by
92 the top level editing loop at the end of each command.
94 This value is always the same as
95 FRAME_SELECTED_WINDOW (selected_frame). */
96 Lisp_Object selected_window
;
98 /* A list of all windows for use by next_window and Fwindow_list.
99 Functions creating or deleting windows should invalidate this cache
100 by setting it to nil. */
101 Lisp_Object Vwindow_list
;
103 /* The mini-buffer window of the selected frame.
104 Note that you cannot test for mini-bufferness of an arbitrary window
105 by comparing against this; but you can test for mini-bufferness of
106 the selected window. */
107 Lisp_Object minibuf_window
;
109 /* Non-nil means it is the window whose mode line should be
110 shown as the selected window when the minibuffer is selected. */
111 Lisp_Object minibuf_selected_window
;
113 /* Hook run at end of temp_output_buffer_show. */
114 static Lisp_Object Qtemp_buffer_show_hook
;
116 /* Incremented for each window created. */
117 static int sequence_number
;
119 /* Nonzero after init_window_once has finished. */
120 static int window_initialized
;
122 /* Hook to run when window config changes. */
123 static Lisp_Object Qwindow_configuration_change_hook
;
125 /* Used by the function window_scroll_pixel_based */
126 static int window_scroll_pixel_based_preserve_x
;
127 static int window_scroll_pixel_based_preserve_y
;
129 /* Same for window_scroll_line_based. */
130 static EMACS_INT window_scroll_preserve_hpos
;
131 static EMACS_INT window_scroll_preserve_vpos
;
133 static struct window
*
134 decode_window (register Lisp_Object window
)
137 return XWINDOW (selected_window
);
139 CHECK_LIVE_WINDOW (window
);
140 return XWINDOW (window
);
143 static struct window
*
144 decode_any_window (register Lisp_Object window
)
147 return XWINDOW (selected_window
);
149 CHECK_WINDOW (window
);
150 return XWINDOW (window
);
153 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
154 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
157 return WINDOWP (object
) ? Qt
: Qnil
;
160 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
161 doc
: /* Return t if OBJECT is a live window and nil otherwise.
162 A live window is a window that displays a buffer.
163 Internal windows and deleted windows are not live. */)
166 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
169 /* Frames and windows. */
170 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
171 doc
: /* Return the frame that window WINDOW is on.
172 If WINDOW is omitted or nil, it defaults to the selected window. */)
175 return decode_any_window (window
)->frame
;
178 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
179 doc
: /* Return the root window of FRAME-OR-WINDOW.
180 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
181 With a frame argument, return that frame's root window.
182 With a window argument, return the root window of that window's 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 minibuffer window for frame FRAME.
202 If FRAME is omitted or nil, it defaults to the selected frame. */)
206 frame
= selected_frame
;
207 CHECK_LIVE_FRAME (frame
);
208 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
211 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
212 Swindow_minibuffer_p
, 0, 1, 0,
213 doc
: /* Return non-nil if WINDOW is a minibuffer window.
214 If WINDOW is omitted or nil, it defaults to the selected window. */)
217 return MINI_WINDOW_P (decode_any_window (window
)) ? Qt
: Qnil
;
220 /* Don't move this to window.el - this must be a safe routine. */
221 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
222 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
223 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
224 Else if FRAME-OR-WINDOW denotes any window, return the first window of
225 that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
226 the first window of that frame. */)
227 (Lisp_Object frame_or_window
)
231 if (NILP (frame_or_window
))
232 window
= SELECTED_FRAME ()->root_window
;
233 else if (WINDOWP (frame_or_window
))
234 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
237 CHECK_LIVE_FRAME (frame_or_window
);
238 window
= XFRAME (frame_or_window
)->root_window
;
241 while (NILP (XWINDOW (window
)->buffer
))
243 if (! NILP (XWINDOW (window
)->hchild
))
244 window
= XWINDOW (window
)->hchild
;
245 else if (! NILP (XWINDOW (window
)->vchild
))
246 window
= XWINDOW (window
)->vchild
;
254 DEFUN ("frame-selected-window", Fframe_selected_window
,
255 Sframe_selected_window
, 0, 1, 0,
256 doc
: /* Return the selected window of FRAME-OR-WINDOW.
257 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
258 Else if FRAME-OR-WINDOW denotes any window, return the selected window
259 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
260 the selected window of that frame. */)
261 (Lisp_Object frame_or_window
)
265 if (NILP (frame_or_window
))
266 window
= SELECTED_FRAME ()->selected_window
;
267 else if (WINDOWP (frame_or_window
))
268 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
271 CHECK_LIVE_FRAME (frame_or_window
);
272 window
= XFRAME (frame_or_window
)->selected_window
;
278 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
279 Sset_frame_selected_window
, 2, 3, 0,
280 doc
: /* Set selected window of FRAME to WINDOW.
281 FRAME must be a live frame and defaults to the selected one. If FRAME
282 is the selected frame, this makes WINDOW the selected window. Optional
283 argument NORECORD non-nil means to neither change the order of recently
284 selected windows nor the buffer list. WINDOW must denote a live window.
286 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
289 frame
= selected_frame
;
291 CHECK_LIVE_FRAME (frame
);
292 CHECK_LIVE_WINDOW (window
);
294 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
295 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
297 if (EQ (frame
, selected_frame
))
298 return Fselect_window (window
, norecord
);
300 return XFRAME (frame
)->selected_window
= window
;
303 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
304 doc
: /* Return the selected window.
305 The selected window is the window in which the standard cursor for
306 selected windows appears and to which many commands apply. */)
309 return selected_window
;
312 int window_select_count
;
314 /* If select_window is called with inhibit_point_swap non-zero it will
315 not store point of the old selected window's buffer back into that
316 window's pointm slot. This is needed by Fset_window_configuration to
317 avoid that the display routine is called with selected_window set to
318 Qnil causing a subsequent crash. */
320 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
322 register struct window
*w
;
323 register struct window
*ow
;
326 CHECK_LIVE_WINDOW (window
);
328 w
= XWINDOW (window
);
329 w
->frozen_window_start_p
= 0;
333 ++window_select_count
;
334 XSETFASTINT (w
->use_time
, window_select_count
);
335 record_buffer (w
->buffer
);
338 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
341 sf
= SELECTED_FRAME ();
342 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
344 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
345 /* Use this rather than Fhandle_switch_frame
346 so that FRAME_FOCUS_FRAME is moved appropriately as we
347 move around in the state where a minibuffer in a separate
349 Fselect_frame (WINDOW_FRAME (w
), norecord
);
350 /* Fselect_frame called us back so we've done all the work already. */
351 eassert (EQ (window
, selected_window
));
355 sf
->selected_window
= window
;
357 /* Store the current buffer's actual point into the
358 old selected window. It belongs to that window,
359 and when the window is not selected, must be in the window. */
360 if (!inhibit_point_swap
)
362 ow
= XWINDOW (selected_window
);
363 if (! NILP (ow
->buffer
))
364 set_marker_both (ow
->pointm
, ow
->buffer
,
365 BUF_PT (XBUFFER (ow
->buffer
)),
366 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
369 selected_window
= window
;
371 Fset_buffer (w
->buffer
);
373 BVAR (XBUFFER (w
->buffer
), last_selected_window
) = window
;
375 /* Go to the point recorded in the window.
376 This is important when the buffer is in more
377 than one window. It also matters when
378 redisplay_window has altered point after scrolling,
379 because it makes the change only in the window. */
381 register ptrdiff_t new_point
= marker_position (w
->pointm
);
382 if (new_point
< BEGV
)
384 else if (new_point
> ZV
)
390 windows_or_buffers_changed
++;
394 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
395 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
396 Also make WINDOW's buffer current and make WINDOW the frame's selected
397 window. Return WINDOW.
399 Optional second arg NORECORD non-nil means do not put this buffer at the
400 front of the buffer list and do not make this window the most recently
403 Note that the main editor command loop sets the current buffer to the
404 buffer of the selected window before each command. */)
405 (register Lisp_Object window
, Lisp_Object norecord
)
407 return select_window (window
, norecord
, 0);
410 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
411 doc
: /* Return the buffer displayed in window WINDOW.
412 If WINDOW is omitted or nil, it defaults to the selected window.
413 Return nil for an internal window or a deleted window. */)
416 return decode_any_window (window
)->buffer
;
419 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
420 doc
: /* Return the parent window of window WINDOW.
421 If WINDOW is omitted or nil, it defaults to the selected window.
422 Return nil for a window with no parent (e.g. a root window). */)
425 return decode_any_window (window
)->parent
;
428 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 1, 1, 0,
429 doc
: /* Return the topmost child window of window WINDOW.
430 Return nil if WINDOW is a live window (live windows have no children).
431 Return nil if WINDOW is an internal window whose children form a
432 horizontal combination. */)
435 CHECK_WINDOW (window
);
436 return decode_any_window (window
)->vchild
;
439 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 1, 1, 0,
440 doc
: /* Return the leftmost child window of window WINDOW.
441 Return nil if WINDOW is a live window (live windows have no children).
442 Return nil if WINDOW is an internal window whose children form a
443 vertical combination. */)
446 CHECK_WINDOW (window
);
447 return decode_any_window (window
)->hchild
;
450 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
451 doc
: /* Return the next sibling window of window WINDOW.
452 If WINDOW is omitted or nil, it defaults to the selected window.
453 Return nil if WINDOW has no next sibling. */)
456 return decode_any_window (window
)->next
;
459 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
460 doc
: /* Return the previous sibling window of window WINDOW.
461 If WINDOW is omitted or nil, it defaults to the selected window.
462 Return nil if WINDOW has no previous sibling. */)
465 return decode_any_window (window
)->prev
;
468 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
469 doc
: /* Return combination limit of window WINDOW.
470 If the return value is nil, child windows of WINDOW can be recombined with
471 WINDOW's siblings. A return value of t means that child windows of
472 WINDOW are never \(re-)combined with WINDOW's siblings. */)
475 return decode_any_window (window
)->combination_limit
;
478 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
479 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
480 If LIMIT is nil, child windows of WINDOW can be recombined with
481 WINDOW's siblings. LIMIT t means that child windows of WINDOW are
482 never \(re-)combined with WINDOW's siblings. Other values are reserved
484 (Lisp_Object window
, Lisp_Object limit
)
486 register struct window
*w
= decode_any_window (window
);
488 w
->combination_limit
= limit
;
490 return w
->combination_limit
;
493 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
494 doc
: /* Return the use time of window WINDOW.
495 If WINDOW is omitted or nil, it defaults to the selected window.
496 The window with the highest use time is the most recently selected
497 one. The window with the lowest use time is the least recently
501 return decode_window (window
)->use_time
;
504 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
505 doc
: /* Return the total height, in lines, of window WINDOW.
506 If WINDOW is omitted or nil, it defaults to the selected window.
508 The return value includes the mode line and header line, if any.
509 If WINDOW is an internal window, the total height is the height
510 of the screen areas spanned by its children.
512 On a graphical display, this total height is reported as an
513 integer multiple of the default character height. */)
516 return decode_any_window (window
)->total_lines
;
519 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
520 doc
: /* Return the total width, in columns, of window WINDOW.
521 If WINDOW is omitted or nil, it defaults to the selected window.
523 The return value includes any vertical dividers or scroll bars
524 belonging to WINDOW. If WINDOW is an internal window, the total width
525 is the width of the screen areas spanned by its children.
527 On a graphical display, this total width is reported as an
528 integer multiple of the default character width. */)
531 return decode_any_window (window
)->total_cols
;
534 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
535 doc
: /* Return the new total size of window WINDOW.
536 If WINDOW is omitted or nil, it defaults to the selected window. */)
539 return decode_any_window (window
)->new_total
;
542 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
543 doc
: /* Return the normal height of window WINDOW.
544 If WINDOW is omitted or nil, it defaults to the selected window.
545 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
546 (Lisp_Object window
, Lisp_Object horizontal
)
548 if (NILP (horizontal
))
549 return decode_any_window (window
)->normal_lines
;
551 return decode_any_window (window
)->normal_cols
;
554 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
555 doc
: /* Return new normal size of window WINDOW.
556 If WINDOW is omitted or nil, it defaults to the selected window. */)
559 return decode_any_window (window
)->new_normal
;
562 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
563 doc
: /* Return left column of window WINDOW.
564 This is the distance, in columns, between the left edge of WINDOW and
565 the left edge of the frame's window area. For instance, the return
566 value is 0 if there is no window to the left of WINDOW.
568 If WINDOW is omitted or nil, it defaults to the selected window. */)
571 return decode_any_window (window
)->left_col
;
574 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
575 doc
: /* Return top line of window WINDOW.
576 This is the distance, in lines, between the top of WINDOW and the top
577 of the frame's window area. For instance, the return value is 0 if
578 there is no window above WINDOW.
580 If WINDOW is omitted or nil, it defaults to the selected window. */)
583 return decode_any_window (window
)->top_line
;
586 /* Return the number of lines of W's body. Don't count any mode or
590 window_body_lines (struct window
*w
)
592 int height
= XFASTINT (w
->total_lines
);
594 if (!MINI_WINDOW_P (w
))
596 if (WINDOW_WANTS_MODELINE_P (w
))
598 if (WINDOW_WANTS_HEADER_LINE_P (w
))
605 /* Return the number of columns of W's body. Don't count columns
606 occupied by the scroll bar or the vertical bar separating W from its
607 right sibling. On window-systems don't count fringes or display
611 window_body_cols (struct window
*w
)
613 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
614 int width
= XINT (w
->total_cols
);
616 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
617 /* Scroll bars occupy a few columns. */
618 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
619 else if (!FRAME_WINDOW_P (f
)
620 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
621 /* The column of `|' characters separating side-by-side windows
622 occupies one column only. */
625 if (FRAME_WINDOW_P (f
))
626 /* On window-systems, fringes and display margins cannot be
627 used for normal text. */
628 width
-= (WINDOW_FRINGE_COLS (w
)
629 + WINDOW_LEFT_MARGIN_COLS (w
)
630 + WINDOW_RIGHT_MARGIN_COLS (w
));
635 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
636 doc
: /* Return the height, in lines, of WINDOW's text area.
637 If WINDOW is omitted or nil, it defaults to the selected window.
638 Signal an error if the window is not live.
640 The returned height does not include the mode line or header line.
641 On a graphical display, the height is expressed as an integer multiple
642 of the default character height. If a line at the bottom of the text
643 area is only partially visible, that counts as a whole line; to
644 exclude partially-visible lines, use `window-text-height'. */)
647 struct window
*w
= decode_window (window
);
648 return make_number (window_body_lines (w
));
651 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
652 doc
: /* Return the width, in columns, of WINDOW's text area.
653 If WINDOW is omitted or nil, it defaults to the selected window.
654 Signal an error if the window is not live.
656 The return value does not include any vertical dividers, fringe or
657 marginal areas, or scroll bars. On a graphical display, the width is
658 expressed as an integer multiple of the default character width. */)
661 struct window
*w
= decode_window (window
);
662 return make_number (window_body_cols (w
));
665 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
666 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
667 WINDOW must be a live window and defaults to the selected one. */)
670 return decode_window (window
)->hscroll
;
673 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
674 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
675 If WINDOW is nil, the selected window is used.
676 Return NCOL. NCOL should be zero or positive.
678 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
679 window so that the location of point moves off-window. */)
680 (Lisp_Object window
, Lisp_Object ncol
)
682 struct window
*w
= decode_window (window
);
686 hscroll
= clip_to_bounds (0, XINT (ncol
), PTRDIFF_MAX
);
688 /* Prevent redisplay shortcuts when changing the hscroll. */
689 if (XINT (w
->hscroll
) != hscroll
)
690 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
692 w
->hscroll
= make_number (hscroll
);
696 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
697 Swindow_redisplay_end_trigger
, 0, 1, 0,
698 doc
: /* Return WINDOW's redisplay end trigger value.
699 WINDOW defaults to the selected window.
700 See `set-window-redisplay-end-trigger' for more information. */)
703 return decode_window (window
)->redisplay_end_trigger
;
706 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
707 Sset_window_redisplay_end_trigger
, 2, 2, 0,
708 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
709 VALUE should be a buffer position (typically a marker) or nil.
710 If it is a buffer position, then if redisplay in WINDOW reaches a position
711 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
712 with two arguments: WINDOW, and the end trigger value.
713 Afterwards the end-trigger value is reset to nil. */)
714 (register Lisp_Object window
, Lisp_Object value
)
716 register struct window
*w
;
718 w
= decode_window (window
);
719 w
->redisplay_end_trigger
= value
;
723 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
724 doc
: /* Return a list of the edge coordinates of WINDOW.
725 The list has the form (LEFT TOP RIGHT BOTTOM).
726 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
727 all relative to 0, 0 at top left corner of frame.
729 RIGHT is one more than the rightmost column occupied by WINDOW.
730 BOTTOM is one more than the bottommost row occupied by WINDOW.
731 The edges include the space used by WINDOW's scroll bar, display
732 margins, fringes, header line, and/or mode line. For the edges of
733 just the text area, use `window-inside-edges'. */)
736 register struct window
*w
= decode_any_window (window
);
738 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
739 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
740 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
741 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
745 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
746 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
747 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
748 the top left corner of the frame.
750 RIGHT is one more than the rightmost x position occupied by WINDOW.
751 BOTTOM is one more than the bottommost y position occupied by WINDOW.
752 The pixel edges include the space used by WINDOW's scroll bar, display
753 margins, fringes, header line, and/or mode line. For the pixel edges
754 of just the text area, use `window-inside-pixel-edges'. */)
757 register struct window
*w
= decode_any_window (window
);
759 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
760 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
761 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
762 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
767 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
769 struct frame
*f
= XFRAME (w
->frame
);
771 #ifdef FRAME_MENUBAR_HEIGHT
772 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
774 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
775 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
776 #elif FRAME_TOOLBAR_HEIGHT
777 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
779 #ifdef FRAME_NS_TITLEBAR_HEIGHT
780 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
782 *add_x
= f
->left_pos
;
783 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
784 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
788 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
789 Swindow_absolute_pixel_edges
, 0, 1, 0,
790 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
791 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
792 the top left corner of the display.
794 RIGHT is one more than the rightmost x position occupied by WINDOW.
795 BOTTOM is one more than the bottommost y position occupied by WINDOW.
796 The pixel edges include the space used by WINDOW's scroll bar, display
797 margins, fringes, header line, and/or mode line. For the pixel edges
798 of just the text area, use `window-inside-absolute-pixel-edges'. */)
801 register struct window
*w
= decode_any_window (window
);
803 calc_absolute_offset (w
, &add_x
, &add_y
);
805 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
) + add_x
),
806 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
) + add_y
),
807 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
) + add_x
),
808 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
) + add_y
),
812 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
813 doc
: /* Return a list of the edge coordinates of WINDOW.
814 The list has the form (LEFT TOP RIGHT BOTTOM).
815 TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
816 all relative to 0, 0 at top left corner of frame.
818 RIGHT is one more than the rightmost column of WINDOW's text area.
819 BOTTOM is one more than the bottommost row of WINDOW's text area.
820 The inside edges do not include the space used by the WINDOW's scroll
821 bar, display margins, fringes, header line, and/or mode line. */)
824 register struct window
*w
= decode_window (window
);
826 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
827 + WINDOW_LEFT_MARGIN_COLS (w
)
828 + WINDOW_LEFT_FRINGE_COLS (w
)),
829 make_number (WINDOW_TOP_EDGE_LINE (w
)
830 + WINDOW_HEADER_LINE_LINES (w
)),
831 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
832 - WINDOW_RIGHT_MARGIN_COLS (w
)
833 - WINDOW_RIGHT_FRINGE_COLS (w
)),
834 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
835 - WINDOW_MODE_LINE_LINES (w
)));
838 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
839 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
840 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
841 at the top left corner of the frame's window area.
843 RIGHT is one more than the rightmost x position of WINDOW's text area.
844 BOTTOM is one more than the bottommost y position of WINDOW's text area.
845 The inside edges do not include the space used by WINDOW's scroll bar,
846 display margins, fringes, header line, and/or mode line. */)
849 register struct window
*w
= decode_window (window
);
851 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
852 + WINDOW_LEFT_MARGIN_WIDTH (w
)
853 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
854 make_number (WINDOW_TOP_EDGE_Y (w
)
855 + WINDOW_HEADER_LINE_HEIGHT (w
)),
856 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
857 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
858 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
859 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
860 - WINDOW_MODE_LINE_HEIGHT (w
)));
863 DEFUN ("window-inside-absolute-pixel-edges",
864 Fwindow_inside_absolute_pixel_edges
,
865 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
866 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
867 The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
868 at the top left corner of the frame's window area.
870 RIGHT is one more than the rightmost x position of WINDOW's text area.
871 BOTTOM is one more than the bottommost y position of WINDOW's text area.
872 The inside edges do not include the space used by WINDOW's scroll bar,
873 display margins, fringes, header line, and/or mode line. */)
876 register struct window
*w
= decode_window (window
);
878 calc_absolute_offset (w
, &add_x
, &add_y
);
880 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
881 + WINDOW_LEFT_MARGIN_WIDTH (w
)
882 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
883 make_number (WINDOW_TOP_EDGE_Y (w
)
884 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
885 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
886 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
887 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
888 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
889 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
892 /* Test if the character at column X, row Y is within window W.
893 If it is not, return ON_NOTHING;
894 if it is in the window's text area, return ON_TEXT;
895 if it is on the window's modeline, return ON_MODE_LINE;
896 if it is on the border between the window and its right sibling,
897 return ON_VERTICAL_BORDER.
898 if it is on a scroll bar, return ON_SCROLL_BAR.
899 if it is on the window's top line, return ON_HEADER_LINE;
900 if it is in left or right fringe of the window,
901 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
902 if it is in the marginal area to the left/right of the window,
903 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
905 X and Y are frame relative pixel coordinates. */
907 static enum window_part
908 coordinates_in_window (register struct window
*w
, int x
, int y
)
910 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
911 enum window_part part
;
912 int ux
= FRAME_COLUMN_WIDTH (f
);
913 int left_x
= WINDOW_LEFT_EDGE_X (w
);
914 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
915 int top_y
= WINDOW_TOP_EDGE_Y (w
);
916 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
917 /* The width of the area where the vertical line can be dragged.
918 (Between mode lines for instance. */
919 int grabbable_width
= ux
;
920 int lmargin_width
, rmargin_width
, text_left
, text_right
;
922 /* Outside any interesting row or column? */
923 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
926 /* On the mode line or header line? */
927 if ((WINDOW_WANTS_MODELINE_P (w
)
928 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
929 && (part
= ON_MODE_LINE
))
930 || (WINDOW_WANTS_HEADER_LINE_P (w
)
931 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
932 && (part
= ON_HEADER_LINE
)))
934 /* If it's under/over the scroll bar portion of the mode/header
935 line, say it's on the vertical line. That's to be able to
936 resize windows horizontally in case we're using toolkit scroll
937 bars. Note: If scrollbars are on the left, the window that
938 must be eventually resized is that on the left of WINDOW. */
939 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
940 && !WINDOW_LEFTMOST_P (w
)
941 && eabs (x
- left_x
) < grabbable_width
)
942 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
943 && !WINDOW_RIGHTMOST_P (w
)
944 && eabs (x
- right_x
) < grabbable_width
))
945 return ON_VERTICAL_BORDER
;
950 /* In what's below, we subtract 1 when computing right_x because we
951 want the rightmost pixel, which is given by left_pixel+width-1. */
952 if (w
->pseudo_window_p
)
955 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
959 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
960 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
963 /* Outside any interesting column? */
964 if (x
< left_x
|| x
> right_x
)
965 return ON_SCROLL_BAR
;
967 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
968 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
970 text_left
= window_box_left (w
, TEXT_AREA
);
971 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
973 if (FRAME_WINDOW_P (f
))
975 if (!w
->pseudo_window_p
976 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
977 && !WINDOW_RIGHTMOST_P (w
)
978 && (eabs (x
- right_x
) < grabbable_width
))
979 return ON_VERTICAL_BORDER
;
981 /* Need to say "x > right_x" rather than >=, since on character
982 terminals, the vertical line's x coordinate is right_x. */
983 else if (!w
->pseudo_window_p
984 && !WINDOW_RIGHTMOST_P (w
)
986 return ON_VERTICAL_BORDER
;
990 if (lmargin_width
> 0
991 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
992 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
993 : (x
< left_x
+ lmargin_width
)))
994 return ON_LEFT_MARGIN
;
996 return ON_LEFT_FRINGE
;
1001 if (rmargin_width
> 0
1002 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1003 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1004 : (x
>= right_x
- rmargin_width
)))
1005 return ON_RIGHT_MARGIN
;
1007 return ON_RIGHT_FRINGE
;
1010 /* Everything special ruled out - must be on text area */
1014 /* Take X is the frame-relative pixel x-coordinate, and return the
1015 x-coordinate relative to part PART of window W. */
1017 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1019 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1024 return x
- window_box_left (w
, TEXT_AREA
);
1026 case ON_LEFT_FRINGE
:
1029 case ON_RIGHT_FRINGE
:
1030 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1032 case ON_LEFT_MARGIN
:
1034 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1035 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1037 case ON_RIGHT_MARGIN
:
1039 - ((w
->pseudo_window_p
)
1040 ? WINDOW_TOTAL_WIDTH (w
)
1041 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1042 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1043 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1044 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1047 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1052 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1053 Scoordinates_in_window_p
, 2, 2, 0,
1054 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1055 WINDOW must be a live window.
1056 COORDINATES is a cons of the form (X . Y), X and Y being distances
1057 measured in characters from the upper-left corner of the frame.
1058 \(0 . 0) denotes the character in the upper left corner of the
1060 If COORDINATES are in the text portion of WINDOW,
1061 the coordinates relative to the window are returned.
1062 If they are in the mode line of WINDOW, `mode-line' is returned.
1063 If they are in the top mode line of WINDOW, `header-line' is returned.
1064 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1065 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1066 If they are on the border between WINDOW and its right sibling,
1067 `vertical-line' is returned.
1068 If they are in the windows's left or right marginal areas, `left-margin'\n\
1069 or `right-margin' is returned. */)
1070 (register Lisp_Object coordinates
, Lisp_Object window
)
1077 CHECK_LIVE_WINDOW (window
);
1078 w
= XWINDOW (window
);
1079 f
= XFRAME (w
->frame
);
1080 CHECK_CONS (coordinates
);
1081 lx
= Fcar (coordinates
);
1082 ly
= Fcdr (coordinates
);
1083 CHECK_NUMBER_OR_FLOAT (lx
);
1084 CHECK_NUMBER_OR_FLOAT (ly
);
1085 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1086 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1088 switch (coordinates_in_window (w
, x
, y
))
1094 /* Convert X and Y to window relative pixel coordinates, and
1095 return the canonical char units. */
1096 x
-= window_box_left (w
, TEXT_AREA
);
1097 y
-= WINDOW_TOP_EDGE_Y (w
);
1098 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1099 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1104 case ON_VERTICAL_BORDER
:
1105 return Qvertical_line
;
1107 case ON_HEADER_LINE
:
1108 return Qheader_line
;
1110 case ON_LEFT_FRINGE
:
1111 return Qleft_fringe
;
1113 case ON_RIGHT_FRINGE
:
1114 return Qright_fringe
;
1116 case ON_LEFT_MARGIN
:
1117 return Qleft_margin
;
1119 case ON_RIGHT_MARGIN
:
1120 return Qright_margin
;
1123 /* Historically we are supposed to return nil in this case. */
1132 /* Callback for foreach_window, used in window_from_coordinates.
1133 Check if window W contains coordinates specified by USER_DATA which
1134 is actually a pointer to a struct check_window_data CW.
1136 Check if window W contains coordinates *CW->x and *CW->y. If it
1137 does, return W in *CW->window, as Lisp_Object, and return in
1138 *CW->part the part of the window under coordinates *X,*Y. Return
1139 zero from this function to stop iterating over windows. */
1141 struct check_window_data
1143 Lisp_Object
*window
;
1145 enum window_part
*part
;
1149 check_window_containing (struct window
*w
, void *user_data
)
1151 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1152 enum window_part found
;
1155 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1156 if (found
!= ON_NOTHING
)
1159 XSETWINDOW (*cw
->window
, w
);
1167 /* Find the window containing frame-relative pixel position X/Y and
1168 return it as a Lisp_Object.
1170 If X, Y is on one of the window's special `window_part' elements,
1171 set *PART to the id of that element.
1173 If there is no window under X, Y return nil and leave *PART
1174 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1176 This function was previously implemented with a loop cycling over
1177 windows with Fnext_window, and starting with the frame's selected
1178 window. It turned out that this doesn't work with an
1179 implementation of next_window using Vwindow_list, because
1180 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1181 tree of F when this function is called asynchronously from
1182 note_mouse_highlight. The original loop didn't terminate in this
1186 window_from_coordinates (struct frame
*f
, int x
, int y
,
1187 enum window_part
*part
, int tool_bar_p
)
1190 struct check_window_data cw
;
1191 enum window_part dummy
;
1197 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1198 foreach_window (f
, check_window_containing
, &cw
);
1200 /* If not found above, see if it's in the tool bar window, if a tool
1204 && WINDOWP (f
->tool_bar_window
)
1205 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1206 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1210 window
= f
->tool_bar_window
;
1216 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1217 doc
: /* Return window containing coordinates X and Y on FRAME.
1218 FRAME must be a live frame and defaults to the selected one.
1219 The top left corner of the frame is considered to be row 0,
1221 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1226 frame
= selected_frame
;
1227 CHECK_LIVE_FRAME (frame
);
1230 /* Check that arguments are integers or floats. */
1231 CHECK_NUMBER_OR_FLOAT (x
);
1232 CHECK_NUMBER_OR_FLOAT (y
);
1234 return window_from_coordinates (f
,
1235 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1236 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1237 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1238 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1242 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1243 doc
: /* Return current value of point in WINDOW.
1244 WINDOW must be a live window and defaults to the selected one.
1246 For a nonselected window, this is the value point would have
1247 if that window were selected.
1249 Note that, when WINDOW is the selected window and its buffer
1250 is also currently selected, the value returned is the same as (point).
1251 It would be more strictly correct to return the `top-level' value
1252 of point, outside of any save-excursion forms.
1253 But that is hard to define. */)
1254 (Lisp_Object window
)
1256 register struct window
*w
= decode_window (window
);
1258 if (w
== XWINDOW (selected_window
)
1259 && current_buffer
== XBUFFER (w
->buffer
))
1261 return Fmarker_position (w
->pointm
);
1264 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1265 doc
: /* Return position at which display currently starts in WINDOW.
1266 WINDOW must be a live window and defaults to the selected one.
1267 This is updated by redisplay or by calling `set-window-start'. */)
1268 (Lisp_Object window
)
1270 return Fmarker_position (decode_window (window
)->start
);
1273 /* This is text temporarily removed from the doc string below.
1275 This function returns nil if the position is not currently known.
1276 That happens when redisplay is preempted and doesn't finish.
1277 If in that case you want to compute where the end of the window would
1278 have been if redisplay had finished, do this:
1280 (goto-char (window-start window))
1281 (vertical-motion (1- (window-height window)) window)
1284 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1285 doc
: /* Return position at which display currently ends in WINDOW.
1286 WINDOW must be a live window and defaults to the selected one.
1287 This is updated by redisplay, when it runs to completion.
1288 Simply changing the buffer text or setting `window-start'
1289 does not update this value.
1290 Return nil if there is no recorded value. (This can happen if the
1291 last redisplay of WINDOW was preempted, and did not finish.)
1292 If UPDATE is non-nil, compute the up-to-date position
1293 if it isn't already recorded. */)
1294 (Lisp_Object window
, Lisp_Object update
)
1297 struct window
*w
= decode_window (window
);
1305 #if 0 /* This change broke some things. We should make it later. */
1306 /* If we don't know the end position, return nil.
1307 The user can compute it with vertical-motion if he wants to.
1308 It would be nicer to do it automatically,
1309 but that's so slow that it would probably bother people. */
1310 if (NILP (w
->window_end_valid
))
1315 && ! (! NILP (w
->window_end_valid
)
1316 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1317 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1320 struct text_pos startp
;
1322 struct buffer
*old_buffer
= NULL
;
1323 void *itdata
= NULL
;
1325 /* Cannot use Fvertical_motion because that function doesn't
1326 cope with variable-height lines. */
1327 if (b
!= current_buffer
)
1329 old_buffer
= current_buffer
;
1330 set_buffer_internal (b
);
1333 /* In case W->start is out of the range, use something
1334 reasonable. This situation occurred when loading a file with
1335 `-l' containing a call to `rmail' with subsequent other
1336 commands. At the end, W->start happened to be BEG, while
1337 rmail had already narrowed the buffer. */
1338 if (XMARKER (w
->start
)->charpos
< BEGV
)
1339 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1340 else if (XMARKER (w
->start
)->charpos
> ZV
)
1341 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1343 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1345 itdata
= bidi_shelve_cache ();
1346 start_display (&it
, w
, startp
);
1347 move_it_vertically (&it
, window_box_height (w
));
1348 if (it
.current_y
< it
.last_visible_y
)
1349 move_it_past_eol (&it
);
1350 value
= make_number (IT_CHARPOS (it
));
1351 bidi_unshelve_cache (itdata
, 0);
1354 set_buffer_internal (old_buffer
);
1357 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1362 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1363 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1365 (Lisp_Object window
, Lisp_Object pos
)
1367 register struct window
*w
= decode_window (window
);
1369 CHECK_NUMBER_COERCE_MARKER (pos
);
1370 if (w
== XWINDOW (selected_window
)
1371 && XBUFFER (w
->buffer
) == current_buffer
)
1374 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1376 /* We have to make sure that redisplay updates the window to show
1377 the new value of point. */
1378 if (!EQ (window
, selected_window
))
1379 ++windows_or_buffers_changed
;
1384 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1385 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1386 If WINDOW is nil, the selected window is used. Return POS.
1387 Optional third arg NOFORCE non-nil inhibits next redisplay from
1388 overriding motion of point in order to display at this exact start. */)
1389 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1391 register struct window
*w
= decode_window (window
);
1393 CHECK_NUMBER_COERCE_MARKER (pos
);
1394 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1395 /* this is not right, but much easier than doing what is right. */
1396 w
->start_at_line_beg
= Qnil
;
1398 w
->force_start
= Qt
;
1399 w
->update_mode_line
= Qt
;
1400 XSETFASTINT (w
->last_modified
, 0);
1401 XSETFASTINT (w
->last_overlay_modified
, 0);
1402 if (!EQ (window
, selected_window
))
1403 windows_or_buffers_changed
++;
1408 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1409 Spos_visible_in_window_p
, 0, 3, 0,
1410 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1411 Return nil if that position is scrolled vertically out of view.
1412 If a character is only partially visible, nil is returned, unless the
1413 optional argument PARTIALLY is non-nil.
1414 If POS is only out of view because of horizontal scrolling, return non-nil.
1415 If POS is t, it specifies the position of the last visible glyph in WINDOW.
1416 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
1418 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1419 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1420 where X and Y are the pixel coordinates relative to the top left corner
1421 of the window. The remaining elements are omitted if the character after
1422 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1423 off-window at the top and bottom of the row, ROWH is the height of the
1424 display row, and VPOS is the row number (0-based) containing POS. */)
1425 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1427 register struct window
*w
;
1428 register EMACS_INT posint
;
1429 register struct buffer
*buf
;
1430 struct text_pos top
;
1431 Lisp_Object in_window
= Qnil
;
1432 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1435 w
= decode_window (window
);
1436 buf
= XBUFFER (w
->buffer
);
1437 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1441 else if (!NILP (pos
))
1443 CHECK_NUMBER_COERCE_MARKER (pos
);
1444 posint
= XINT (pos
);
1446 else if (w
== XWINDOW (selected_window
))
1449 posint
= XMARKER (w
->pointm
)->charpos
;
1451 /* If position is above window start or outside buffer boundaries,
1452 or if window start is out of range, position is not visible. */
1454 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1455 && CHARPOS (top
) >= BUF_BEGV (buf
)
1456 && CHARPOS (top
) <= BUF_ZV (buf
)
1457 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1458 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1461 if (!NILP (in_window
) && !NILP (partially
))
1463 Lisp_Object part
= Qnil
;
1465 part
= list4 (make_number (rtop
), make_number (rbot
),
1466 make_number (rowh
), make_number (vpos
));
1467 in_window
= Fcons (make_number (x
),
1468 Fcons (make_number (y
), part
));
1474 DEFUN ("window-line-height", Fwindow_line_height
,
1475 Swindow_line_height
, 0, 2, 0,
1476 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1477 WINDOW defaults to the selected window.
1479 Return height of current line if LINE is omitted or nil. Return height of
1480 header or mode line if LINE is `header-line' or `mode-line'.
1481 Otherwise, LINE is a text line number starting from 0. A negative number
1482 counts from the end of the window.
1484 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1485 in pixels of the visible part of the line, VPOS and YPOS are the
1486 vertical position in lines and pixels of the line, relative to the top
1487 of the first text line, and OFFBOT is the number of off-window pixels at
1488 the bottom of the text line. If there are off-window pixels at the top
1489 of the (first) text line, YPOS is negative.
1491 Return nil if window display is not up-to-date. In that case, use
1492 `pos-visible-in-window-p' to obtain the information. */)
1493 (Lisp_Object line
, Lisp_Object window
)
1495 register struct window
*w
;
1496 register struct buffer
*b
;
1497 struct glyph_row
*row
, *end_row
;
1501 w
= decode_window (window
);
1503 if (noninteractive
|| w
->pseudo_window_p
)
1506 CHECK_BUFFER (w
->buffer
);
1507 b
= XBUFFER (w
->buffer
);
1509 /* Fail if current matrix is not up-to-date. */
1510 if (NILP (w
->window_end_valid
)
1511 || current_buffer
->clip_changed
1512 || current_buffer
->prevent_redisplay_optimizations_p
1513 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
1514 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
1520 if (i
< 0 || i
>= w
->current_matrix
->nrows
1521 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1523 max_y
= window_text_bottom_y (w
);
1527 if (EQ (line
, Qheader_line
))
1529 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1531 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1532 if (!row
->enabled_p
)
1534 return list4 (make_number (row
->height
),
1535 make_number (0), make_number (0),
1539 if (EQ (line
, Qmode_line
))
1541 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1542 if (!row
->enabled_p
)
1544 return list4 (make_number (row
->height
),
1545 make_number (0), /* not accurate */
1546 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
1547 + window_text_bottom_y (w
)),
1551 CHECK_NUMBER (line
);
1554 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1555 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1556 max_y
= window_text_bottom_y (w
);
1559 while ((n
< 0 || i
< n
)
1560 && row
<= end_row
&& row
->enabled_p
1561 && row
->y
+ row
->height
< max_y
)
1564 if (row
> end_row
|| !row
->enabled_p
)
1576 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1577 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
1579 make_number (row
->y
),
1580 make_number (crop
));
1583 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1585 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1586 More precisely, return the value assigned by the last call of
1587 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1588 never called with WINDOW as its argument, or the value set by that
1589 function was internally reset since its last call. WINDOW defaults to
1590 the selected window.
1592 When a window is dedicated to its buffer, `display-buffer' will refrain
1593 from displaying another buffer in it. `get-lru-window' and
1594 `get-largest-window' treat dedicated windows specially.
1595 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1596 `kill-buffer' can delete a dedicated window and the containing frame.
1598 Functions like `set-window-buffer' may change the buffer displayed by a
1599 window, unless that window is "strongly" dedicated to its buffer, that
1600 is the value returned by `window-dedicated-p' is t. */)
1601 (Lisp_Object window
)
1603 return decode_window (window
)->dedicated
;
1606 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1607 Sset_window_dedicated_p
, 2, 2, 0,
1608 doc
: /* Mark WINDOW as dedicated according to FLAG.
1609 WINDOW must be a live window and defaults to the selected one. FLAG
1610 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1611 mark WINDOW as non-dedicated. Return FLAG.
1613 When a window is dedicated to its buffer, `display-buffer' will refrain
1614 from displaying another buffer in it. `get-lru-window' and
1615 `get-largest-window' treat dedicated windows specially.
1616 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1617 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1618 and the containing frame.
1620 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1621 its buffer. Functions like `set-window-buffer' may change the buffer
1622 displayed by a window, unless that window is strongly dedicated to its
1623 buffer. If and when `set-window-buffer' displays another buffer in a
1624 window, it also makes sure that the window is no more dedicated. */)
1625 (Lisp_Object window
, Lisp_Object flag
)
1627 register struct window
*w
= decode_window (window
);
1629 w
->dedicated
= flag
;
1630 return w
->dedicated
;
1633 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1635 doc
: /* Return buffers previously shown in WINDOW.
1636 WINDOW must be a live window and defaults to the selected one.
1638 The return value is a list of elements (BUFFER WINDOW-START POS),
1639 where BUFFER is a buffer, WINDOW-START is the start position of the
1640 window for that buffer, and POS is a window-specific point value. */)
1641 (Lisp_Object window
)
1643 return decode_window (window
)->prev_buffers
;
1646 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1647 Sset_window_prev_buffers
, 2, 2, 0,
1648 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1649 WINDOW must be a live window and defaults to the selected one.
1651 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1652 where BUFFER is a buffer, WINDOW-START is the start position of the
1653 window for that buffer, and POS is a window-specific point value. */)
1654 (Lisp_Object window
, Lisp_Object prev_buffers
)
1656 return decode_window (window
)->prev_buffers
= prev_buffers
;
1659 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1661 doc
: /* Return list of buffers recently re-shown in WINDOW.
1662 WINDOW must be a live window and defaults to the selected one. */)
1663 (Lisp_Object window
)
1665 return decode_window (window
)->next_buffers
;
1668 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1669 Sset_window_next_buffers
, 2, 2, 0,
1670 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1671 WINDOW must be a live window and defaults to the selected one.
1672 NEXT-BUFFERS should be a list of buffers. */)
1673 (Lisp_Object window
, Lisp_Object next_buffers
)
1675 return decode_window (window
)->next_buffers
= next_buffers
;
1678 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1680 doc
: /* Return the parameters of WINDOW and their values.
1681 WINDOW defaults to the selected window. The return value is a list of
1682 elements of the form (PARAMETER . VALUE). */)
1683 (Lisp_Object window
)
1685 return Fcopy_alist (decode_any_window (window
)->window_parameters
);
1688 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1690 doc
: /* Return WINDOW's value for PARAMETER.
1691 WINDOW defaults to the selected window. */)
1692 (Lisp_Object window
, Lisp_Object parameter
)
1696 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1697 return CDR_SAFE (result
);
1700 DEFUN ("set-window-parameter", Fset_window_parameter
,
1701 Sset_window_parameter
, 3, 3, 0,
1702 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1703 WINDOW defaults to the selected window. Return VALUE. */)
1704 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1706 register struct window
*w
= decode_any_window (window
);
1707 Lisp_Object old_alist_elt
;
1709 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1710 if (NILP (old_alist_elt
))
1711 w
->window_parameters
= Fcons (Fcons (parameter
, value
), w
->window_parameters
);
1713 Fsetcdr (old_alist_elt
, value
);
1717 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1719 doc
: /* Return the display-table that WINDOW is using.
1720 WINDOW defaults to the selected window. */)
1721 (Lisp_Object window
)
1723 return decode_window (window
)->display_table
;
1726 /* Get the display table for use on window W. This is either W's
1727 display table or W's buffer's display table. Ignore the specified
1728 tables if they are not valid; if no valid table is specified,
1731 struct Lisp_Char_Table
*
1732 window_display_table (struct window
*w
)
1734 struct Lisp_Char_Table
*dp
= NULL
;
1736 if (DISP_TABLE_P (w
->display_table
))
1737 dp
= XCHAR_TABLE (w
->display_table
);
1738 else if (BUFFERP (w
->buffer
))
1740 struct buffer
*b
= XBUFFER (w
->buffer
);
1742 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1743 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1744 else if (DISP_TABLE_P (Vstandard_display_table
))
1745 dp
= XCHAR_TABLE (Vstandard_display_table
);
1751 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1752 doc
: /* Set WINDOW's display-table to TABLE. */)
1753 (register Lisp_Object window
, Lisp_Object table
)
1755 register struct window
*w
;
1757 w
= decode_window (window
);
1758 w
->display_table
= table
;
1762 /* Record info on buffer window W is displaying
1763 when it is about to cease to display that buffer. */
1765 unshow_buffer (register struct window
*w
)
1772 if (b
!= XMARKER (w
->pointm
)->buffer
)
1776 if (w
== XWINDOW (selected_window
)
1777 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1778 /* Do this except when the selected window's buffer
1779 is being removed from some other window. */
1781 /* last_window_start records the start position that this buffer
1782 had in the last window to be disconnected from it.
1783 Now that this statement is unconditional,
1784 it is possible for the buffer to be displayed in the
1785 selected window, while last_window_start reflects another
1786 window which was recently showing the same buffer.
1787 Some people might say that might be a good thing. Let's see. */
1788 b
->last_window_start
= marker_position (w
->start
);
1790 /* Point in the selected window's buffer
1791 is actually stored in that buffer, and the window's pointm isn't used.
1792 So don't clobber point in that buffer. */
1793 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1794 /* This line helps to fix Horsley's testbug.el bug. */
1795 && !(WINDOWP (BVAR (b
, last_selected_window
))
1796 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1797 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1798 temp_set_point_both (b
,
1799 clip_to_bounds (BUF_BEGV (b
),
1800 XMARKER (w
->pointm
)->charpos
,
1802 clip_to_bounds (BUF_BEGV_BYTE (b
),
1803 marker_byte_position (w
->pointm
),
1806 if (WINDOWP (BVAR (b
, last_selected_window
))
1807 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1808 BVAR (b
, last_selected_window
) = Qnil
;
1811 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1812 means change window structure only. Otherwise store geometry and
1813 other settings as well. */
1815 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1817 register Lisp_Object tem
;
1818 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1820 /* If OLD is its frame's root window, then NEW is the new
1821 root window for that frame. */
1822 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1823 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = new;
1827 n
->left_col
= o
->left_col
;
1828 n
->top_line
= o
->top_line
;
1829 n
->total_cols
= o
->total_cols
;
1830 n
->total_lines
= o
->total_lines
;
1831 n
->normal_cols
= o
->normal_cols
;
1832 o
->normal_cols
= make_float (1.0);
1833 n
->normal_lines
= o
->normal_lines
;
1834 o
->normal_lines
= make_float (1.0);
1835 n
->desired_matrix
= n
->current_matrix
= 0;
1837 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1838 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1839 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1840 n
->phys_cursor_type
= -1;
1841 n
->phys_cursor_width
= -1;
1842 n
->must_be_updated_p
= 0;
1843 n
->pseudo_window_p
= 0;
1844 XSETFASTINT (n
->window_end_vpos
, 0);
1845 XSETFASTINT (n
->window_end_pos
, 0);
1846 n
->window_end_valid
= Qnil
;
1847 n
->frozen_window_start_p
= 0;
1850 n
->next
= tem
= o
->next
;
1852 XWINDOW (tem
)->prev
= new;
1854 n
->prev
= tem
= o
->prev
;
1856 XWINDOW (tem
)->next
= new;
1858 n
->parent
= tem
= o
->parent
;
1861 if (EQ (XWINDOW (tem
)->vchild
, old
))
1862 XWINDOW (tem
)->vchild
= new;
1863 if (EQ (XWINDOW (tem
)->hchild
, old
))
1864 XWINDOW (tem
)->hchild
= new;
1868 /* If window WINDOW and its parent window are iso-combined, merge
1869 WINDOW's children into those of its parent window and mark WINDOW as
1873 recombine_windows (Lisp_Object window
)
1875 struct window
*w
, *p
, *c
;
1876 Lisp_Object parent
, child
;
1879 w
= XWINDOW (window
);
1881 if (!NILP (parent
) && NILP (w
->combination_limit
))
1883 p
= XWINDOW (parent
);
1884 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
1885 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
1886 /* WINDOW and PARENT are both either a vertical or a horizontal
1889 horflag
= NILP (w
->vchild
);
1890 child
= horflag
? w
->hchild
: w
->vchild
;
1891 c
= XWINDOW (child
);
1893 /* Splice WINDOW's children into its parent's children and
1894 assign new normal sizes. */
1903 XWINDOW (w
->prev
)->next
= child
;
1912 = make_float (XFLOATINT (c
->total_cols
)
1913 / XFLOATINT (p
->total_cols
));
1916 = make_float (XFLOATINT (c
->total_lines
)
1917 / XFLOATINT (p
->total_lines
));
1921 if (!NILP (w
->next
))
1924 XWINDOW (c
->next
)->prev
= child
;
1932 c
= XWINDOW (child
);
1936 /* WINDOW can be deleted now. */
1937 w
->vchild
= w
->hchild
= Qnil
;
1942 /* If WINDOW can be deleted, delete it. */
1944 delete_deletable_window (Lisp_Object window
)
1946 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
1947 call1 (Qdelete_window
, window
);
1950 /***********************************************************************
1952 ***********************************************************************/
1954 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1955 pointer. This is a callback function for foreach_window, used in
1956 the window_list function. */
1959 add_window_to_list (struct window
*w
, void *user_data
)
1961 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1963 XSETWINDOW (window
, w
);
1964 *list
= Fcons (window
, *list
);
1969 /* Return a list of all windows, for use by next_window. If
1970 Vwindow_list is a list, return that list. Otherwise, build a new
1971 list, cache it in Vwindow_list, and return that. */
1976 if (!CONSP (Vwindow_list
))
1980 Vwindow_list
= Qnil
;
1981 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1983 Lisp_Object args
[2];
1985 /* We are visiting windows in canonical order, and add
1986 new windows at the front of args[1], which means we
1987 have to reverse this list at the end. */
1989 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1990 args
[0] = Vwindow_list
;
1991 args
[1] = Fnreverse (args
[1]);
1992 Vwindow_list
= Fnconc (2, args
);
1996 return Vwindow_list
;
2000 /* Value is non-zero if WINDOW satisfies the constraints given by
2001 OWINDOW, MINIBUF and ALL_FRAMES.
2003 MINIBUF t means WINDOW may be minibuffer windows.
2004 `lambda' means WINDOW may not be a minibuffer window.
2005 a window means a specific minibuffer window
2007 ALL_FRAMES t means search all frames,
2008 nil means search just current frame,
2009 `visible' means search just visible frames on the
2011 0 means search visible and iconified frames on the
2013 a window means search the frame that window belongs to,
2014 a frame means consider windows on that frame, only. */
2017 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2019 struct window
*w
= XWINDOW (window
);
2020 struct frame
*f
= XFRAME (w
->frame
);
2021 int candidate_p
= 1;
2023 if (!BUFFERP (w
->buffer
))
2025 else if (MINI_WINDOW_P (w
)
2026 && (EQ (minibuf
, Qlambda
)
2027 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2029 /* If MINIBUF is `lambda' don't consider any mini-windows.
2030 If it is a window, consider only that one. */
2033 else if (EQ (all_frames
, Qt
))
2035 else if (NILP (all_frames
))
2037 xassert (WINDOWP (owindow
));
2038 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2040 else if (EQ (all_frames
, Qvisible
))
2042 FRAME_SAMPLE_VISIBILITY (f
);
2043 candidate_p
= FRAME_VISIBLE_P (f
)
2044 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2045 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2048 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2050 FRAME_SAMPLE_VISIBILITY (f
);
2051 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2052 #ifdef HAVE_X_WINDOWS
2053 /* Yuck!! If we've just created the frame and the
2054 window-manager requested the user to place it
2055 manually, the window may still not be considered
2056 `visible'. I'd argue it should be at least
2057 something like `iconified', but don't know how to do
2059 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2060 && !f
->output_data
.x
->has_been_visible
)
2063 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2064 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2066 else if (WINDOWP (all_frames
))
2067 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2068 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2069 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2070 else if (FRAMEP (all_frames
))
2071 candidate_p
= EQ (all_frames
, w
->frame
);
2077 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2078 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2079 MINIBUF, and ALL_FRAMES. */
2082 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2085 *window
= selected_window
;
2087 CHECK_LIVE_WINDOW (*window
);
2089 /* MINIBUF nil may or may not include minibuffers. Decide if it
2091 if (NILP (*minibuf
))
2092 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2093 else if (!EQ (*minibuf
, Qt
))
2096 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2097 => count none of them, or a specific minibuffer window (the
2098 active one) to count. */
2100 /* ALL_FRAMES nil doesn't specify which frames to include. */
2101 if (NILP (*all_frames
))
2102 *all_frames
= (!EQ (*minibuf
, Qlambda
)
2103 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
2105 else if (EQ (*all_frames
, Qvisible
))
2107 else if (EQ (*all_frames
, make_number (0)))
2109 else if (FRAMEP (*all_frames
))
2111 else if (!EQ (*all_frames
, Qt
))
2116 /* Return the next or previous window of WINDOW in cyclic ordering
2117 of windows. NEXT_P non-zero means return the next window. See the
2118 documentation string of next-window for the meaning of MINIBUF and
2122 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2124 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2126 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2127 return the first window on the frame. */
2128 if (FRAMEP (all_frames
)
2129 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2130 return Fframe_first_window (all_frames
);
2136 /* Find WINDOW in the list of all windows. */
2137 list
= Fmemq (window
, window_list ());
2139 /* Scan forward from WINDOW to the end of the window list. */
2141 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2142 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2145 /* Scan from the start of the window list up to WINDOW. */
2147 for (list
= Vwindow_list
;
2148 CONSP (list
) && !EQ (XCAR (list
), window
);
2150 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2154 window
= XCAR (list
);
2158 Lisp_Object candidate
, list
;
2160 /* Scan through the list of windows for candidates. If there are
2161 candidate windows in front of WINDOW, the last one of these
2162 is the one we want. If there are candidates following WINDOW
2163 in the list, again the last one of these is the one we want. */
2165 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2167 if (EQ (XCAR (list
), window
))
2169 if (WINDOWP (candidate
))
2172 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2174 candidate
= XCAR (list
);
2177 if (WINDOWP (candidate
))
2185 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2186 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2187 WINDOW must be a live window and defaults to the selected one. The
2188 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2191 MINIBUF nil or omitted means consider the minibuffer window only if the
2192 minibuffer is active. MINIBUF t means consider the minibuffer window
2193 even if the minibuffer is not active. Any other value means do not
2194 consider the minibuffer window even if the minibuffer is active.
2196 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2197 plus the minibuffer window if specified by the MINIBUF argument. If the
2198 minibuffer counts, consider all windows on all frames that share that
2199 minibuffer too. The following non-nil values of ALL-FRAMES have special
2202 - t means consider all windows on all existing frames.
2204 - `visible' means consider all windows on all visible frames.
2206 - 0 (the number zero) means consider all windows on all visible and
2209 - A frame means consider all windows on that frame only.
2211 Anything else means consider all windows on WINDOW's frame and no
2214 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2215 `next-window' to iterate through the entire cycle of acceptable
2216 windows, eventually ending up back at the window you started with.
2217 `previous-window' traverses the same cycle, in the reverse order. */)
2218 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2220 return next_window (window
, minibuf
, all_frames
, 1);
2224 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2225 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2226 WINDOW must be a live window and defaults to the selected one. The
2227 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2230 MINIBUF nil or omitted means consider the minibuffer window only if the
2231 minibuffer is active. MINIBUF t means consider the minibuffer window
2232 even if the minibuffer is not active. Any other value means do not
2233 consider the minibuffer window even if the minibuffer is active.
2235 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2236 plus the minibuffer window if specified by the MINIBUF argument. If the
2237 minibuffer counts, consider all windows on all frames that share that
2238 minibuffer too. The following non-nil values of ALL-FRAMES have special
2241 - t means consider all windows on all existing frames.
2243 - `visible' means consider all windows on all visible frames.
2245 - 0 (the number zero) means consider all windows on all visible and
2248 - A frame means consider all windows on that frame only.
2250 Anything else means consider all windows on WINDOW's frame and no
2253 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2254 use `previous-window' to iterate through the entire cycle of
2255 acceptable windows, eventually ending up back at the window you
2256 started with. `next-window' traverses the same cycle, in the
2258 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2260 return next_window (window
, minibuf
, all_frames
, 0);
2264 /* Return a list of windows in cyclic ordering. Arguments are like
2265 for `next-window'. */
2268 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2270 Lisp_Object tail
, list
, rest
;
2272 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2275 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2276 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2277 list
= Fcons (XCAR (tail
), list
);
2279 /* Rotate the list to start with WINDOW. */
2280 list
= Fnreverse (list
);
2281 rest
= Fmemq (window
, list
);
2282 if (!NILP (rest
) && !EQ (rest
, list
))
2284 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2286 XSETCDR (tail
, Qnil
);
2287 list
= nconc2 (rest
, list
);
2293 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2294 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2295 FRAME nil or omitted means use the selected frame.
2296 WINDOW nil or omitted means use the window selected within FRAME.
2297 MINIBUF t means include the minibuffer window, even if it isn't active.
2298 MINIBUF nil or omitted means include the minibuffer window only
2300 MINIBUF neither nil nor t means never include the minibuffer window. */)
2301 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2304 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2305 CHECK_WINDOW (window
);
2307 frame
= selected_frame
;
2309 if (!EQ (frame
, XWINDOW (window
)->frame
))
2310 error ("Window is on a different frame");
2312 return window_list_1 (window
, minibuf
, frame
);
2316 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2317 doc
: /* Return a list of all live windows.
2318 WINDOW specifies the first window to list and defaults to the selected
2321 Optional argument MINIBUF nil or omitted means consider the minibuffer
2322 window only if the minibuffer is active. MINIBUF t means consider the
2323 minibuffer window even if the minibuffer is not active. Any other value
2324 means do not consider the minibuffer window even if the minibuffer is
2327 Optional argument ALL-FRAMES nil or omitted means consider all windows
2328 on WINDOW's frame, plus the minibuffer window if specified by the
2329 MINIBUF argument. If the minibuffer counts, consider all windows on all
2330 frames that share that minibuffer too. The following non-nil values of
2331 ALL-FRAMES have special meanings:
2333 - t means consider all windows on all existing frames.
2335 - `visible' means consider all windows on all visible frames.
2337 - 0 (the number zero) means consider all windows on all visible and
2340 - A frame means consider all windows on that frame only.
2342 Anything else means consider all windows on WINDOW's frame and no
2345 If WINDOW is not on the list of windows returned, some other window will
2346 be listed first but no error is signaled. */)
2347 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2349 return window_list_1 (window
, minibuf
, all_frames
);
2352 /* Look at all windows, performing an operation specified by TYPE
2354 If FRAMES is Qt, look at all frames;
2355 Qnil, look at just the selected frame;
2356 Qvisible, look at visible frames;
2357 a frame, just look at windows on that frame.
2358 If MINI is non-zero, perform the operation on minibuffer windows too. */
2363 GET_BUFFER_WINDOW
, /* Arg is buffer */
2364 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2365 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2370 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2372 Lisp_Object window
, windows
, best_window
, frame_arg
;
2373 int frame_best_window_flag
= 0;
2375 struct gcpro gcpro1
;
2377 /* If we're only looping through windows on a particular frame,
2378 frame points to that frame. If we're looping through windows
2379 on all frames, frame is 0. */
2380 if (FRAMEP (frames
))
2381 f
= XFRAME (frames
);
2382 else if (NILP (frames
))
2383 f
= SELECTED_FRAME ();
2388 frame_arg
= Qlambda
;
2389 else if (EQ (frames
, make_number (0)))
2391 else if (EQ (frames
, Qvisible
))
2396 /* frame_arg is Qlambda to stick to one frame,
2397 Qvisible to consider all visible frames,
2400 /* Pick a window to start with. */
2404 window
= FRAME_SELECTED_WINDOW (f
);
2406 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2408 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2412 for (; CONSP (windows
); windows
= XCDR (windows
))
2416 window
= XCAR (windows
);
2417 w
= XWINDOW (window
);
2419 /* Note that we do not pay attention here to whether the frame
2420 is visible, since Fwindow_list skips non-visible frames if
2421 that is desired, under the control of frame_arg. */
2422 if (!MINI_WINDOW_P (w
)
2423 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2424 consider all windows. */
2425 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2426 || (mini
&& minibuf_level
> 0))
2429 case GET_BUFFER_WINDOW
:
2430 if (EQ (w
->buffer
, obj
)
2431 /* Don't find any minibuffer window except the one that
2432 is currently in use. */
2433 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2435 if (EQ (window
, selected_window
))
2436 /* Preferably return the selected window. */
2437 RETURN_UNGCPRO (window
);
2438 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2439 && !frame_best_window_flag
)
2440 /* Prefer windows on the current frame (but don't
2441 choose another one if we have one already). */
2443 best_window
= window
;
2444 frame_best_window_flag
= 1;
2446 else if (NILP (best_window
))
2447 best_window
= window
;
2451 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2452 /* We could simply check whether the buffer shown by window
2453 is live, and show another buffer in case it isn't. */
2454 if (EQ (w
->buffer
, obj
))
2456 /* Undedicate WINDOW. */
2457 w
->dedicated
= Qnil
;
2458 /* Make WINDOW show the buffer returned by
2459 other_buffer_safely, don't run any hooks. */
2461 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2462 /* If WINDOW is the selected window, make its buffer
2463 current. But do so only if the window shows the
2464 current buffer (Bug#6454). */
2465 if (EQ (window
, selected_window
)
2466 && XBUFFER (w
->buffer
) == current_buffer
)
2467 Fset_buffer (w
->buffer
);
2471 case REDISPLAY_BUFFER_WINDOWS
:
2472 if (EQ (w
->buffer
, obj
))
2474 mark_window_display_accurate (window
, 0);
2475 w
->update_mode_line
= Qt
;
2476 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2477 ++update_mode_lines
;
2478 best_window
= window
;
2482 /* Check for a window that has a killed buffer. */
2483 case CHECK_ALL_WINDOWS
:
2484 if (! NILP (w
->buffer
)
2485 && NILP (BVAR (XBUFFER (w
->buffer
), name
)))
2489 case WINDOW_LOOP_UNUSED
:
2498 /* Used for debugging. Abort if any window has a dead buffer. */
2500 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2502 check_all_windows (void)
2504 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2507 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2508 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2509 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2512 The optional argument ALL-FRAMES specifies the frames to consider:
2514 - t means consider all windows on all existing frames.
2516 - `visible' means consider all windows on all visible frames.
2518 - 0 (the number zero) means consider all windows on all visible
2519 and iconified frames.
2521 - A frame means consider all windows on that frame only.
2523 Any other value of ALL-FRAMES means consider all windows on the
2524 selected frame and no others. */)
2525 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2529 if (NILP (buffer_or_name
))
2530 buffer
= Fcurrent_buffer ();
2532 buffer
= Fget_buffer (buffer_or_name
);
2534 if (BUFFERP (buffer
))
2535 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2541 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2543 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2547 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2548 Sdelete_other_windows_internal
, 0, 2, "",
2549 doc
: /* Make WINDOW fill its frame.
2550 Only the frame WINDOW is on is affected. WINDOW may be any window and
2551 defaults to the selected one.
2553 Optional argument ROOT, if non-nil, must specify an internal window such
2554 that WINDOW is in its window subtree. If this is the case, replace ROOT
2555 by WINDOW and leave alone any windows not part of ROOT's subtree.
2557 When WINDOW is live try to reduce display jumps by keeping the text
2558 previously visible in WINDOW in the same place on the frame. Doing this
2559 depends on the value of (window-start WINDOW), so if calling this
2560 function in a program gives strange scrolling, make sure the
2561 window-start value is reasonable when this function is called. */)
2562 (Lisp_Object window
, Lisp_Object root
)
2564 struct window
*w
, *r
, *s
;
2566 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2567 ptrdiff_t startpos
IF_LINT (= 0);
2568 int top
IF_LINT (= 0), new_top
, resize_failed
;
2569 Mouse_HLInfo
*hlinfo
;
2571 w
= decode_any_window (window
);
2572 XSETWINDOW (window
, w
);
2573 f
= XFRAME (w
->frame
);
2576 /* ROOT is the frame's root window. */
2578 root
= FRAME_ROOT_WINDOW (f
);
2582 /* ROOT must be an ancestor of WINDOW. */
2584 r
= decode_any_window (root
);
2585 pwindow
= XWINDOW (window
)->parent
;
2586 while (!NILP (pwindow
))
2587 if (EQ (pwindow
, root
))
2590 pwindow
= XWINDOW (pwindow
)->parent
;
2591 if (!EQ (pwindow
, root
))
2592 error ("Specified root is not an ancestor of specified window");
2595 if (EQ (window
, root
))
2598 /* I don't understand the "top > 0" part below. If we deal with a
2599 standalone minibuffer it would have been caught by the preceding
2601 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2602 error ("Can't expand minibuffer to full frame");
2604 if (!NILP (w
->buffer
))
2606 startpos
= marker_position (w
->start
);
2607 top
= WINDOW_TOP_EDGE_LINE (w
)
2608 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2609 /* Make sure WINDOW is the frame's selected window. */
2610 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2612 if (EQ (selected_frame
, w
->frame
))
2613 Fselect_window (window
, Qnil
);
2615 FRAME_SELECTED_WINDOW (f
) = window
;
2620 /* See if the frame's selected window is a part of the window
2621 subtree rooted at WINDOW, by finding all the selected window's
2622 parents and comparing each one with WINDOW. If it isn't we
2623 need a new selected window for this frame. */
2624 swindow
= FRAME_SELECTED_WINDOW (f
);
2628 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2629 pwindow
= XWINDOW (pwindow
)->parent
;
2631 if (EQ (window
, pwindow
))
2632 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2633 as the new selected window. */
2636 /* Else try the previous window of SWINDOW. */
2637 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2640 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2642 if (EQ (selected_frame
, w
->frame
))
2643 Fselect_window (swindow
, Qnil
);
2645 FRAME_SELECTED_WINDOW (f
) = swindow
;
2650 hlinfo
= MOUSE_HL_INFO (f
);
2651 /* We are going to free the glyph matrices of WINDOW, and with that
2652 we might lose any information about glyph rows that have some of
2653 their glyphs highlighted in mouse face. (These rows are marked
2654 with a non-zero mouse_face_p flag.) If WINDOW indeed has some
2655 glyphs highlighted in mouse face, signal to frame's up-to-date
2656 hook that mouse highlight was overwritten, so that it will
2657 arrange for redisplaying the highlight. */
2658 if (EQ (hlinfo
->mouse_face_window
, window
))
2660 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2661 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2662 hlinfo
->mouse_face_window
= Qnil
;
2664 free_window_matrices (r
);
2666 windows_or_buffers_changed
++;
2667 Vwindow_list
= Qnil
;
2668 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2671 if (NILP (w
->buffer
))
2673 /* Resize child windows vertically. */
2674 XSETINT (delta
, XINT (r
->total_lines
) - XINT (w
->total_lines
));
2675 w
->top_line
= r
->top_line
;
2676 resize_root_window (window
, delta
, Qnil
, Qnil
);
2677 if (window_resize_check (w
, 0))
2678 window_resize_apply (w
, 0);
2681 resize_root_window (window
, delta
, Qnil
, Qt
);
2682 if (window_resize_check (w
, 0))
2683 window_resize_apply (w
, 0);
2688 /* Resize child windows horizontally. */
2691 w
->left_col
= r
->left_col
;
2692 XSETINT (delta
, XINT (r
->total_cols
) - XINT (w
->total_cols
));
2693 w
->left_col
= r
->left_col
;
2694 resize_root_window (window
, delta
, Qt
, Qnil
);
2695 if (window_resize_check (w
, 1))
2696 window_resize_apply (w
, 1);
2699 resize_root_window (window
, delta
, Qt
, Qt
);
2700 if (window_resize_check (w
, 1))
2701 window_resize_apply (w
, 1);
2708 /* Play safe, if we still can ... */
2711 w
= XWINDOW (window
);
2715 /* Cleanly unlink WINDOW from window-tree. */
2716 if (!NILP (w
->prev
))
2717 /* Get SIBLING above (on the left of) WINDOW. */
2720 s
= XWINDOW (sibling
);
2722 if (!NILP (s
->next
))
2723 XWINDOW (s
->next
)->prev
= sibling
;
2726 /* Get SIBLING below (on the right of) WINDOW. */
2729 s
= XWINDOW (sibling
);
2731 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2732 XWINDOW (w
->parent
)->vchild
= sibling
;
2734 XWINDOW (w
->parent
)->hchild
= sibling
;
2737 /* Delete ROOT and all child windows of ROOT. */
2738 if (!NILP (r
->vchild
))
2740 delete_all_child_windows (r
->vchild
);
2743 else if (!NILP (r
->hchild
))
2745 delete_all_child_windows (r
->hchild
);
2749 replace_window (root
, window
, 1);
2751 /* This must become SWINDOW anyway ....... */
2752 if (!NILP (w
->buffer
) && !resize_failed
)
2754 /* Try to minimize scrolling, by setting the window start to the
2755 point will cause the text at the old window start to be at the
2756 same place on the frame. But don't try to do this if the
2757 window start is outside the visible portion (as might happen
2758 when the display is not current, due to typeahead). */
2759 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2761 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2762 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2764 struct position pos
;
2765 struct buffer
*obuf
= current_buffer
;
2767 Fset_buffer (w
->buffer
);
2768 /* This computation used to temporarily move point, but that
2769 can have unwanted side effects due to text properties. */
2770 pos
= *vmotion (startpos
, -top
, w
);
2772 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2773 w
->window_end_valid
= Qnil
;
2774 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2775 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2777 /* We need to do this, so that the window-scroll-functions
2779 w
->optional_new_start
= Qt
;
2781 set_buffer_internal (obuf
);
2788 run_window_configuration_change_hook (f
);
2795 replace_buffer_in_windows (Lisp_Object buffer
)
2797 call1 (Qreplace_buffer_in_windows
, buffer
);
2801 /* Safely replace BUFFER with some other buffer in all windows of all
2802 frames, even those on other keyboards. */
2805 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2807 Lisp_Object tail
, frame
;
2809 /* A single call to window_loop won't do the job because it only
2810 considers frames on the current keyboard. So loop manually over
2811 frames, and handle each one. */
2812 FOR_EACH_FRAME (tail
, frame
)
2813 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2816 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2817 minimum allowable size. */
2820 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2822 /* For height, we have to see:
2823 how many windows the frame has at minimum (one or two),
2824 and whether it has a menu bar or other special stuff at the top. */
2826 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2827 ? MIN_SAFE_WINDOW_HEIGHT
2828 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2830 if (FRAME_TOP_MARGIN (frame
) > 0)
2831 min_height
+= FRAME_TOP_MARGIN (frame
);
2833 if (*rows
< min_height
)
2835 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2836 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2839 /* Adjust the margins of window W if text area is too small.
2840 Return 1 if window width is ok after adjustment; 0 if window
2841 is still too narrow. */
2844 adjust_window_margins (struct window
*w
)
2846 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2847 - WINDOW_FRINGE_COLS (w
)
2848 - WINDOW_SCROLL_BAR_COLS (w
));
2849 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2850 + WINDOW_RIGHT_MARGIN_COLS (w
));
2852 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2855 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2858 /* Window's text area is too narrow, but reducing the window
2859 margins will fix that. */
2860 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2861 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2863 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2864 w
->left_margin_cols
= w
->right_margin_cols
2865 = make_number (margin_cols
/2);
2867 w
->right_margin_cols
= make_number (margin_cols
);
2870 w
->left_margin_cols
= make_number (margin_cols
);
2874 static Lisp_Object
Fset_window_margins (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2875 static Lisp_Object
Fset_window_fringes (Lisp_Object
, Lisp_Object
, Lisp_Object
,
2877 static Lisp_Object
Fset_window_scroll_bars (Lisp_Object
, Lisp_Object
,
2878 Lisp_Object
, Lisp_Object
);
2879 static Lisp_Object
Fset_window_vscroll (Lisp_Object
, Lisp_Object
, Lisp_Object
);
2881 /* The following three routines are needed for running a window's
2882 configuration change hook. */
2884 run_funs (Lisp_Object funs
)
2886 for (; CONSP (funs
); funs
= XCDR (funs
))
2887 if (!EQ (XCAR (funs
), Qt
))
2888 call0 (XCAR (funs
));
2892 select_window_norecord (Lisp_Object window
)
2894 return WINDOW_LIVE_P (window
)
2895 ? Fselect_window (window
, Qt
) : selected_window
;
2899 select_frame_norecord (Lisp_Object frame
)
2901 return FRAME_LIVE_P (XFRAME (frame
))
2902 ? Fselect_frame (frame
, Qt
) : selected_frame
;
2906 run_window_configuration_change_hook (struct frame
*f
)
2908 ptrdiff_t count
= SPECPDL_INDEX ();
2909 Lisp_Object frame
, global_wcch
2910 = Fdefault_value (Qwindow_configuration_change_hook
);
2911 XSETFRAME (frame
, f
);
2913 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
2916 /* Use the right buffer. Matters when running the local hooks. */
2917 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
2919 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2920 Fset_buffer (Fwindow_buffer (Qnil
));
2923 if (SELECTED_FRAME () != f
)
2925 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
2926 select_frame_norecord (frame
);
2929 /* Look for buffer-local values. */
2931 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
2932 for (; CONSP (windows
); windows
= XCDR (windows
))
2934 Lisp_Object window
= XCAR (windows
);
2935 Lisp_Object buffer
= Fwindow_buffer (window
);
2936 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
2939 ptrdiff_t inner_count
= SPECPDL_INDEX ();
2940 record_unwind_protect (select_window_norecord
, Fselected_window ());
2941 select_window_norecord (window
);
2942 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
2944 unbind_to (inner_count
, Qnil
);
2949 run_funs (global_wcch
);
2950 unbind_to (count
, Qnil
);
2953 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
2954 Srun_window_configuration_change_hook
, 1, 1, 0,
2955 doc
: /* Run `window-configuration-change-hook' for FRAME. */)
2958 CHECK_LIVE_FRAME (frame
);
2959 run_window_configuration_change_hook (XFRAME (frame
));
2963 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2964 means it's allowed to run hooks. See make_frame for a case where
2965 it's not allowed. KEEP_MARGINS_P non-zero means that the current
2966 margins, fringes, and scroll-bar settings of the window are not
2967 reset from the buffer's local settings. */
2970 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
2972 struct window
*w
= XWINDOW (window
);
2973 struct buffer
*b
= XBUFFER (buffer
);
2974 ptrdiff_t count
= SPECPDL_INDEX ();
2975 int samebuf
= EQ (buffer
, w
->buffer
);
2979 if (EQ (window
, selected_window
))
2980 BVAR (b
, last_selected_window
) = window
;
2982 /* Let redisplay errors through. */
2983 b
->display_error_modiff
= 0;
2985 /* Update time stamps of buffer display. */
2986 if (INTEGERP (BVAR (b
, display_count
)))
2987 XSETINT (BVAR (b
, display_count
), XINT (BVAR (b
, display_count
)) + 1);
2988 BVAR (b
, display_time
) = Fcurrent_time ();
2990 XSETFASTINT (w
->window_end_pos
, 0);
2991 XSETFASTINT (w
->window_end_vpos
, 0);
2992 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
2993 w
->window_end_valid
= Qnil
;
2994 if (!(keep_margins_p
&& samebuf
))
2995 { /* If we're not actually changing the buffer, don't reset hscroll and
2996 vscroll. This case happens for example when called from
2997 change_frame_size_1, where we use a dummy call to
2998 Fset_window_buffer on the frame's selected window (and no other)
2999 just in order to run window-configuration-change-hook.
3000 Resetting hscroll and vscroll here is problematic for things like
3001 image-mode and doc-view-mode since it resets the image's position
3002 whenever we resize the frame. */
3003 w
->hscroll
= w
->min_hscroll
= make_number (0);
3005 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3006 set_marker_restricted (w
->start
,
3007 make_number (b
->last_window_start
),
3009 w
->start_at_line_beg
= Qnil
;
3010 w
->force_start
= Qnil
;
3011 XSETFASTINT (w
->last_modified
, 0);
3012 XSETFASTINT (w
->last_overlay_modified
, 0);
3014 /* Maybe we could move this into the `if' but it's not obviously safe and
3015 I doubt it's worth the trouble. */
3016 windows_or_buffers_changed
++;
3018 /* We must select BUFFER for running the window-scroll-functions. */
3019 /* We can't check ! NILP (Vwindow_scroll_functions) here
3020 because that might itself be a local variable. */
3021 if (window_initialized
)
3023 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3024 Fset_buffer (buffer
);
3027 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3029 if (!keep_margins_p
)
3031 /* Set left and right marginal area width etc. from buffer. */
3033 /* This may call adjust_window_margins three times, so
3034 temporarily disable window margins. */
3035 Lisp_Object save_left
= w
->left_margin_cols
;
3036 Lisp_Object save_right
= w
->right_margin_cols
;
3038 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3040 Fset_window_fringes (window
,
3041 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3042 BVAR (b
, fringes_outside_margins
));
3044 Fset_window_scroll_bars (window
,
3045 BVAR (b
, scroll_bar_width
),
3046 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3048 w
->left_margin_cols
= save_left
;
3049 w
->right_margin_cols
= save_right
;
3051 Fset_window_margins (window
,
3052 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3057 if (! NILP (Vwindow_scroll_functions
))
3058 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3059 Fmarker_position (w
->start
));
3060 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3063 unbind_to (count
, Qnil
);
3066 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3067 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3068 WINDOW has to be a live window and defaults to the selected one.
3069 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3071 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3072 display margins, fringe widths, and scroll bar settings are preserved;
3073 the default is to reset these from the local settings for BUFFER-OR-NAME
3074 or the frame defaults. Return nil.
3076 This function throws an error when WINDOW is strongly dedicated to its
3077 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3078 already display BUFFER-OR-NAME.
3080 This function runs `window-scroll-functions' before running
3081 `window-configuration-change-hook'. */)
3082 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3084 register Lisp_Object tem
, buffer
;
3085 register struct window
*w
= decode_window (window
);
3087 XSETWINDOW (window
, w
);
3088 buffer
= Fget_buffer (buffer_or_name
);
3089 CHECK_BUFFER (buffer
);
3090 if (NILP (BVAR (XBUFFER (buffer
), name
)))
3091 error ("Attempt to display deleted buffer");
3095 error ("Window is deleted");
3096 else if (!EQ (tem
, Qt
))
3097 /* w->buffer is t when the window is first being set up. */
3099 if (!EQ (tem
, buffer
))
3101 if (EQ (w
->dedicated
, Qt
))
3102 /* WINDOW is strongly dedicated to its buffer, signal an
3104 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3106 /* WINDOW is weakly dedicated to its buffer, reset
3108 w
->dedicated
= Qnil
;
3110 call1 (Qrecord_window_buffer
, window
);
3116 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3122 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3124 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3127 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3129 doc
: /* Force all windows to be updated on next redisplay.
3130 If optional arg OBJECT is a window, force redisplay of that window only.
3131 If OBJECT is a buffer or buffer name, force redisplay of all windows
3132 displaying that buffer. */)
3133 (Lisp_Object object
)
3137 windows_or_buffers_changed
++;
3138 update_mode_lines
++;
3142 if (WINDOWP (object
))
3144 struct window
*w
= XWINDOW (object
);
3145 mark_window_display_accurate (object
, 0);
3146 w
->update_mode_line
= Qt
;
3147 if (BUFFERP (w
->buffer
))
3148 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3149 ++update_mode_lines
;
3153 if (STRINGP (object
))
3154 object
= Fget_buffer (object
);
3155 if (BUFFERP (object
) && !NILP (BVAR (XBUFFER (object
), name
)))
3157 /* Walk all windows looking for buffer, and force update
3158 of each of those windows. */
3160 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3161 return NILP (object
) ? Qnil
: Qt
;
3164 /* If nothing suitable was found, just return.
3165 We could signal an error, but this feature will typically be used
3166 asynchronously in timers or process sentinels, so we don't. */
3172 temp_output_buffer_show (register Lisp_Object buf
)
3174 register struct buffer
*old
= current_buffer
;
3175 register Lisp_Object window
;
3176 register struct window
*w
;
3178 BVAR (XBUFFER (buf
), directory
) = BVAR (current_buffer
, directory
);
3181 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3185 set_buffer_internal (old
);
3187 if (!NILP (Vtemp_buffer_show_function
))
3188 call1 (Vtemp_buffer_show_function
, buf
);
3191 window
= display_buffer (buf
, Qnil
, Qnil
);
3193 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3194 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3195 Vminibuf_scroll_window
= window
;
3196 w
= XWINDOW (window
);
3197 XSETFASTINT (w
->hscroll
, 0);
3198 XSETFASTINT (w
->min_hscroll
, 0);
3199 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3200 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3202 /* Run temp-buffer-show-hook, with the chosen window selected
3203 and its buffer current. */
3205 ptrdiff_t count
= SPECPDL_INDEX ();
3206 Lisp_Object prev_window
, prev_buffer
;
3207 prev_window
= selected_window
;
3208 XSETBUFFER (prev_buffer
, old
);
3210 /* Select the window that was chosen, for running the hook.
3211 Note: Both Fselect_window and select_window_norecord may
3212 set-buffer to the buffer displayed in the window,
3213 so we need to save the current buffer. --stef */
3214 record_unwind_protect (Fset_buffer
, prev_buffer
);
3215 record_unwind_protect (select_window_norecord
, prev_window
);
3216 Fselect_window (window
, Qt
);
3217 Fset_buffer (w
->buffer
);
3218 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3219 unbind_to (count
, Qnil
);
3224 DEFUN ("internal-temp-output-buffer-show",
3225 Ftemp_output_buffer_show
, Stemp_output_buffer_show
,
3227 doc
: /* Internal function for `with-output-to-temp-buffer'. */)
3230 temp_output_buffer_show (buf
);
3234 /* Make new window, have it replace WINDOW in window-tree, and make
3235 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3236 horizontal child). */
3238 make_parent_window (Lisp_Object window
, int horflag
)
3241 register struct window
*o
, *p
;
3244 o
= XWINDOW (window
);
3245 p
= allocate_window ();
3246 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3247 ((struct Lisp_Vector
*) p
)->contents
[i
]
3248 = ((struct Lisp_Vector
*) o
)->contents
[i
];
3249 XSETWINDOW (parent
, p
);
3252 XSETFASTINT (p
->sequence_number
, sequence_number
);
3254 replace_window (window
, parent
, 1);
3260 p
->hchild
= horflag
? window
: Qnil
;
3261 p
->vchild
= horflag
? Qnil
: window
;
3265 p
->combination_limit
= Qnil
;
3266 p
->window_parameters
= Qnil
;
3269 /* Make new window from scratch. */
3274 register struct window
*w
;
3276 w
= allocate_window ();
3277 /* Initialize all Lisp data. */
3278 w
->frame
= w
->mini_p
= Qnil
;
3279 w
->next
= w
->prev
= w
->hchild
= w
->vchild
= w
->parent
= Qnil
;
3280 XSETFASTINT (w
->left_col
, 0);
3281 XSETFASTINT (w
->top_line
, 0);
3282 XSETFASTINT (w
->total_lines
, 0);
3283 XSETFASTINT (w
->total_cols
, 0);
3284 w
->normal_lines
= make_float (1.0);
3285 w
->normal_cols
= make_float (1.0);
3286 XSETFASTINT (w
->new_total
, 0);
3287 XSETFASTINT (w
->new_normal
, 0);
3289 w
->start
= Fmake_marker ();
3290 w
->pointm
= Fmake_marker ();
3291 w
->force_start
= w
->optional_new_start
= Qnil
;
3292 XSETFASTINT (w
->hscroll
, 0);
3293 XSETFASTINT (w
->min_hscroll
, 0);
3294 XSETFASTINT (w
->use_time
, 0);
3296 XSETFASTINT (w
->sequence_number
, sequence_number
);
3297 w
->temslot
= w
->last_modified
= w
->last_overlay_modified
= Qnil
;
3298 XSETFASTINT (w
->last_point
, 0);
3299 w
->last_had_star
= w
->vertical_scroll_bar
= Qnil
;
3300 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3301 w
->left_fringe_width
= w
->right_fringe_width
= Qnil
;
3302 w
->fringes_outside_margins
= Qnil
;
3303 w
->scroll_bar_width
= Qnil
;
3304 w
->vertical_scroll_bar_type
= Qt
;
3305 w
->last_mark_x
= w
->last_mark_y
= Qnil
;
3306 XSETFASTINT (w
->window_end_pos
, 0);
3307 XSETFASTINT (w
->window_end_vpos
, 0);
3308 w
->window_end_valid
= w
->update_mode_line
= Qnil
;
3309 w
->start_at_line_beg
= w
->display_table
= w
->dedicated
= Qnil
;
3310 w
->base_line_number
= w
->base_line_pos
= w
->region_showing
= Qnil
;
3311 w
->column_number_displayed
= w
->redisplay_end_trigger
= Qnil
;
3312 w
->combination_limit
= w
->window_parameters
= Qnil
;
3313 w
->prev_buffers
= w
->next_buffers
= Qnil
;
3314 /* Initialize non-Lisp data. */
3315 w
->desired_matrix
= w
->current_matrix
= 0;
3316 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3317 memset (&w
->cursor
, 0, sizeof (w
->cursor
));
3318 memset (&w
->last_cursor
, 0, sizeof (w
->last_cursor
));
3319 memset (&w
->phys_cursor
, 0, sizeof (w
->phys_cursor
));
3320 w
->phys_cursor_type
= -1;
3321 w
->phys_cursor_width
= -1;
3322 w
->phys_cursor_on_p
= 0;
3323 w
->last_cursor_off_p
= w
->cursor_off_p
= 0;
3324 w
->must_be_updated_p
= 0;
3325 w
->pseudo_window_p
= 0;
3326 w
->frozen_window_start_p
= 0;
3328 /* Reset window_list. */
3329 Vwindow_list
= Qnil
;
3330 /* Return window. */
3331 XSETWINDOW (window
, w
);
3335 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3336 doc
: /* Set new total size of WINDOW to SIZE.
3339 Optional argument ADD non-nil means add SIZE to the new total size of
3340 WINDOW and return the sum.
3342 Note: This function does not operate on any child windows of WINDOW. */)
3343 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3345 struct window
*w
= decode_any_window (window
);
3347 CHECK_NUMBER (size
);
3349 XSETINT (w
->new_total
, XINT (size
));
3351 XSETINT (w
->new_total
, XINT (w
->new_total
) + XINT (size
));
3353 return w
->new_total
;
3356 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3357 doc
: /* Set new normal size of WINDOW to SIZE.
3360 Note: This function does not operate on any child windows of WINDOW. */)
3361 (Lisp_Object window
, Lisp_Object size
)
3363 struct window
*w
= decode_any_window (window
);
3365 w
->new_normal
= size
;
3366 return w
->new_normal
;
3369 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3370 non-zero) to w->new_total would result in correct heights (widths)
3371 for window W and recursively all child windows of W.
3373 Note: This function does not check any of `window-fixed-size-p',
3374 `window-min-height' or `window-min-width'. It does check that window
3375 sizes do not drop below one line (two columns). */
3377 window_resize_check (struct window
*w
, int horflag
)
3381 if (!NILP (w
->vchild
))
3382 /* W is a vertical combination. */
3384 c
= XWINDOW (w
->vchild
);
3386 /* All child windows of W must have the same width as W. */
3390 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3391 || !window_resize_check (c
, horflag
))
3393 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3398 /* The sum of the heights of the child windows of W must equal
3401 int sum_of_sizes
= 0;
3404 if (!window_resize_check (c
, horflag
))
3406 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3407 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3409 return (sum_of_sizes
== XINT (w
->new_total
));
3412 else if (!NILP (w
->hchild
))
3413 /* W is a horizontal combination. */
3415 c
= XWINDOW (w
->hchild
);
3417 /* The sum of the widths of the child windows of W must equal W's
3420 int sum_of_sizes
= 0;
3423 if (!window_resize_check (c
, horflag
))
3425 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3426 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3428 return (sum_of_sizes
== XINT (w
->new_total
));
3431 /* All child windows of W must have the same height as W. */
3435 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3436 || !window_resize_check (c
, horflag
))
3438 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3444 /* A leaf window. Make sure it's not too small. The following
3445 hardcodes the values of `window-safe-min-width' (2) and
3446 `window-safe-min-height' (1) which are defined in window.el. */
3447 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3450 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3451 w->new_total for window W and recursively all child windows of W.
3452 Also calculate and assign the new vertical (horizontal) start
3453 positions of each of these windows.
3455 This function does not perform any error checks. Make sure you have
3456 run window_resize_check on W before applying this function. */
3458 window_resize_apply (struct window
*w
, int horflag
)
3463 /* Note: Assigning new_normal requires that the new total size of the
3464 parent window has been set *before*. */
3467 w
->total_cols
= w
->new_total
;
3468 if (NUMBERP (w
->new_normal
))
3469 w
->normal_cols
= w
->new_normal
;
3471 pos
= XINT (w
->left_col
);
3475 w
->total_lines
= w
->new_total
;
3476 if (NUMBERP (w
->new_normal
))
3477 w
->normal_lines
= w
->new_normal
;
3479 pos
= XINT (w
->top_line
);
3482 if (!NILP (w
->vchild
))
3483 /* W is a vertical combination. */
3485 c
= XWINDOW (w
->vchild
);
3489 XSETFASTINT (c
->left_col
, pos
);
3491 XSETFASTINT (c
->top_line
, pos
);
3492 window_resize_apply (c
, horflag
);
3494 pos
= pos
+ XINT (c
->total_lines
);
3495 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3498 else if (!NILP (w
->hchild
))
3499 /* W is a horizontal combination. */
3501 c
= XWINDOW (w
->hchild
);
3505 XSETFASTINT (c
->left_col
, pos
);
3507 XSETFASTINT (c
->top_line
, pos
);
3508 window_resize_apply (c
, horflag
);
3510 pos
= pos
+ XINT (c
->total_cols
);
3511 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3515 /* Clear out some redisplay caches. */
3516 XSETFASTINT (w
->last_modified
, 0);
3517 XSETFASTINT (w
->last_overlay_modified
, 0);
3521 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 1, 2, 0,
3522 doc
: /* Apply requested size values for window-tree of FRAME.
3523 Optional argument HORIZONTAL omitted or nil means apply requested height
3524 values. HORIZONTAL non-nil means apply requested width values.
3526 This function checks whether the requested values sum up to a valid
3527 window layout, recursively assigns the new sizes of all child windows
3528 and calculates and assigns the new start positions of these windows.
3530 Note: This function does not check any of `window-fixed-size-p',
3531 `window-min-height' or `window-min-width'. All these checks have to
3532 be applied on the Elisp level. */)
3533 (Lisp_Object frame
, Lisp_Object horizontal
)
3537 int horflag
= !NILP (horizontal
);
3540 frame
= selected_frame
;
3541 CHECK_LIVE_FRAME (frame
);
3544 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3546 if (!window_resize_check (r
, horflag
)
3547 || ! EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3551 window_resize_apply (r
, horflag
);
3553 windows_or_buffers_changed
++;
3554 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3559 run_window_configuration_change_hook (f
);
3565 /* Resize frame F's windows when number of lines of F is set to SIZE.
3566 HORFLAG 1 means resize windows when number of columns of F is set to
3569 This function can delete all windows but the selected one in order to
3570 satisfy the request. The result will be meaningful if and only if
3571 F's windows have meaningful sizes when you call this. */
3573 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3575 Lisp_Object root
= f
->root_window
;
3576 struct window
*r
= XWINDOW (root
);
3577 Lisp_Object mini
= f
->minibuffer_window
;
3579 /* new_size is the new size of the frame's root window. */
3580 int new_size
= (horflag
3583 - FRAME_TOP_MARGIN (f
)
3584 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3587 XSETFASTINT (r
->top_line
, FRAME_TOP_MARGIN (f
));
3588 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3589 /* For a leaf root window just set the size. */
3591 XSETFASTINT (r
->total_cols
, new_size
);
3593 XSETFASTINT (r
->total_lines
, new_size
);
3596 /* old_size is the old size of the frame's root window. */
3597 int old_size
= XFASTINT (horflag
? r
->total_cols
: r
->total_lines
);
3600 XSETINT (delta
, new_size
- old_size
);
3601 /* Try a "normal" resize first. */
3602 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3603 if (window_resize_check (r
, horflag
) && new_size
== XINT (r
->new_total
))
3604 window_resize_apply (r
, horflag
);
3607 /* Try with "reasonable" minimum sizes next. */
3608 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3609 if (window_resize_check (r
, horflag
)
3610 && new_size
== XINT (r
->new_total
))
3611 window_resize_apply (r
, horflag
);
3614 /* Finally, try with "safe" minimum sizes. */
3615 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3616 if (window_resize_check (r
, horflag
)
3617 && new_size
== XINT (r
->new_total
))
3618 window_resize_apply (r
, horflag
);
3621 /* We lost. Delete all windows but the frame's
3623 root
= f
->selected_window
;
3624 Fdelete_other_windows_internal (root
, Qnil
);
3626 XSETFASTINT (XWINDOW (root
)->total_cols
, new_size
);
3628 XSETFASTINT (XWINDOW (root
)->total_lines
, new_size
);
3634 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3638 XSETFASTINT (m
->total_cols
, size
);
3641 /* Are we sure we always want 1 line here? */
3642 XSETFASTINT (m
->total_lines
, 1);
3643 XSETFASTINT (m
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
3649 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3650 doc
: /* Split window OLD.
3651 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3652 new window. In any case TOTAL-SIZE must be a positive integer.
3654 Third argument SIDE nil (or `below') specifies that the new window shall
3655 be located below WINDOW. SIDE `above' means the new window shall be
3656 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3657 lines of the new window including space reserved for the mode and/or
3660 SIDE t (or `right') specifies that the new window shall be located on
3661 the right side of WINDOW. SIDE `left' means the new window shall be
3662 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3663 number of columns of the new window including space reserved for fringes
3664 and the scrollbar or a divider column.
3666 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3667 according to the SIDE argument.
3669 The new total and normal sizes of all involved windows must have been
3670 set correctly. See the code of `split-window' for how this is done. */)
3671 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3673 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3674 parent window or an internal window we have to install as OLD's new
3675 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3676 provided OLD is a leaf window, or to the frame's selected window.
3677 NEW (*n) is the new window created with some parameters taken from
3679 register Lisp_Object
new, frame
, reference
;
3680 register struct window
*o
, *p
, *n
, *r
;
3683 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3684 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3685 int combination_limit
= 0;
3689 frame
= WINDOW_FRAME (o
);
3692 CHECK_NUMBER (total_size
);
3694 /* Set combination_limit to 1 if we have to make a new parent window.
3695 We do that if either `window-combination-limit' is t, or OLD has no
3696 parent, or OLD is ortho-combined. */
3698 !NILP (Vwindow_combination_limit
)
3701 ? (XWINDOW (o
->parent
)->hchild
)
3702 : (XWINDOW (o
->parent
)->vchild
));
3704 /* We need a live reference window to initialize some parameters. */
3705 if (WINDOW_LIVE_P (old
))
3706 /* OLD is live, use it as reference window. */
3709 /* Use the frame's selected window as reference window. */
3710 reference
= FRAME_SELECTED_WINDOW (f
);
3711 r
= XWINDOW (reference
);
3713 /* The following bugs are caught by `split-window'. */
3714 if (MINI_WINDOW_P (o
))
3715 error ("Attempt to split minibuffer window");
3716 else if (XINT (total_size
) < (horflag
? 2 : 1))
3717 error ("Size of new window too small (after split)");
3718 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3719 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3722 p
= XWINDOW (o
->parent
);
3723 /* Temporarily pretend we split the parent window. */
3724 XSETINT (p
->new_total
,
3725 XINT (horflag
? p
->total_cols
: p
->total_lines
)
3726 - XINT (total_size
));
3727 if (!window_resize_check (p
, horflag
))
3728 error ("Window sizes don't fit");
3730 /* Undo the temporary pretension. */
3731 p
->new_total
= horflag
? p
->total_cols
: p
->total_lines
;
3735 if (!window_resize_check (o
, horflag
))
3736 error ("Resizing old window failed");
3737 else if (XINT (total_size
) + XINT (o
->new_total
)
3738 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3739 error ("Sum of sizes of old and new window don't fit");
3742 /* This is our point of no return. */
3743 if (combination_limit
)
3745 /* Save the old value of o->normal_cols/lines. It gets corrupted
3746 by make_parent_window and we need it below for assigning it to
3748 Lisp_Object new_normal
= horflag
? o
->normal_cols
: o
->normal_lines
;
3750 make_parent_window (old
, horflag
);
3751 p
= XWINDOW (o
->parent
);
3752 /* Store value of `window-combination-limit' in new parent's
3753 combination_limit slot. */
3754 p
->combination_limit
= Vwindow_combination_limit
;
3755 /* These get applied below. */
3756 p
->new_total
= horflag
? o
->total_cols
: o
->total_lines
;
3757 p
->new_normal
= new_normal
;
3760 p
= XWINDOW (o
->parent
);
3762 windows_or_buffers_changed
++;
3763 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3764 new = make_window ();
3767 n
->parent
= o
->parent
;
3768 n
->vchild
= n
->hchild
= Qnil
;
3770 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3779 XWINDOW (n
->prev
)->next
= new;
3786 if (!NILP (n
->next
))
3787 XWINDOW (n
->next
)->prev
= new;
3793 n
->window_end_valid
= Qnil
;
3794 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3796 /* Get special geometry settings from reference window. */
3797 n
->left_margin_cols
= r
->left_margin_cols
;
3798 n
->right_margin_cols
= r
->right_margin_cols
;
3799 n
->left_fringe_width
= r
->left_fringe_width
;
3800 n
->right_fringe_width
= r
->right_fringe_width
;
3801 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3802 n
->scroll_bar_width
= r
->scroll_bar_width
;
3803 n
->vertical_scroll_bar_type
= r
->vertical_scroll_bar_type
;
3805 /* Directly assign orthogonal coordinates and sizes. */
3808 n
->top_line
= o
->top_line
;
3809 n
->total_lines
= o
->total_lines
;
3813 n
->left_col
= o
->left_col
;
3814 n
->total_cols
= o
->total_cols
;
3817 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3818 get them ready here. */
3819 n
->new_total
= total_size
;
3820 n
->new_normal
= normal_size
;
3823 window_resize_apply (p
, horflag
);
3825 /* Set buffer of NEW to buffer of reference window. Don't run
3827 set_window_buffer (new, r
->buffer
, 0, 1);
3830 /* Maybe we should run the scroll functions in Elisp (which already
3831 runs the configuration change hook). */
3832 if (! NILP (Vwindow_scroll_functions
))
3833 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3834 Fmarker_position (n
->start
));
3840 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3841 doc
: /* Remove WINDOW from its frame.
3842 WINDOW defaults to the selected window. Return nil.
3843 Signal an error when WINDOW is the only window on its frame. */)
3844 (register Lisp_Object window
)
3846 register Lisp_Object parent
, sibling
, frame
, root
;
3847 struct window
*w
, *p
, *s
, *r
;
3850 int before_sibling
= 0;
3852 w
= decode_any_window (window
);
3853 XSETWINDOW (window
, w
);
3854 if (NILP (w
->buffer
) && NILP (w
->hchild
) && NILP (w
->vchild
))
3855 /* It's a no-op to delete an already deleted window. */
3860 /* Never delete a minibuffer or frame root window. */
3861 error ("Attempt to delete minibuffer or sole ordinary window");
3862 else if (NILP (w
->prev
) && NILP (w
->next
))
3863 /* Rather bow out here, this case should be handled on the Elisp
3865 error ("Attempt to delete sole window of parent");
3867 p
= XWINDOW (parent
);
3868 horflag
= NILP (p
->vchild
);
3870 frame
= WINDOW_FRAME (w
);
3873 root
= FRAME_ROOT_WINDOW (f
);
3876 /* Unlink WINDOW from window tree. */
3878 /* Get SIBLING below (on the right of) WINDOW. */
3880 /* before_sibling 1 means WINDOW is the first child of its
3881 parent and thus before the sibling. */
3884 s
= XWINDOW (sibling
);
3887 p
->hchild
= sibling
;
3889 p
->vchild
= sibling
;
3892 /* Get SIBLING above (on the left of) WINDOW. */
3895 s
= XWINDOW (sibling
);
3897 if (!NILP (s
->next
))
3898 XWINDOW (s
->next
)->prev
= sibling
;
3901 if (window_resize_check (r
, horflag
)
3902 && EQ (r
->new_total
, (horflag
? r
->total_cols
: r
->total_lines
)))
3903 /* We can delete WINDOW now. */
3905 Mouse_HLInfo
*hlinfo
;
3909 window_resize_apply (p
, horflag
);
3911 /* If this window is referred to by the dpyinfo's mouse
3912 highlight, invalidate that slot to be safe (Bug#9904). */
3913 hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
3914 if (EQ (hlinfo
->mouse_face_window
, window
))
3915 hlinfo
->mouse_face_window
= Qnil
;
3917 windows_or_buffers_changed
++;
3918 Vwindow_list
= Qnil
;
3919 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3921 w
->next
= Qnil
; /* Don't delete w->next too. */
3922 free_window_matrices (w
);
3924 if (!NILP (w
->vchild
))
3926 delete_all_child_windows (w
->vchild
);
3929 else if (!NILP (w
->hchild
))
3931 delete_all_child_windows (w
->hchild
);
3934 else if (!NILP (w
->buffer
))
3937 unchain_marker (XMARKER (w
->pointm
));
3938 unchain_marker (XMARKER (w
->start
));
3942 if (NILP (s
->prev
) && NILP (s
->next
))
3943 /* A matrjoshka where SIBLING has become the only child of
3946 /* Put SIBLING into PARENT's place. */
3947 replace_window (parent
, sibling
, 0);
3948 /* Have SIBLING inherit the following three slot values from
3949 PARENT (the combination_limit slot is not inherited). */
3950 s
->normal_cols
= p
->normal_cols
;
3951 s
->normal_lines
= p
->normal_lines
;
3952 /* Mark PARENT as deleted. */
3953 p
->vchild
= p
->hchild
= Qnil
;
3954 /* Try to merge SIBLING into its new parent. */
3955 recombine_windows (sibling
);
3960 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
3961 /* We deleted the frame's selected window. */
3963 /* Use the frame's first window as fallback ... */
3964 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
3965 /* ... but preferably use its most recently used window. */
3966 Lisp_Object mru_window
;
3968 /* `get-mru-window' might fail for some reason so play it safe
3969 - promote the first window _without recording it_ first. */
3970 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
3971 Fselect_window (new_selected_window
, Qt
);
3973 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
3977 /* Now look whether `get-mru-window' gets us something. */
3978 mru_window
= call1 (Qget_mru_window
, frame
);
3979 if (WINDOW_LIVE_P (mru_window
)
3980 && EQ (XWINDOW (mru_window
)->frame
, frame
))
3981 new_selected_window
= mru_window
;
3983 /* If all ended up well, we now promote the mru window. */
3984 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
3985 Fselect_window (new_selected_window
, Qnil
);
3987 FRAME_SELECTED_WINDOW (f
) = new_selected_window
;
3992 /* Must be run by the caller:
3993 run_window_configuration_change_hook (f); */
3996 /* We failed: Relink WINDOW into window tree. */
4009 if (!NILP (w
->next
))
4010 XWINDOW (w
->next
)->prev
= window
;
4012 error ("Deletion failed");
4018 /***********************************************************************
4019 Resizing Mini-Windows
4020 ***********************************************************************/
4022 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4025 grow_mini_window (struct window
*w
, int delta
)
4027 struct frame
*f
= XFRAME (w
->frame
);
4029 Lisp_Object root
, value
;
4031 xassert (MINI_WINDOW_P (w
));
4032 xassert (delta
>= 0);
4034 root
= FRAME_ROOT_WINDOW (f
);
4036 value
= call2 (Qwindow_resize_root_window_vertically
,
4037 root
, make_number (- delta
));
4038 if (INTEGERP (value
) && window_resize_check (r
, 0))
4041 window_resize_apply (r
, 0);
4043 /* Grow the mini-window. */
4044 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4045 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - XINT (value
));
4046 XSETFASTINT (w
->last_modified
, 0);
4047 XSETFASTINT (w
->last_overlay_modified
, 0);
4055 /* Shrink mini-window W. */
4057 shrink_mini_window (struct window
*w
)
4059 struct frame
*f
= XFRAME (w
->frame
);
4061 Lisp_Object root
, value
;
4064 xassert (MINI_WINDOW_P (w
));
4066 size
= XINT (w
->total_lines
);
4069 root
= FRAME_ROOT_WINDOW (f
);
4071 value
= call2 (Qwindow_resize_root_window_vertically
,
4072 root
, make_number (size
- 1));
4073 if (INTEGERP (value
) && window_resize_check (r
, 0))
4076 window_resize_apply (r
, 0);
4078 /* Shrink the mini-window. */
4079 XSETFASTINT (w
->top_line
, XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
));
4080 XSETFASTINT (w
->total_lines
, 1);
4082 XSETFASTINT (w
->last_modified
, 0);
4083 XSETFASTINT (w
->last_overlay_modified
, 0);
4088 /* If the above failed for whatever strange reason we must make a
4089 one window frame here. The same routine will be needed when
4090 shrinking the frame (and probably when making the initial
4091 *scratch* window). For the moment leave things as they are. */
4095 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4096 doc
: /* Resize minibuffer window WINDOW. */)
4097 (Lisp_Object window
)
4099 struct window
*w
= XWINDOW (window
);
4104 CHECK_WINDOW (window
);
4105 f
= XFRAME (w
->frame
);
4107 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4108 error ("Not a valid minibuffer window");
4109 else if (FRAME_MINIBUF_ONLY_P (f
))
4110 error ("Cannot resize a minibuffer-only frame");
4112 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4113 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4114 if (window_resize_check (r
, 0)
4115 && XINT (w
->new_total
) > 0
4116 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4119 window_resize_apply (r
, 0);
4121 w
->total_lines
= w
->new_total
;
4122 XSETFASTINT (w
->top_line
, XINT (r
->top_line
) + XINT (r
->total_lines
));
4124 windows_or_buffers_changed
++;
4125 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4129 run_window_configuration_change_hook (f
);
4132 else error ("Failed to resize minibuffer window");
4135 /* Mark window cursors off for all windows in the window tree rooted
4136 at W by setting their phys_cursor_on_p flag to zero. Called from
4137 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4138 the frame are cleared. */
4141 mark_window_cursors_off (struct window
*w
)
4145 if (!NILP (w
->hchild
))
4146 mark_window_cursors_off (XWINDOW (w
->hchild
));
4147 else if (!NILP (w
->vchild
))
4148 mark_window_cursors_off (XWINDOW (w
->vchild
));
4150 w
->phys_cursor_on_p
= 0;
4152 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4157 /* Return number of lines of text (not counting mode lines) in W. */
4160 window_internal_height (struct window
*w
)
4162 int ht
= XFASTINT (w
->total_lines
);
4164 if (!MINI_WINDOW_P (w
))
4166 if (!NILP (w
->parent
)
4167 || !NILP (w
->vchild
)
4168 || !NILP (w
->hchild
)
4171 || WINDOW_WANTS_MODELINE_P (w
))
4174 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4181 /************************************************************************
4183 ***********************************************************************/
4185 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4186 N screen-fulls, which is defined as the height of the window minus
4187 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4188 instead. Negative values of N mean scroll down. NOERROR non-zero
4189 means don't signal an error if we try to move over BEGV or ZV,
4193 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4196 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4198 /* If we must, use the pixel-based version which is much slower than
4199 the line-based one but can handle varying line heights. */
4200 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4201 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4203 window_scroll_line_based (window
, n
, whole
, noerror
);
4209 /* Implementation of window_scroll that works based on pixel line
4210 heights. See the comment of window_scroll for parameter
4214 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4217 struct window
*w
= XWINDOW (window
);
4218 struct text_pos start
;
4219 int this_scroll_margin
;
4220 /* True if we fiddled the window vscroll field without really scrolling. */
4222 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4223 void *itdata
= NULL
;
4225 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4226 /* Scrolling a minibuffer window via scroll bar when the echo area
4227 shows long text sometimes resets the minibuffer contents behind
4229 if (CHARPOS (start
) > ZV
)
4230 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4232 /* If PT is not visible in WINDOW, move back one half of
4233 the screen. Allow PT to be partially visible, otherwise
4234 something like (scroll-down 1) with PT in the line before
4235 the partially visible one would recenter. */
4237 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4239 itdata
= bidi_shelve_cache ();
4240 /* Move backward half the height of the window. Performance note:
4241 vmotion used here is about 10% faster, but would give wrong
4242 results for variable height lines. */
4243 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4244 it
.current_y
= it
.last_visible_y
;
4245 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4247 /* The function move_iterator_vertically may move over more than
4248 the specified y-distance. If it->w is small, e.g. a
4249 mini-buffer window, we may end up in front of the window's
4250 display area. This is the case when Start displaying at the
4251 start of the line containing PT in this case. */
4252 if (it
.current_y
<= 0)
4254 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4255 move_it_vertically_backward (&it
, 0);
4259 start
= it
.current
.pos
;
4260 bidi_unshelve_cache (itdata
, 0);
4262 else if (auto_window_vscroll_p
)
4264 if (rtop
|| rbot
) /* partially visible */
4267 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4269 dy
= max ((window_box_height (w
)
4270 - next_screen_context_lines
* dy
),
4276 /* Only vscroll backwards if already vscrolled forwards. */
4277 if (w
->vscroll
< 0 && rtop
> 0)
4279 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4280 Fset_window_vscroll (window
, make_number (px
), Qt
);
4286 /* Do vscroll if already vscrolled or only display line. */
4287 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4289 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4290 Fset_window_vscroll (window
, make_number (px
), Qt
);
4294 /* Maybe modify window start instead of scrolling. */
4295 if (rbot
> 0 || w
->vscroll
< 0)
4299 Fset_window_vscroll (window
, make_number (0), Qt
);
4300 /* If there are other text lines above the current row,
4301 move window start to current row. Else to next row. */
4303 spos
= XINT (Fline_beginning_position (Qnil
));
4305 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4306 set_marker_restricted (w
->start
, make_number (spos
),
4308 w
->start_at_line_beg
= Qt
;
4309 w
->update_mode_line
= Qt
;
4310 XSETFASTINT (w
->last_modified
, 0);
4311 XSETFASTINT (w
->last_overlay_modified
, 0);
4312 /* Set force_start so that redisplay_window will run the
4313 window-scroll-functions. */
4314 w
->force_start
= Qt
;
4319 /* Cancel previous vscroll. */
4320 Fset_window_vscroll (window
, make_number (0), Qt
);
4323 itdata
= bidi_shelve_cache ();
4324 /* If scroll_preserve_screen_position is non-nil, we try to set
4325 point in the same window line as it is now, so get that line. */
4326 if (!NILP (Vscroll_preserve_screen_position
))
4328 /* We preserve the goal pixel coordinate across consecutive
4329 calls to scroll-up, scroll-down and other commands that
4330 have the `scroll-command' property. This avoids the
4331 possibility of point becoming "stuck" on a tall line when
4332 scrolling by one line. */
4333 if (window_scroll_pixel_based_preserve_y
< 0
4334 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4335 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4337 start_display (&it
, w
, start
);
4338 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4339 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4340 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4344 window_scroll_pixel_based_preserve_y
4345 = window_scroll_pixel_based_preserve_x
= -1;
4347 /* Move iterator it from start the specified distance forward or
4348 backward. The result is the new window start. */
4349 start_display (&it
, w
, start
);
4352 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4353 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4354 dy
= max ((window_box_height (w
)
4355 - next_screen_context_lines
* dy
),
4358 /* Note that move_it_vertically always moves the iterator to the
4359 start of a line. So, if the last line doesn't have a newline,
4360 we would end up at the start of the line ending at ZV. */
4363 move_it_vertically_backward (&it
, -dy
);
4364 /* Ensure we actually do move, e.g. in case we are currently
4365 looking at an image that is taller that the window height. */
4366 while (start_pos
== IT_CHARPOS (it
)
4367 && start_pos
> BEGV
)
4368 move_it_by_lines (&it
, -1);
4372 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4373 MOVE_TO_POS
| MOVE_TO_Y
);
4374 /* Ensure we actually do move, e.g. in case we are currently
4375 looking at an image that is taller that the window height. */
4376 while (start_pos
== IT_CHARPOS (it
)
4378 move_it_by_lines (&it
, 1);
4382 move_it_by_lines (&it
, n
);
4384 /* We failed if we find ZV is already on the screen (scrolling up,
4385 means there's nothing past the end), or if we can't start any
4386 earlier (scrolling down, means there's nothing past the top). */
4387 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4388 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4390 if (IT_CHARPOS (it
) == ZV
)
4392 if (it
.current_y
< it
.last_visible_y
4393 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4394 > it
.last_visible_y
))
4396 /* The last line was only partially visible, make it fully
4398 w
->vscroll
= (it
.last_visible_y
4399 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4400 adjust_glyphs (it
.f
);
4404 bidi_unshelve_cache (itdata
, 0);
4407 else if (n
< 0) /* could happen with empty buffers */
4408 xsignal0 (Qbeginning_of_buffer
);
4410 xsignal0 (Qend_of_buffer
);
4415 if (w
->vscroll
!= 0)
4416 /* The first line was only partially visible, make it fully
4421 bidi_unshelve_cache (itdata
, 0);
4425 xsignal0 (Qbeginning_of_buffer
);
4429 /* If control gets here, then we vscrolled. */
4431 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4433 /* Don't try to change the window start below. */
4439 ptrdiff_t pos
= IT_CHARPOS (it
);
4442 /* If in the middle of a multi-glyph character move forward to
4443 the next character. */
4444 if (in_display_vector_p (&it
))
4447 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4450 /* Set the window start, and set up the window for redisplay. */
4451 set_marker_restricted (w
->start
, make_number (pos
),
4453 bytepos
= XMARKER (w
->start
)->bytepos
;
4454 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4456 w
->update_mode_line
= Qt
;
4457 XSETFASTINT (w
->last_modified
, 0);
4458 XSETFASTINT (w
->last_overlay_modified
, 0);
4459 /* Set force_start so that redisplay_window will run the
4460 window-scroll-functions. */
4461 w
->force_start
= Qt
;
4464 /* The rest of this function uses current_y in a nonstandard way,
4465 not including the height of the header line if any. */
4466 it
.current_y
= it
.vpos
= 0;
4468 /* Move PT out of scroll margins.
4469 This code wants current_y to be zero at the window start position
4470 even if there is a header line. */
4471 this_scroll_margin
= max (0, scroll_margin
);
4472 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4473 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4477 /* We moved the window start towards ZV, so PT may be now
4478 in the scroll margin at the top. */
4479 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4480 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4481 && (NILP (Vscroll_preserve_screen_position
)
4482 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4483 /* We found PT at a legitimate height. Leave it alone. */
4485 else if (window_scroll_pixel_based_preserve_y
>= 0)
4487 /* If we have a header line, take account of it.
4488 This is necessary because we set it.current_y to 0, above. */
4489 move_it_to (&it
, -1,
4490 window_scroll_pixel_based_preserve_x
,
4491 window_scroll_pixel_based_preserve_y
4492 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4493 -1, MOVE_TO_Y
| MOVE_TO_X
);
4494 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4498 while (it
.current_y
< this_scroll_margin
)
4500 int prev
= it
.current_y
;
4501 move_it_by_lines (&it
, 1);
4502 if (prev
== it
.current_y
)
4505 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4510 ptrdiff_t charpos
, bytepos
;
4513 /* Save our position, for the
4514 window_scroll_pixel_based_preserve_y case. */
4515 charpos
= IT_CHARPOS (it
);
4516 bytepos
= IT_BYTEPOS (it
);
4518 /* We moved the window start towards BEGV, so PT may be now
4519 in the scroll margin at the bottom. */
4520 move_it_to (&it
, PT
, -1,
4521 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4522 - this_scroll_margin
- 1),
4524 MOVE_TO_POS
| MOVE_TO_Y
);
4526 /* Save our position, in case it's correct. */
4527 charpos
= IT_CHARPOS (it
);
4528 bytepos
= IT_BYTEPOS (it
);
4530 /* See if point is on a partially visible line at the end. */
4531 if (it
.what
== IT_EOB
)
4532 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4535 move_it_by_lines (&it
, 1);
4536 partial_p
= it
.current_y
> it
.last_visible_y
;
4539 if (charpos
== PT
&& !partial_p
4540 && (NILP (Vscroll_preserve_screen_position
)
4541 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4542 /* We found PT before we found the display margin, so PT is ok. */
4544 else if (window_scroll_pixel_based_preserve_y
>= 0)
4546 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4547 start_display (&it
, w
, start
);
4548 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4549 here because we called start_display again and did not
4550 alter it.current_y this time. */
4551 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4552 window_scroll_pixel_based_preserve_y
, -1,
4553 MOVE_TO_Y
| MOVE_TO_X
);
4554 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4559 /* The last line was only partially visible, so back up two
4560 lines to make sure we're on a fully visible line. */
4562 move_it_by_lines (&it
, -2);
4563 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4566 /* No, the position we saved is OK, so use it. */
4567 SET_PT_BOTH (charpos
, bytepos
);
4570 bidi_unshelve_cache (itdata
, 0);
4574 /* Implementation of window_scroll that works based on screen lines.
4575 See the comment of window_scroll for parameter descriptions. */
4578 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4580 register struct window
*w
= XWINDOW (window
);
4581 /* Fvertical_motion enters redisplay, which can trigger
4582 fontification, which in turn can modify buffer text (e.g., if the
4583 fontification functions replace escape sequences with faces, as
4584 in `grep-mode-font-lock-keywords'). So we use a marker to record
4585 the old point position, to prevent crashes in SET_PT_BOTH. */
4586 Lisp_Object opoint_marker
= Fpoint_marker ();
4587 register ptrdiff_t pos
, pos_byte
;
4588 register int ht
= window_internal_height (w
);
4589 register Lisp_Object tem
;
4593 Lisp_Object original_pos
= Qnil
;
4595 /* If scrolling screen-fulls, compute the number of lines to
4596 scroll from the window's height. */
4598 n
*= max (1, ht
- next_screen_context_lines
);
4600 startpos
= marker_position (w
->start
);
4602 if (!NILP (Vscroll_preserve_screen_position
))
4604 if (window_scroll_preserve_vpos
<= 0
4605 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4606 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4608 struct position posit
4609 = *compute_motion (startpos
, 0, 0, 0,
4611 -1, XINT (w
->hscroll
),
4613 window_scroll_preserve_vpos
= posit
.vpos
;
4614 window_scroll_preserve_hpos
= posit
.hpos
+ XINT (w
->hscroll
);
4617 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4618 make_number (window_scroll_preserve_vpos
));
4621 XSETFASTINT (tem
, PT
);
4622 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4626 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4631 lose
= n
< 0 && PT
== BEGV
;
4632 Fvertical_motion (make_number (n
), window
);
4636 SET_PT_BOTH (marker_position (opoint_marker
),
4637 marker_byte_position (opoint_marker
));
4644 xsignal0 (Qbeginning_of_buffer
);
4649 /* Don't use a scroll margin that is negative or too large. */
4650 int this_scroll_margin
=
4651 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4653 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4654 w
->start_at_line_beg
= bolp
;
4655 w
->update_mode_line
= Qt
;
4656 XSETFASTINT (w
->last_modified
, 0);
4657 XSETFASTINT (w
->last_overlay_modified
, 0);
4658 /* Set force_start so that redisplay_window will run
4659 the window-scroll-functions. */
4660 w
->force_start
= Qt
;
4662 if (!NILP (Vscroll_preserve_screen_position
)
4663 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4665 SET_PT_BOTH (pos
, pos_byte
);
4666 Fvertical_motion (original_pos
, window
);
4668 /* If we scrolled forward, put point enough lines down
4669 that it is outside the scroll margin. */
4674 if (this_scroll_margin
> 0)
4676 SET_PT_BOTH (pos
, pos_byte
);
4677 Fvertical_motion (make_number (this_scroll_margin
), window
);
4683 if (top_margin
<= marker_position (opoint_marker
))
4684 SET_PT_BOTH (marker_position (opoint_marker
),
4685 marker_byte_position (opoint_marker
));
4686 else if (!NILP (Vscroll_preserve_screen_position
))
4688 SET_PT_BOTH (pos
, pos_byte
);
4689 Fvertical_motion (original_pos
, window
);
4692 SET_PT (top_margin
);
4698 /* If we scrolled backward, put point near the end of the window
4699 but not within the scroll margin. */
4700 SET_PT_BOTH (pos
, pos_byte
);
4701 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4702 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4705 bottom_margin
= PT
+ 1;
4707 if (bottom_margin
> marker_position (opoint_marker
))
4708 SET_PT_BOTH (marker_position (opoint_marker
),
4709 marker_byte_position (opoint_marker
));
4712 if (!NILP (Vscroll_preserve_screen_position
))
4714 SET_PT_BOTH (pos
, pos_byte
);
4715 Fvertical_motion (original_pos
, window
);
4718 Fvertical_motion (make_number (-1), window
);
4727 xsignal0 (Qend_of_buffer
);
4732 /* Scroll selected_window up or down. If N is nil, scroll a
4733 screen-full which is defined as the height of the window minus
4734 next_screen_context_lines. If N is the symbol `-', scroll.
4735 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4736 up. This is the guts of Fscroll_up and Fscroll_down. */
4739 scroll_command (Lisp_Object n
, int direction
)
4741 ptrdiff_t count
= SPECPDL_INDEX ();
4743 xassert (eabs (direction
) == 1);
4745 /* If selected window's buffer isn't current, make it current for
4746 the moment. But don't screw up if window_scroll gets an error. */
4747 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4749 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4750 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4752 /* Make redisplay consider other windows than just selected_window. */
4753 ++windows_or_buffers_changed
;
4757 window_scroll (selected_window
, direction
, 1, 0);
4758 else if (EQ (n
, Qminus
))
4759 window_scroll (selected_window
, -direction
, 1, 0);
4762 n
= Fprefix_numeric_value (n
);
4763 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4766 unbind_to (count
, Qnil
);
4769 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4770 doc
: /* Scroll text of selected window upward ARG lines.
4771 If ARG is omitted or nil, scroll upward by a near full screen.
4772 A near full screen is `next-screen-context-lines' less than a full screen.
4773 Negative ARG means scroll downward.
4774 If ARG is the atom `-', scroll downward by nearly full screen.
4775 When calling from a program, supply as argument a number, nil, or `-'. */)
4778 scroll_command (arg
, 1);
4782 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4783 doc
: /* Scroll text of selected window down ARG lines.
4784 If ARG is omitted or nil, scroll down by a near full screen.
4785 A near full screen is `next-screen-context-lines' less than a full screen.
4786 Negative ARG means scroll upward.
4787 If ARG is the atom `-', scroll upward by nearly full screen.
4788 When calling from a program, supply as argument a number, nil, or `-'. */)
4791 scroll_command (arg
, -1);
4795 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4796 doc
: /* Return the other window for \"other window scroll\" commands.
4797 If `other-window-scroll-buffer' is non-nil, a window
4798 showing that buffer is used.
4799 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4800 specifies the window. This takes precedence over
4801 `other-window-scroll-buffer'. */)
4806 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4807 && !NILP (Vminibuf_scroll_window
))
4808 window
= Vminibuf_scroll_window
;
4809 /* If buffer is specified, scroll that buffer. */
4810 else if (!NILP (Vother_window_scroll_buffer
))
4812 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4814 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4818 /* Nothing specified; look for a neighboring window on the same
4820 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4822 if (EQ (window
, selected_window
))
4823 /* That didn't get us anywhere; look for a window on another
4826 window
= Fnext_window (window
, Qnil
, Qt
);
4827 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4828 && ! EQ (window
, selected_window
));
4831 CHECK_LIVE_WINDOW (window
);
4833 if (EQ (window
, selected_window
))
4834 error ("There is no other window");
4839 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4840 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4841 A near full screen is `next-screen-context-lines' less than a full screen.
4842 The next window is the one below the current one; or the one at the top
4843 if the current one is at the bottom. Negative ARG means scroll downward.
4844 If ARG is the atom `-', scroll downward by nearly full screen.
4845 When calling from a program, supply as argument a number, nil, or `-'.
4847 If `other-window-scroll-buffer' is non-nil, scroll the window
4848 showing that buffer, popping the buffer up if necessary.
4849 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4850 specifies the window to scroll. This takes precedence over
4851 `other-window-scroll-buffer'. */)
4856 ptrdiff_t count
= SPECPDL_INDEX ();
4858 window
= Fother_window_for_scrolling ();
4859 w
= XWINDOW (window
);
4861 /* Don't screw up if window_scroll gets an error. */
4862 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4863 ++windows_or_buffers_changed
;
4865 Fset_buffer (w
->buffer
);
4866 SET_PT (marker_position (w
->pointm
));
4869 window_scroll (window
, 1, 1, 1);
4870 else if (EQ (arg
, Qminus
))
4871 window_scroll (window
, -1, 1, 1);
4877 window_scroll (window
, XINT (arg
), 0, 1);
4880 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4881 unbind_to (count
, Qnil
);
4886 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
4887 doc
: /* Scroll selected window display ARG columns left.
4888 Default for ARG is window width minus 2.
4889 Value is the total amount of leftward horizontal scrolling in
4890 effect after the change.
4891 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4892 lower bound for automatic scrolling, i.e. automatic scrolling
4893 will not scroll a window to a column less than the value returned
4894 by this function. This happens in an interactive call. */)
4895 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4899 struct window
*w
= XWINDOW (selected_window
);
4902 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4904 arg
= Fprefix_numeric_value (arg
);
4906 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
4907 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4909 if (!NILP (set_minimum
))
4910 w
->min_hscroll
= w
->hscroll
;
4915 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
4916 doc
: /* Scroll selected window display ARG columns right.
4917 Default for ARG is window width minus 2.
4918 Value is the total amount of leftward horizontal scrolling in
4919 effect after the change.
4920 If SET-MINIMUM is non-nil, the new scroll amount becomes the
4921 lower bound for automatic scrolling, i.e. automatic scrolling
4922 will not scroll a window to a column less than the value returned
4923 by this function. This happens in an interactive call. */)
4924 (register Lisp_Object arg
, Lisp_Object set_minimum
)
4928 struct window
*w
= XWINDOW (selected_window
);
4931 XSETFASTINT (arg
, window_body_cols (w
) - 2);
4933 arg
= Fprefix_numeric_value (arg
);
4935 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
4936 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4938 if (!NILP (set_minimum
))
4939 w
->min_hscroll
= w
->hscroll
;
4944 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
4945 doc
: /* Return the window which was selected when entering the minibuffer.
4946 Returns nil, if selected window is not a minibuffer window. */)
4949 if (minibuf_level
> 0
4950 && MINI_WINDOW_P (XWINDOW (selected_window
))
4951 && WINDOW_LIVE_P (minibuf_selected_window
))
4952 return minibuf_selected_window
;
4957 /* Value is the number of lines actually displayed in window W,
4958 as opposed to its height. */
4961 displayed_window_lines (struct window
*w
)
4964 struct text_pos start
;
4965 int height
= window_box_height (w
);
4966 struct buffer
*old_buffer
;
4968 void *itdata
= NULL
;
4970 if (XBUFFER (w
->buffer
) != current_buffer
)
4972 old_buffer
= current_buffer
;
4973 set_buffer_internal (XBUFFER (w
->buffer
));
4978 /* In case W->start is out of the accessible range, do something
4979 reasonable. This happens in Info mode when Info-scroll-down
4980 calls (recenter -1) while W->start is 1. */
4981 if (XMARKER (w
->start
)->charpos
< BEGV
)
4982 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4983 else if (XMARKER (w
->start
)->charpos
> ZV
)
4984 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
4986 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4988 itdata
= bidi_shelve_cache ();
4989 start_display (&it
, w
, start
);
4990 move_it_vertically (&it
, height
);
4991 bottom_y
= line_bottom_y (&it
);
4992 bidi_unshelve_cache (itdata
, 0);
4994 /* rms: On a non-window display,
4995 the value of it.vpos at the bottom of the screen
4996 seems to be 1 larger than window_box_height (w).
4997 This kludge fixes a bug whereby (move-to-window-line -1)
4998 when ZV is on the last screen line
4999 moves to the previous screen line instead of the last one. */
5000 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5003 /* Add in empty lines at the bottom of the window. */
5004 if (bottom_y
< height
)
5006 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5007 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5011 set_buffer_internal (old_buffer
);
5017 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5018 doc
: /* Center point in selected window and maybe redisplay frame.
5019 With prefix argument ARG, recenter putting point on screen line ARG
5020 relative to the selected window. If ARG is negative, it counts up from the
5021 bottom of the window. (ARG should be less than the height of the window.)
5023 If ARG is omitted or nil, then recenter with point on the middle line of
5024 the selected window; if the variable `recenter-redisplay' is non-nil,
5025 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5026 is set to `grow-only', this resets the tool-bar's height to the minimum
5027 height needed); if `recenter-redisplay' has the special value `tty',
5028 then only tty frames are redrawn.
5030 Just C-u as prefix means put point in the center of the window
5031 and redisplay normally--don't erase and redraw the frame. */)
5032 (register Lisp_Object arg
)
5034 struct window
*w
= XWINDOW (selected_window
);
5035 struct buffer
*buf
= XBUFFER (w
->buffer
);
5036 struct buffer
*obuf
= current_buffer
;
5038 ptrdiff_t charpos
, bytepos
;
5039 EMACS_INT iarg
IF_LINT (= 0);
5040 int this_scroll_margin
;
5042 /* If redisplay is suppressed due to an error, try again. */
5043 obuf
->display_error_modiff
= 0;
5047 if (!NILP (Vrecenter_redisplay
)
5048 && (!EQ (Vrecenter_redisplay
, Qtty
)
5049 || !NILP (Ftty_type (selected_frame
))))
5053 /* Invalidate pixel data calculated for all compositions. */
5054 for (i
= 0; i
< n_compositions
; i
++)
5055 composition_table
[i
]->font
= NULL
;
5057 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5059 Fredraw_frame (WINDOW_FRAME (w
));
5060 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5065 else if (CONSP (arg
)) /* Just C-u. */
5069 arg
= Fprefix_numeric_value (arg
);
5074 set_buffer_internal (buf
);
5076 /* Do this after making BUF current
5077 in case scroll_margin is buffer-local. */
5078 this_scroll_margin
=
5079 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5081 /* Handle centering on a graphical frame specially. Such frames can
5082 have variable-height lines and centering point on the basis of
5083 line counts would lead to strange effects. */
5084 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5090 void *itdata
= bidi_shelve_cache ();
5092 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5093 start_display (&it
, w
, pt
);
5094 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5095 charpos
= IT_CHARPOS (it
);
5096 bytepos
= IT_BYTEPOS (it
);
5097 bidi_unshelve_cache (itdata
, 0);
5103 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5104 int extra_line_spacing
;
5105 int h
= window_box_height (w
);
5106 void *itdata
= bidi_shelve_cache ();
5108 iarg
= - max (-iarg
, this_scroll_margin
);
5110 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5111 start_display (&it
, w
, pt
);
5113 /* Be sure we have the exact height of the full line containing PT. */
5114 move_it_by_lines (&it
, 0);
5116 /* The amount of pixels we have to move back is the window
5117 height minus what's displayed in the line containing PT,
5118 and the lines below. */
5121 move_it_by_lines (&it
, nlines
);
5123 if (it
.vpos
== nlines
)
5127 /* Last line has no newline */
5128 h
-= line_bottom_y (&it
);
5132 /* Don't reserve space for extra line spacing of last line. */
5133 extra_line_spacing
= it
.max_extra_line_spacing
;
5135 /* If we can't move down NLINES lines because we hit
5136 the end of the buffer, count in some empty lines. */
5137 if (it
.vpos
< nlines
)
5140 extra_line_spacing
= it
.extra_line_spacing
;
5141 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5145 bidi_unshelve_cache (itdata
, 0);
5149 /* Now find the new top line (starting position) of the window. */
5150 start_display (&it
, w
, pt
);
5152 move_it_vertically_backward (&it
, h
);
5154 /* If extra line spacing is present, we may move too far
5155 back. This causes the last line to be only partially
5156 visible (which triggers redisplay to recenter that line
5157 in the middle), so move forward.
5158 But ignore extra line spacing on last line, as it is not
5159 considered to be part of the visible height of the line.
5161 h
+= extra_line_spacing
;
5162 while (-it
.current_y
> h
)
5163 move_it_by_lines (&it
, 1);
5165 charpos
= IT_CHARPOS (it
);
5166 bytepos
= IT_BYTEPOS (it
);
5168 bidi_unshelve_cache (itdata
, 0);
5172 struct position pos
;
5174 iarg
= max (iarg
, this_scroll_margin
);
5176 pos
= *vmotion (PT
, -iarg
, w
);
5177 charpos
= pos
.bufpos
;
5178 bytepos
= pos
.bytepos
;
5183 struct position pos
;
5184 int ht
= window_internal_height (w
);
5191 /* Don't let it get into the margin at either top or bottom. */
5192 iarg
= max (iarg
, this_scroll_margin
);
5193 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5195 pos
= *vmotion (PT
, - iarg
, w
);
5196 charpos
= pos
.bufpos
;
5197 bytepos
= pos
.bytepos
;
5200 /* Set the new window start. */
5201 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5202 w
->window_end_valid
= Qnil
;
5204 w
->optional_new_start
= Qt
;
5206 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5207 w
->start_at_line_beg
= Qt
;
5209 w
->start_at_line_beg
= Qnil
;
5211 set_buffer_internal (obuf
);
5215 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5217 doc
: /* Return the height in lines of the text display area of WINDOW.
5218 If WINDOW is omitted or nil, it defaults to the selected window.
5220 The returned height does not include the mode line, any header line,
5221 nor any partial-height lines at the bottom of the text area. */)
5222 (Lisp_Object window
)
5224 struct window
*w
= decode_window (window
);
5225 int pixel_height
= window_box_height (w
);
5226 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5227 return make_number (line_height
);
5232 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5234 doc
: /* Position point relative to window.
5235 ARG nil means position point at center of window.
5236 Else, ARG specifies vertical position within the window;
5237 zero means top of window, negative means relative to bottom of window. */)
5240 struct window
*w
= XWINDOW (selected_window
);
5244 int this_scroll_margin
;
5247 if (!(BUFFERP (w
->buffer
)
5248 && XBUFFER (w
->buffer
) == current_buffer
))
5249 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5250 when passed below to set_marker_both. */
5251 error ("move-to-window-line called from unrelated buffer");
5253 window
= selected_window
;
5254 start
= marker_position (w
->start
);
5255 if (start
< BEGV
|| start
> ZV
)
5257 int height
= window_internal_height (w
);
5258 Fvertical_motion (make_number (- (height
/ 2)), window
);
5259 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5260 w
->start_at_line_beg
= Fbolp ();
5261 w
->force_start
= Qt
;
5264 Fgoto_char (w
->start
);
5266 lines
= displayed_window_lines (w
);
5269 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5273 XSETFASTINT (arg
, lines
/ 2);
5276 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5279 iarg
= iarg
+ lines
;
5281 #if 0 /* This code would prevent move-to-window-line from moving point
5282 to a place inside the scroll margins (which would cause the
5283 next redisplay to scroll). I wrote this code, but then concluded
5284 it is probably better not to install it. However, it is here
5285 inside #if 0 so as not to lose it. -- rms. */
5287 /* Don't let it get into the margin at either top or bottom. */
5288 iarg
= max (iarg
, this_scroll_margin
);
5289 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5292 arg
= make_number (iarg
);
5295 /* Skip past a partially visible first line. */
5297 XSETINT (arg
, XINT (arg
) + 1);
5299 return Fvertical_motion (arg
, window
);
5304 /***********************************************************************
5305 Window Configuration
5306 ***********************************************************************/
5308 struct save_window_data
5310 struct vectorlike_header header
;
5311 Lisp_Object selected_frame
;
5312 Lisp_Object current_window
;
5313 Lisp_Object current_buffer
;
5314 Lisp_Object minibuf_scroll_window
;
5315 Lisp_Object minibuf_selected_window
;
5316 Lisp_Object root_window
;
5317 Lisp_Object focus_frame
;
5318 /* A vector, each of whose elements is a struct saved_window
5320 Lisp_Object saved_windows
;
5322 /* All fields above are traced by the GC.
5323 From `fame-cols' down, the fields are ignored by the GC. */
5325 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5326 int frame_tool_bar_lines
;
5329 /* This is saved as a Lisp_Vector */
5332 struct vectorlike_header header
;
5334 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5335 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5336 Lisp_Object normal_cols
, normal_lines
;
5337 Lisp_Object hscroll
, min_hscroll
;
5338 Lisp_Object parent
, prev
;
5339 Lisp_Object start_at_line_beg
;
5340 Lisp_Object display_table
;
5341 Lisp_Object left_margin_cols
, right_margin_cols
;
5342 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5343 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5344 Lisp_Object combination_limit
, window_parameters
;
5347 #define SAVED_WINDOW_N(swv,n) \
5348 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5350 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5351 doc
: /* Return t if OBJECT is a window-configuration object. */)
5352 (Lisp_Object object
)
5354 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5357 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5358 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5359 (Lisp_Object config
)
5361 register struct save_window_data
*data
;
5362 struct Lisp_Vector
*saved_windows
;
5364 CHECK_WINDOW_CONFIGURATION (config
);
5366 data
= (struct save_window_data
*) XVECTOR (config
);
5367 saved_windows
= XVECTOR (data
->saved_windows
);
5368 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5371 DEFUN ("set-window-configuration", Fset_window_configuration
,
5372 Sset_window_configuration
, 1, 1, 0,
5373 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5374 CONFIGURATION must be a value previously returned
5375 by `current-window-configuration' (which see).
5376 If CONFIGURATION was made from a frame that is now deleted,
5377 only frame-independent values can be restored. In this case,
5378 the return value is nil. Otherwise the value is t. */)
5379 (Lisp_Object configuration
)
5381 register struct save_window_data
*data
;
5382 struct Lisp_Vector
*saved_windows
;
5383 Lisp_Object new_current_buffer
;
5385 Lisp_Object auto_buffer_name
;
5387 ptrdiff_t old_point
= -1;
5389 CHECK_WINDOW_CONFIGURATION (configuration
);
5391 data
= (struct save_window_data
*) XVECTOR (configuration
);
5392 saved_windows
= XVECTOR (data
->saved_windows
);
5394 new_current_buffer
= data
->current_buffer
;
5395 if (NILP (BVAR (XBUFFER (new_current_buffer
), name
)))
5396 new_current_buffer
= Qnil
;
5399 if (XBUFFER (new_current_buffer
) == current_buffer
)
5400 /* The code further down "preserves point" by saving here PT in
5401 old_point and then setting it later back into PT. When the
5402 current-selected-window and the final-selected-window both show
5403 the current buffer, this suffers from the problem that the
5404 current PT is the window-point of the current-selected-window,
5405 while the final PT is the point of the final-selected-window, so
5406 this copy from one PT to the other would end up moving the
5407 window-point of the final-selected-window to the window-point of
5408 the current-selected-window. So we have to be careful which
5409 point of the current-buffer we copy into old_point. */
5410 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5411 && WINDOWP (selected_window
)
5412 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5413 && !EQ (selected_window
, data
->current_window
))
5414 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5418 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5419 point in new_current_buffer as of the last time this buffer was
5420 used. This can be non-deterministic since it can be changed by
5421 things like jit-lock by mere temporary selection of some random
5422 window that happens to show this buffer.
5423 So if possible we want this arbitrary choice of "which point" to
5424 be the one from the to-be-selected-window so as to prevent this
5425 window's cursor from being copied from another window. */
5426 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5427 /* If current_window = selected_window, its point is in BUF_PT. */
5428 && !EQ (selected_window
, data
->current_window
))
5429 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5431 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5434 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5437 /* If f is a dead frame, don't bother rebuilding its window tree.
5438 However, there is other stuff we should still try to do below. */
5439 if (FRAME_LIVE_P (f
))
5442 Lisp_Object dead_windows
= Qnil
;
5443 register Lisp_Object tem
, par
, pers
;
5444 register struct window
*w
;
5445 register struct saved_window
*p
;
5446 struct window
*root_window
;
5447 struct window
**leaf_windows
;
5452 /* If the frame has been resized since this window configuration was
5453 made, we change the frame to the size specified in the
5454 configuration, restore the configuration, and then resize it
5455 back. We keep track of the prevailing height in these variables. */
5456 int previous_frame_lines
= FRAME_LINES (f
);
5457 int previous_frame_cols
= FRAME_COLS (f
);
5458 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5459 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5461 /* The mouse highlighting code could get screwed up
5462 if it runs during this. */
5465 if (data
->frame_lines
!= previous_frame_lines
5466 || data
->frame_cols
!= previous_frame_cols
)
5467 change_frame_size (f
, data
->frame_lines
,
5468 data
->frame_cols
, 0, 0, 0);
5469 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5470 if (data
->frame_menu_bar_lines
5471 != previous_frame_menu_bar_lines
)
5472 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5474 #ifdef HAVE_WINDOW_SYSTEM
5475 if (data
->frame_tool_bar_lines
5476 != previous_frame_tool_bar_lines
)
5477 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5482 /* "Swap out" point from the selected window's buffer
5483 into the window itself. (Normally the pointm of the selected
5484 window holds garbage.) We do this now, before
5485 restoring the window contents, and prevent it from
5486 being done later on when we select a new window. */
5487 if (! NILP (XWINDOW (selected_window
)->buffer
))
5489 w
= XWINDOW (selected_window
);
5490 set_marker_both (w
->pointm
,
5492 BUF_PT (XBUFFER (w
->buffer
)),
5493 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5496 windows_or_buffers_changed
++;
5497 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5499 /* Problem: Freeing all matrices and later allocating them again
5500 is a serious redisplay flickering problem. What we would
5501 really like to do is to free only those matrices not reused
5503 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5505 = (struct window
**) alloca (count_windows (root_window
)
5506 * sizeof (struct window
*));
5507 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5510 Mark all windows now on frame as "deleted".
5511 Restoring the new configuration "undeletes" any that are in it.
5513 Save their current buffers in their height fields, since we may
5514 need it later, if a buffer saved in the configuration is now
5516 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5518 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5520 p
= SAVED_WINDOW_N (saved_windows
, k
);
5522 w
= XWINDOW (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 /* If we squirreled away the buffer in the window's height,
5557 if (BUFFERP (w
->total_lines
))
5558 w
->buffer
= w
->total_lines
;
5559 w
->left_col
= p
->left_col
;
5560 w
->top_line
= p
->top_line
;
5561 w
->total_cols
= p
->total_cols
;
5562 w
->total_lines
= p
->total_lines
;
5563 w
->normal_cols
= p
->normal_cols
;
5564 w
->normal_lines
= p
->normal_lines
;
5565 w
->hscroll
= p
->hscroll
;
5566 w
->min_hscroll
= p
->min_hscroll
;
5567 w
->display_table
= p
->display_table
;
5568 w
->left_margin_cols
= p
->left_margin_cols
;
5569 w
->right_margin_cols
= p
->right_margin_cols
;
5570 w
->left_fringe_width
= p
->left_fringe_width
;
5571 w
->right_fringe_width
= p
->right_fringe_width
;
5572 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5573 w
->scroll_bar_width
= p
->scroll_bar_width
;
5574 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5575 w
->dedicated
= p
->dedicated
;
5576 w
->combination_limit
= p
->combination_limit
;
5577 /* Restore any window parameters that have been saved.
5578 Parameters that have not been saved are left alone. */
5579 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5584 if (NILP (XCDR (pers
)))
5586 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5587 if (CONSP (par
) && !NILP (XCDR (par
)))
5588 /* Reset a parameter to nil if and only if it
5589 has a non-nil association. Don't make new
5591 Fsetcdr (par
, Qnil
);
5594 /* Always restore a non-nil value. */
5595 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5599 XSETFASTINT (w
->last_modified
, 0);
5600 XSETFASTINT (w
->last_overlay_modified
, 0);
5602 /* Reinstall the saved buffer and pointers into it. */
5603 if (NILP (p
->buffer
))
5604 /* An internal window. */
5605 w
->buffer
= p
->buffer
;
5606 else if (!NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5607 /* If saved buffer is alive, install it. */
5609 w
->buffer
= p
->buffer
;
5610 w
->start_at_line_beg
= p
->start_at_line_beg
;
5611 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5612 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5613 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5614 p
->mark
, w
->buffer
);
5616 /* As documented in Fcurrent_window_configuration, don't
5617 restore the location of point in the buffer which was
5618 current when the window configuration was recorded. */
5619 if (!EQ (p
->buffer
, new_current_buffer
)
5620 && XBUFFER (p
->buffer
) == current_buffer
)
5621 Fgoto_char (w
->pointm
);
5623 else if (!NILP (w
->buffer
) && !NILP (BVAR (XBUFFER (w
->buffer
), name
)))
5624 /* Keep window's old buffer; make sure the markers are
5627 /* Set window markers at start of visible range. */
5628 if (XMARKER (w
->start
)->buffer
== 0)
5629 set_marker_restricted (w
->start
, make_number (0),
5631 if (XMARKER (w
->pointm
)->buffer
== 0)
5632 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5633 BUF_PT (XBUFFER (w
->buffer
)),
5634 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5635 w
->start_at_line_beg
= Qt
;
5637 else if (STRINGP (auto_buffer_name
=
5638 Fwindow_parameter (window
, Qauto_buffer_name
))
5639 && SCHARS (auto_buffer_name
) != 0
5640 && !NILP (w
->buffer
= Fget_buffer_create (auto_buffer_name
)))
5642 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5643 set_marker_restricted (w
->pointm
, make_number (0), w
->buffer
);
5644 w
->start_at_line_beg
= Qt
;
5647 /* Window has no live buffer, get one. */
5649 /* Get the buffer via other_buffer_safely in order to
5650 avoid showing an unimportant buffer and, if necessary, to
5651 recreate *scratch* in the course (part of Juanma's bs-show
5652 scenario from March 2011). */
5653 w
->buffer
= other_buffer_safely (Fcurrent_buffer ());
5654 /* This will set the markers to beginning of visible
5656 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5657 set_marker_restricted (w
->pointm
, make_number (0), w
->buffer
);
5658 w
->start_at_line_beg
= Qt
;
5659 if (!NILP (w
->dedicated
))
5660 /* Record this window as dead. */
5661 dead_windows
= Fcons (window
, dead_windows
);
5662 /* Make sure window is no more dedicated. */
5663 w
->dedicated
= Qnil
;
5667 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5668 /* Arrange *not* to restore point in the buffer that was
5669 current when the window configuration was saved. */
5670 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5671 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5672 make_number (old_point
),
5673 XWINDOW (data
->current_window
)->buffer
);
5675 /* In the following call to `select-window', prevent "swapping out
5676 point" in the old selected window using the buffer that has
5677 been restored into it. We already swapped out that point from
5678 that window's old buffer. */
5679 select_window (data
->current_window
, Qnil
, 1);
5680 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5683 if (NILP (data
->focus_frame
)
5684 || (FRAMEP (data
->focus_frame
)
5685 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5686 Fredirect_frame_focus (frame
, data
->focus_frame
);
5688 /* Set the screen height to the value it had before this function. */
5689 if (previous_frame_lines
!= FRAME_LINES (f
)
5690 || previous_frame_cols
!= FRAME_COLS (f
))
5691 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5693 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5694 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5695 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5697 #ifdef HAVE_WINDOW_SYSTEM
5698 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5699 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5704 /* Now, free glyph matrices in windows that were not reused. */
5705 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5707 if (NILP (leaf_windows
[i
]->buffer
))
5709 /* Assert it's not reused as a combination. */
5710 xassert (NILP (leaf_windows
[i
]->hchild
)
5711 && NILP (leaf_windows
[i
]->vchild
));
5712 free_window_matrices (leaf_windows
[i
]);
5714 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5721 /* Scan dead buffer windows. */
5722 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5724 window
= XCAR (dead_windows
);
5725 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5726 delete_deletable_window (window
);
5729 /* Fselect_window will have made f the selected frame, so we
5730 reselect the proper frame here. Fhandle_switch_frame will change the
5731 selected window too, but that doesn't make the call to
5732 Fselect_window above totally superfluous; it still sets f's
5734 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5735 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5737 run_window_configuration_change_hook (f
);
5740 if (!NILP (new_current_buffer
))
5741 Fset_buffer (new_current_buffer
);
5743 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5744 minibuf_selected_window
= data
->minibuf_selected_window
;
5746 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5750 /* Recursively delete all child windows reachable via the next, vchild,
5751 and hchild slots of WINDOW. */
5753 delete_all_child_windows (Lisp_Object window
)
5755 register struct window
*w
;
5757 w
= XWINDOW (window
);
5759 if (!NILP (w
->next
))
5760 /* Delete WINDOW's siblings (we traverse postorderly). */
5761 delete_all_child_windows (w
->next
);
5763 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5765 if (!NILP (w
->vchild
))
5767 delete_all_child_windows (w
->vchild
);
5770 else if (!NILP (w
->hchild
))
5772 delete_all_child_windows (w
->hchild
);
5775 else if (!NILP (w
->buffer
))
5778 unchain_marker (XMARKER (w
->pointm
));
5779 unchain_marker (XMARKER (w
->start
));
5783 Vwindow_list
= Qnil
;
5787 count_windows (register struct window
*window
)
5789 register int count
= 1;
5790 if (!NILP (window
->next
))
5791 count
+= count_windows (XWINDOW (window
->next
));
5792 if (!NILP (window
->vchild
))
5793 count
+= count_windows (XWINDOW (window
->vchild
));
5794 if (!NILP (window
->hchild
))
5795 count
+= count_windows (XWINDOW (window
->hchild
));
5800 /* Fill vector FLAT with leaf windows under W, starting at index I.
5801 Value is last index + 1. */
5803 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5807 if (!NILP (w
->hchild
))
5808 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5809 else if (!NILP (w
->vchild
))
5810 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5814 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5821 /* Return a pointer to the glyph W's physical cursor is on. Value is
5822 null if W's current matrix is invalid, so that no meaningful glyph
5825 get_phys_cursor_glyph (struct window
*w
)
5827 struct glyph_row
*row
;
5828 struct glyph
*glyph
;
5829 int hpos
= w
->phys_cursor
.hpos
;
5831 if (!(w
->phys_cursor
.vpos
>= 0
5832 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5835 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5836 if (!row
->enabled_p
)
5839 if (XINT (w
->hscroll
))
5841 /* When the window is hscrolled, cursor hpos can legitimately be
5842 out of bounds, but we draw the cursor at the corresponding
5843 window margin in that case. */
5844 if (!row
->reversed_p
&& hpos
< 0)
5846 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
5847 hpos
= row
->used
[TEXT_AREA
] - 1;
5850 if (row
->used
[TEXT_AREA
] > hpos
5852 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
5861 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
5863 register struct saved_window
*p
;
5864 register struct window
*w
;
5865 register Lisp_Object tem
, pers
, par
;
5867 for (;!NILP (window
); window
= w
->next
)
5869 p
= SAVED_WINDOW_N (vector
, i
);
5870 w
= XWINDOW (window
);
5872 XSETFASTINT (w
->temslot
, i
); i
++;
5874 p
->buffer
= w
->buffer
;
5875 p
->left_col
= w
->left_col
;
5876 p
->top_line
= w
->top_line
;
5877 p
->total_cols
= w
->total_cols
;
5878 p
->total_lines
= w
->total_lines
;
5879 p
->normal_cols
= w
->normal_cols
;
5880 p
->normal_lines
= w
->normal_lines
;
5881 p
->hscroll
= w
->hscroll
;
5882 p
->min_hscroll
= w
->min_hscroll
;
5883 p
->display_table
= w
->display_table
;
5884 p
->left_margin_cols
= w
->left_margin_cols
;
5885 p
->right_margin_cols
= w
->right_margin_cols
;
5886 p
->left_fringe_width
= w
->left_fringe_width
;
5887 p
->right_fringe_width
= w
->right_fringe_width
;
5888 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
5889 p
->scroll_bar_width
= w
->scroll_bar_width
;
5890 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5891 p
->dedicated
= w
->dedicated
;
5892 p
->combination_limit
= w
->combination_limit
;
5893 p
->window_parameters
= Qnil
;
5895 if (!NILP (Vwindow_persistent_parameters
))
5897 /* Run cycle detection on Vwindow_persistent_parameters. */
5898 Lisp_Object tortoise
, hare
;
5900 hare
= tortoise
= Vwindow_persistent_parameters
;
5901 while (CONSP (hare
))
5908 tortoise
= XCDR (tortoise
);
5910 if (EQ (hare
, tortoise
))
5911 /* Reset Vwindow_persistent_parameters to Qnil. */
5913 Vwindow_persistent_parameters
= Qnil
;
5918 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
5922 /* Save values for persistent window parameters. */
5923 if (CONSP (pers
) && !NILP (XCDR (pers
)))
5925 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5927 /* If the window has no value for the parameter,
5929 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
5930 p
->window_parameters
);
5932 /* If the window has a value for the parameter,
5934 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
5936 p
->window_parameters
);
5941 if (!NILP (w
->buffer
))
5943 /* Save w's value of point in the window configuration. If w
5944 is the selected window, then get the value of point from
5945 the buffer; pointm is garbage in the selected window. */
5946 if (EQ (window
, selected_window
))
5948 p
->pointm
= Fmake_marker ();
5949 set_marker_both (p
->pointm
, w
->buffer
,
5950 BUF_PT (XBUFFER (w
->buffer
)),
5951 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5954 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5955 XMARKER (p
->pointm
)->insertion_type
5956 = !NILP (Vwindow_point_insertion_type
);
5958 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5959 p
->start_at_line_beg
= w
->start_at_line_beg
;
5961 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
5962 p
->mark
= Fcopy_marker (tem
, Qnil
);
5969 p
->start_at_line_beg
= Qnil
;
5972 if (NILP (w
->parent
))
5975 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5980 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5982 if (!NILP (w
->vchild
))
5983 i
= save_window_save (w
->vchild
, vector
, i
);
5984 if (!NILP (w
->hchild
))
5985 i
= save_window_save (w
->hchild
, vector
, i
);
5991 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5992 Scurrent_window_configuration
, 0, 1, 0,
5993 doc
: /* Return an object representing the current window configuration of FRAME.
5994 If FRAME is nil or omitted, use the selected frame.
5995 This describes the number of windows, their sizes and current buffers,
5996 and for each displayed buffer, where display starts, and the positions of
5997 point and mark. An exception is made for point in the current buffer:
5998 its value is -not- saved.
5999 This also records the currently selected frame, and FRAME's focus
6000 redirection (see `redirect-frame-focus'). The variable
6001 `window-persistent-parameters' specifies which window parameters are
6002 saved by this function. */)
6005 register Lisp_Object tem
;
6006 register int n_windows
;
6007 register struct save_window_data
*data
;
6012 frame
= selected_frame
;
6013 CHECK_LIVE_FRAME (frame
);
6016 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6017 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6018 PVEC_WINDOW_CONFIGURATION
);
6020 data
->frame_cols
= FRAME_COLS (f
);
6021 data
->frame_lines
= FRAME_LINES (f
);
6022 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6023 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6024 data
->selected_frame
= selected_frame
;
6025 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6026 XSETBUFFER (data
->current_buffer
, current_buffer
);
6027 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6028 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6029 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6030 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6031 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6032 data
->saved_windows
= tem
;
6033 for (i
= 0; i
< n_windows
; i
++)
6034 XVECTOR (tem
)->contents
[i
]
6035 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6036 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6037 XSETWINDOW_CONFIGURATION (tem
, data
);
6041 /***********************************************************************
6043 ***********************************************************************/
6045 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6047 doc
: /* Set width of marginal areas of window WINDOW.
6048 If WINDOW is nil, set margins of the currently selected window.
6049 Second arg LEFT-WIDTH specifies the number of character cells to
6050 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6051 does the same for the right marginal area. A nil width parameter
6052 means no margin. */)
6053 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6055 struct window
*w
= decode_window (window
);
6057 /* Translate negative or zero widths to nil.
6058 Margins that are too wide have to be checked elsewhere. */
6060 if (!NILP (left_width
))
6062 CHECK_NUMBER (left_width
);
6063 if (XINT (left_width
) <= 0)
6067 if (!NILP (right_width
))
6069 CHECK_NUMBER (right_width
);
6070 if (XINT (right_width
) <= 0)
6074 if (!EQ (w
->left_margin_cols
, left_width
)
6075 || !EQ (w
->right_margin_cols
, right_width
))
6077 w
->left_margin_cols
= left_width
;
6078 w
->right_margin_cols
= right_width
;
6080 adjust_window_margins (w
);
6082 ++windows_or_buffers_changed
;
6083 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6090 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6092 doc
: /* Get width of marginal areas of window WINDOW.
6093 If WINDOW is omitted or nil, it defaults to the selected window.
6094 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6095 If a marginal area does not exist, its width will be returned
6097 (Lisp_Object window
)
6099 struct window
*w
= decode_window (window
);
6100 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6105 /***********************************************************************
6107 ***********************************************************************/
6109 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6111 doc
: /* Set the fringe widths of window WINDOW.
6112 If WINDOW is nil, set the fringe widths of the currently selected
6114 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6115 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6116 fringe width. If a fringe width arg is nil, that means to use the
6117 frame's default fringe width. Default fringe widths can be set with
6118 the command `set-fringe-style'.
6119 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6120 outside of the display margins. By default, fringes are drawn between
6121 display marginal areas and the text area. */)
6122 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6124 struct window
*w
= decode_window (window
);
6126 if (!NILP (left_width
))
6127 CHECK_NATNUM (left_width
);
6128 if (!NILP (right_width
))
6129 CHECK_NATNUM (right_width
);
6131 /* Do nothing on a tty. */
6132 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6133 && (!EQ (w
->left_fringe_width
, left_width
)
6134 || !EQ (w
->right_fringe_width
, right_width
)
6135 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6137 w
->left_fringe_width
= left_width
;
6138 w
->right_fringe_width
= right_width
;
6139 w
->fringes_outside_margins
= outside_margins
;
6141 adjust_window_margins (w
);
6143 clear_glyph_matrix (w
->current_matrix
);
6144 w
->window_end_valid
= Qnil
;
6146 ++windows_or_buffers_changed
;
6147 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6154 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6156 doc
: /* Get width of fringes of window WINDOW.
6157 If WINDOW is omitted or nil, it defaults to the selected window.
6158 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6159 (Lisp_Object window
)
6161 struct window
*w
= decode_window (window
);
6163 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6164 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6165 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6166 ? Qt
: Qnil
), Qnil
)));
6171 /***********************************************************************
6173 ***********************************************************************/
6175 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6176 Sset_window_scroll_bars
, 2, 4, 0,
6177 doc
: /* Set width and type of scroll bars of window WINDOW.
6178 If window is nil, set scroll bars of the currently selected window.
6179 Second parameter WIDTH specifies the pixel width for the scroll bar;
6180 this is automatically adjusted to a multiple of the frame column width.
6181 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6182 bar: left, right, or nil.
6183 If WIDTH is nil, use the frame's scroll-bar width.
6184 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6185 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6186 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6188 struct window
*w
= decode_window (window
);
6192 CHECK_RANGED_INTEGER (0, width
, INT_MAX
);
6194 if (XINT (width
) == 0)
6195 vertical_type
= Qnil
;
6198 if (!(NILP (vertical_type
)
6199 || EQ (vertical_type
, Qleft
)
6200 || EQ (vertical_type
, Qright
)
6201 || EQ (vertical_type
, Qt
)))
6202 error ("Invalid type of vertical scroll bar");
6204 if (!EQ (w
->scroll_bar_width
, width
)
6205 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6207 w
->scroll_bar_width
= width
;
6208 w
->vertical_scroll_bar_type
= vertical_type
;
6210 adjust_window_margins (w
);
6212 clear_glyph_matrix (w
->current_matrix
);
6213 w
->window_end_valid
= Qnil
;
6215 ++windows_or_buffers_changed
;
6216 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6223 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6225 doc
: /* Get width and type of scroll bars of window WINDOW.
6226 If WINDOW is omitted or nil, it defaults to the selected window.
6227 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6228 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6230 (Lisp_Object window
)
6232 struct window
*w
= decode_window (window
);
6233 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6234 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6235 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6236 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6237 Fcons (w
->vertical_scroll_bar_type
,
6238 Fcons (Qnil
, Qnil
))));
6243 /***********************************************************************
6245 ***********************************************************************/
6247 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6248 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6249 If WINDOW is omitted or nil, it defaults to the selected window.
6250 Normally, value is a multiple of the canonical character height of WINDOW;
6251 optional second arg PIXELS-P means value is measured in pixels. */)
6252 (Lisp_Object window
, Lisp_Object pixels_p
)
6259 window
= selected_window
;
6261 CHECK_WINDOW (window
);
6262 w
= XWINDOW (window
);
6263 f
= XFRAME (w
->frame
);
6265 if (FRAME_WINDOW_P (f
))
6266 result
= (NILP (pixels_p
)
6267 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6268 : make_number (-w
->vscroll
));
6270 result
= make_number (0);
6275 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6277 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6278 WINDOW nil means use the selected window. Normally, VSCROLL is a
6279 non-negative multiple of the canonical character height of WINDOW;
6280 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6281 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6282 corresponds to an integral number of pixels. The return value is the
6283 result of this rounding.
6284 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6285 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6291 window
= selected_window
;
6293 CHECK_WINDOW (window
);
6294 CHECK_NUMBER_OR_FLOAT (vscroll
);
6296 w
= XWINDOW (window
);
6297 f
= XFRAME (w
->frame
);
6299 if (FRAME_WINDOW_P (f
))
6301 int old_dy
= w
->vscroll
;
6303 w
->vscroll
= - (NILP (pixels_p
)
6304 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6305 : XFLOATINT (vscroll
));
6306 w
->vscroll
= min (w
->vscroll
, 0);
6308 if (w
->vscroll
!= old_dy
)
6310 /* Adjust glyph matrix of the frame if the virtual display
6311 area becomes larger than before. */
6312 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6315 /* Prevent redisplay shortcuts. */
6316 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6320 return Fwindow_vscroll (window
, pixels_p
);
6324 /* Call FN for all leaf windows on frame F. FN is called with the
6325 first argument being a pointer to the leaf window, and with
6326 additional argument USER_DATA. Stops when FN returns 0. */
6329 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6332 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6333 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6334 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6338 /* Helper function for foreach_window. Call FN for all leaf windows
6339 reachable from W. FN is called with the first argument being a
6340 pointer to the leaf window, and with additional argument USER_DATA.
6341 Stop when FN returns 0. Value is 0 if stopped by FN. */
6344 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6348 for (cont
= 1; w
&& cont
;)
6350 if (!NILP (w
->hchild
))
6351 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6352 else if (!NILP (w
->vchild
))
6353 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6355 cont
= fn (w
, user_data
);
6357 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6364 /* Freeze or unfreeze the window start of W unless it is a
6365 mini-window or the selected window. FREEZE_P non-null means freeze
6366 the window start. */
6369 freeze_window_start (struct window
*w
, void *freeze_p
)
6371 if (MINI_WINDOW_P (w
)
6372 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6373 && (w
== XWINDOW (selected_window
)
6374 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6375 && ! NILP (Vminibuf_scroll_window
)
6376 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6379 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6384 /* Freeze or unfreeze the window starts of all leaf windows on frame
6385 F, except the selected window and a mini-window. FREEZE_P non-zero
6386 means freeze the window start. */
6389 freeze_window_starts (struct frame
*f
, int freeze_p
)
6391 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6395 /***********************************************************************
6397 ***********************************************************************/
6399 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6400 describe the same state of affairs. This is used by Fequal.
6402 ignore_positions non-zero means ignore non-matching scroll positions
6405 This ignores a couple of things like the dedication status of
6406 window, combination_limit and the like. This might have to be
6410 compare_window_configurations (Lisp_Object configuration1
, Lisp_Object configuration2
, int ignore_positions
)
6412 register struct save_window_data
*d1
, *d2
;
6413 struct Lisp_Vector
*sws1
, *sws2
;
6416 CHECK_WINDOW_CONFIGURATION (configuration1
);
6417 CHECK_WINDOW_CONFIGURATION (configuration2
);
6419 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6420 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6421 sws1
= XVECTOR (d1
->saved_windows
);
6422 sws2
= XVECTOR (d2
->saved_windows
);
6424 /* Frame settings must match. */
6425 if (d1
->frame_cols
!= d2
->frame_cols
6426 || d1
->frame_lines
!= d2
->frame_lines
6427 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6428 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6429 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6430 || (!ignore_positions
6431 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6432 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6433 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6434 /* Verify that the two configurations have the same number of windows. */
6435 || sws1
->header
.size
!= sws2
->header
.size
)
6438 for (i
= 0; i
< sws1
->header
.size
; i
++)
6440 struct saved_window
*sw1
, *sw2
;
6442 sw1
= SAVED_WINDOW_N (sws1
, i
);
6443 sw2
= SAVED_WINDOW_N (sws2
, i
);
6446 /* The "current" windows in the two configurations must
6447 correspond to each other. */
6448 EQ (d1
->current_window
, sw1
->window
)
6449 != EQ (d2
->current_window
, sw2
->window
)
6450 /* Windows' buffers must match. */
6451 || !EQ (sw1
->buffer
, sw2
->buffer
)
6452 || !EQ (sw1
->left_col
, sw2
->left_col
)
6453 || !EQ (sw1
->top_line
, sw2
->top_line
)
6454 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6455 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6456 || !EQ (sw1
->display_table
, sw2
->display_table
)
6457 /* The next two disjuncts check the window structure for
6459 || !EQ (sw1
->parent
, sw2
->parent
)
6460 || !EQ (sw1
->prev
, sw2
->prev
)
6461 || (!ignore_positions
6462 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6463 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6464 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6465 || NILP (Fequal (sw1
->start
, sw2
->start
))
6466 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6467 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6468 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6469 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6470 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6471 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6472 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6473 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6474 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6481 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6482 Scompare_window_configurations
, 2, 2, 0,
6483 doc
: /* Compare two window configurations as regards the structure of windows.
6484 This function ignores details such as the values of point and mark
6485 and scrolling positions. */)
6486 (Lisp_Object x
, Lisp_Object y
)
6488 if (compare_window_configurations (x
, y
, 1))
6494 init_window_once (void)
6496 struct frame
*f
= make_initial_frame ();
6497 XSETFRAME (selected_frame
, f
);
6498 Vterminal_frame
= selected_frame
;
6499 minibuf_window
= f
->minibuffer_window
;
6500 selected_window
= f
->selected_window
;
6501 last_nonminibuf_frame
= f
;
6503 window_initialized
= 1;
6509 Vwindow_list
= Qnil
;
6513 syms_of_window (void)
6515 DEFSYM (Qscroll_up
, "scroll-up");
6516 DEFSYM (Qscroll_down
, "scroll-down");
6517 DEFSYM (Qscroll_command
, "scroll-command");
6519 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6520 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6522 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6523 DEFSYM (Qwindowp
, "windowp");
6524 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6525 DEFSYM (Qwindow_live_p
, "window-live-p");
6526 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6527 DEFSYM (Qdelete_window
, "delete-window");
6528 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6529 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6530 DEFSYM (Qsafe
, "safe");
6531 DEFSYM (Qdisplay_buffer
, "display-buffer");
6532 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6533 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6534 DEFSYM (Qget_mru_window
, "get-mru-window");
6535 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6536 DEFSYM (Qabove
, "above");
6537 DEFSYM (Qbelow
, "below");
6538 DEFSYM (Qauto_buffer_name
, "auto-buffer-name");
6539 DEFSYM (Qclone_of
, "clone-of");
6541 staticpro (&Vwindow_list
);
6543 minibuf_selected_window
= Qnil
;
6544 staticpro (&minibuf_selected_window
);
6546 window_scroll_pixel_based_preserve_x
= -1;
6547 window_scroll_pixel_based_preserve_y
= -1;
6548 window_scroll_preserve_hpos
= -1;
6549 window_scroll_preserve_vpos
= -1;
6551 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6552 doc
: /* Non-nil means call as function to display a help buffer.
6553 The function is called with one argument, the buffer to be displayed.
6554 Used by `with-output-to-temp-buffer'.
6555 If this function is used, then it must do the entire job of showing
6556 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6557 Vtemp_buffer_show_function
= Qnil
;
6559 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6560 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6561 Vminibuf_scroll_window
= Qnil
;
6563 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6564 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6565 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6566 is displayed in the `mode-line' face. */);
6567 mode_line_in_non_selected_windows
= 1;
6569 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6570 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6571 Vother_window_scroll_buffer
= Qnil
;
6573 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6574 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6575 auto_window_vscroll_p
= 1;
6577 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6578 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6579 next_screen_context_lines
= 2;
6581 DEFVAR_LISP ("scroll-preserve-screen-position",
6582 Vscroll_preserve_screen_position
,
6583 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6584 A value of nil means point does not keep its screen position except
6585 at the scroll margin or window boundary respectively.
6586 A value of t means point keeps its screen position if the scroll
6587 command moved it vertically out of the window, e.g. when scrolling
6589 Any other value means point always keeps its screen position.
6590 Scroll commands should have the `scroll-command' property
6591 on their symbols to be controlled by this variable. */);
6592 Vscroll_preserve_screen_position
= Qnil
;
6594 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6595 doc
: /* Type of marker to use for `window-point'. */);
6596 Vwindow_point_insertion_type
= Qnil
;
6598 DEFVAR_LISP ("window-configuration-change-hook",
6599 Vwindow_configuration_change_hook
,
6600 doc
: /* Functions to call when window configuration changes.
6601 The buffer-local part is run once per window, with the relevant window
6602 selected; while the global part is run only once for the modified frame,
6603 with the relevant frame selected. */);
6604 Vwindow_configuration_change_hook
= Qnil
;
6606 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6607 doc
: /* Non-nil means `recenter' redraws entire frame.
6608 If this option is non-nil, then the `recenter' command with a nil
6609 argument will redraw the entire frame; the special value `tty' causes
6610 the frame to be redrawn only if it is a tty frame. */);
6611 Vrecenter_redisplay
= Qtty
;
6613 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6614 doc
: /* If t, resize window combinations proportionally.
6615 If this variable is nil, splitting a window gets the entire screen space
6616 for displaying the new window from the window to split. Deleting and
6617 resizing a window preferably resizes one adjacent window only.
6619 If this variable is t, splitting a window tries to get the space
6620 proportionally from all windows in the same combination. This also
6621 allows to split a window that is otherwise too small or of fixed size.
6622 Resizing and deleting a window proportionally resize all windows in the
6625 Other values are reserved for future use.
6627 This variable takes no effect if `window-combination-limit' is non-nil. */);
6628 Vwindow_combination_resize
= Qnil
;
6630 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6631 doc
: /* If t, splitting a window makes a new parent window.
6632 If this variable is nil, splitting a window will create a new parent
6633 window only if the window has no parent window or the window shall
6634 become a combination orthogonal to the one it is part of.
6636 If this variable is t, splitting a window always creates a new parent
6637 window. If all splits behave this way, each frame's window tree is a
6638 binary tree and every window but the frame's root window has exactly one
6641 Other values are reserved for future use.
6643 The value of this variable is also assigned to the combination limit of
6644 the new parent window. The combination limit of a window can be
6645 retrieved via the function `window-combination-limit' and altered by the
6646 function `set-window-combination-limit'. */);
6647 Vwindow_combination_limit
= Qnil
;
6649 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6650 doc
: /* Alist of persistent window parameters.
6651 This alist specifies which window parameters shall get saved by
6652 `current-window-configuration' and `window-state-get' and subsequently
6653 restored to their previous values by `set-window-configuration' and
6656 The car of each entry of this alist is the symbol specifying the
6657 parameter. The cdr is one of the following:
6659 nil means the parameter is neither saved by `window-state-get' nor by
6660 `current-window-configuration'.
6662 t means the parameter is saved by `current-window-configuration' and,
6663 provided its WRITABLE argument is nil, by `window-state-get'.
6665 The symbol `writable' means the parameter is saved unconditionally by
6666 both `current-window-configuration' and `window-state-get'. Do not use
6667 this value for parameters without read syntax (like windows or frames).
6669 Parameters not saved by `current-window-configuration' or
6670 `window-state-get' are left alone by `set-window-configuration'
6671 respectively are not installed by `window-state-put'. */);
6672 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6674 defsubr (&Sselected_window
);
6675 defsubr (&Sminibuffer_window
);
6676 defsubr (&Swindow_minibuffer_p
);
6677 defsubr (&Swindowp
);
6678 defsubr (&Swindow_live_p
);
6679 defsubr (&Swindow_frame
);
6680 defsubr (&Sframe_root_window
);
6681 defsubr (&Sframe_first_window
);
6682 defsubr (&Sframe_selected_window
);
6683 defsubr (&Sset_frame_selected_window
);
6684 defsubr (&Spos_visible_in_window_p
);
6685 defsubr (&Swindow_line_height
);
6686 defsubr (&Swindow_buffer
);
6687 defsubr (&Swindow_parent
);
6688 defsubr (&Swindow_top_child
);
6689 defsubr (&Swindow_left_child
);
6690 defsubr (&Swindow_next_sibling
);
6691 defsubr (&Swindow_prev_sibling
);
6692 defsubr (&Swindow_combination_limit
);
6693 defsubr (&Sset_window_combination_limit
);
6694 defsubr (&Swindow_use_time
);
6695 defsubr (&Swindow_top_line
);
6696 defsubr (&Swindow_left_column
);
6697 defsubr (&Swindow_total_height
);
6698 defsubr (&Swindow_total_width
);
6699 defsubr (&Swindow_normal_size
);
6700 defsubr (&Swindow_new_total
);
6701 defsubr (&Swindow_new_normal
);
6702 defsubr (&Sset_window_new_total
);
6703 defsubr (&Sset_window_new_normal
);
6704 defsubr (&Swindow_resize_apply
);
6705 defsubr (&Swindow_body_height
);
6706 defsubr (&Swindow_body_width
);
6707 defsubr (&Swindow_hscroll
);
6708 defsubr (&Sset_window_hscroll
);
6709 defsubr (&Swindow_redisplay_end_trigger
);
6710 defsubr (&Sset_window_redisplay_end_trigger
);
6711 defsubr (&Swindow_edges
);
6712 defsubr (&Swindow_pixel_edges
);
6713 defsubr (&Swindow_absolute_pixel_edges
);
6714 defsubr (&Swindow_inside_edges
);
6715 defsubr (&Swindow_inside_pixel_edges
);
6716 defsubr (&Swindow_inside_absolute_pixel_edges
);
6717 defsubr (&Scoordinates_in_window_p
);
6718 defsubr (&Swindow_at
);
6719 defsubr (&Swindow_point
);
6720 defsubr (&Swindow_start
);
6721 defsubr (&Swindow_end
);
6722 defsubr (&Sset_window_point
);
6723 defsubr (&Sset_window_start
);
6724 defsubr (&Swindow_dedicated_p
);
6725 defsubr (&Sset_window_dedicated_p
);
6726 defsubr (&Swindow_display_table
);
6727 defsubr (&Sset_window_display_table
);
6728 defsubr (&Snext_window
);
6729 defsubr (&Sprevious_window
);
6730 defsubr (&Sget_buffer_window
);
6731 defsubr (&Sdelete_other_windows_internal
);
6732 defsubr (&Sdelete_window_internal
);
6733 defsubr (&Sresize_mini_window_internal
);
6734 defsubr (&Sset_window_buffer
);
6735 defsubr (&Srun_window_configuration_change_hook
);
6736 defsubr (&Sselect_window
);
6737 defsubr (&Sforce_window_update
);
6738 defsubr (&Stemp_output_buffer_show
);
6739 defsubr (&Ssplit_window_internal
);
6740 defsubr (&Sscroll_up
);
6741 defsubr (&Sscroll_down
);
6742 defsubr (&Sscroll_left
);
6743 defsubr (&Sscroll_right
);
6744 defsubr (&Sother_window_for_scrolling
);
6745 defsubr (&Sscroll_other_window
);
6746 defsubr (&Sminibuffer_selected_window
);
6747 defsubr (&Srecenter
);
6748 defsubr (&Swindow_text_height
);
6749 defsubr (&Smove_to_window_line
);
6750 defsubr (&Swindow_configuration_p
);
6751 defsubr (&Swindow_configuration_frame
);
6752 defsubr (&Sset_window_configuration
);
6753 defsubr (&Scurrent_window_configuration
);
6754 defsubr (&Sset_window_margins
);
6755 defsubr (&Swindow_margins
);
6756 defsubr (&Sset_window_fringes
);
6757 defsubr (&Swindow_fringes
);
6758 defsubr (&Sset_window_scroll_bars
);
6759 defsubr (&Swindow_scroll_bars
);
6760 defsubr (&Swindow_vscroll
);
6761 defsubr (&Sset_window_vscroll
);
6762 defsubr (&Scompare_window_configurations
);
6763 defsubr (&Swindow_list
);
6764 defsubr (&Swindow_list_1
);
6765 defsubr (&Swindow_prev_buffers
);
6766 defsubr (&Sset_window_prev_buffers
);
6767 defsubr (&Swindow_next_buffers
);
6768 defsubr (&Sset_window_next_buffers
);
6769 defsubr (&Swindow_parameters
);
6770 defsubr (&Swindow_parameter
);
6771 defsubr (&Sset_window_parameter
);
6775 keys_of_window (void)
6777 initial_define_key (control_x_map
, '<', "scroll-left");
6778 initial_define_key (control_x_map
, '>', "scroll-right");
6780 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6781 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6782 initial_define_key (meta_map
, 'v', "scroll-down-command");