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/>. */
23 #define WINDOW_INLINE EXTERN_INLINE
28 #include "character.h"
38 #include "dispextern.h"
39 #include "blockinput.h"
40 #include "intervals.h"
41 #include "termhooks.h" /* For FRAME_TERMINAL. */
45 #endif /* HAVE_X_WINDOWS */
56 Lisp_Object Qwindowp
, Qwindow_live_p
;
57 static Lisp_Object Qwindow_valid_p
;
58 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
59 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
60 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
61 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
62 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
63 static Lisp_Object Qsafe
, Qabove
, Qbelow
, Qwindow_size
, Qclone_of
;
65 static int displayed_window_lines (struct window
*);
66 static int count_windows (struct window
*);
67 static int get_leaf_windows (struct window
*, struct window
**, int);
68 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
69 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
70 static void window_scroll_line_based (Lisp_Object
, int, int, int);
71 static int freeze_window_start (struct window
*, void *);
72 static Lisp_Object
window_list (void);
73 static int add_window_to_list (struct window
*, void *);
74 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
80 static void foreach_window (struct frame
*,
81 int (* fn
) (struct window
*, void *),
83 static int foreach_window_1 (struct window
*,
84 int (* fn
) (struct window
*, void *),
86 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
87 static int window_resize_check (struct window
*, int);
88 static void window_resize_apply (struct window
*, int);
89 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
91 /* This is the window in which the terminal's cursor should
92 be left when nothing is being done with it. This must
93 always be a leaf window, and its buffer is selected by
94 the top level editing loop at the end of each command.
96 This value is always the same as
97 FRAME_SELECTED_WINDOW (selected_frame). */
98 Lisp_Object selected_window
;
100 /* A list of all windows for use by next_window and Fwindow_list.
101 Functions creating or deleting windows should invalidate this cache
102 by setting it to nil. */
103 Lisp_Object Vwindow_list
;
105 /* The mini-buffer window of the selected frame.
106 Note that you cannot test for mini-bufferness of an arbitrary window
107 by comparing against this; but you can test for mini-bufferness of
108 the selected window. */
109 Lisp_Object minibuf_window
;
111 /* Non-nil means it is the window whose mode line should be
112 shown as the selected window when the minibuffer is selected. */
113 Lisp_Object minibuf_selected_window
;
115 /* Hook run at end of temp_output_buffer_show. */
116 static Lisp_Object Qtemp_buffer_show_hook
;
118 /* Incremented for each window created. */
119 static int sequence_number
;
121 /* Nonzero after init_window_once has finished. */
122 static int window_initialized
;
124 /* Hook to run when window config changes. */
125 static Lisp_Object Qwindow_configuration_change_hook
;
127 /* Used by the function window_scroll_pixel_based */
128 static int window_scroll_pixel_based_preserve_x
;
129 static int window_scroll_pixel_based_preserve_y
;
131 /* Same for window_scroll_line_based. */
132 static EMACS_INT window_scroll_preserve_hpos
;
133 static EMACS_INT window_scroll_preserve_vpos
;
135 /* These setters are used only in this file, so they can be private. */
137 wset_combination_limit (struct window
*w
, Lisp_Object val
)
139 w
->combination_limit
= val
;
142 wset_dedicated (struct window
*w
, Lisp_Object val
)
147 wset_display_table (struct window
*w
, Lisp_Object val
)
149 w
->display_table
= val
;
152 wset_hchild (struct window
*w
, Lisp_Object val
)
157 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
159 w
->left_fringe_width
= val
;
162 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
164 w
->left_margin_cols
= val
;
167 wset_new_normal (struct window
*w
, Lisp_Object val
)
172 wset_new_total (struct window
*w
, Lisp_Object val
)
177 wset_normal_cols (struct window
*w
, Lisp_Object val
)
179 w
->normal_cols
= val
;
182 wset_normal_lines (struct window
*w
, Lisp_Object val
)
184 w
->normal_lines
= val
;
187 wset_parent (struct window
*w
, Lisp_Object val
)
192 wset_pointm (struct window
*w
, Lisp_Object val
)
197 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
199 w
->right_fringe_width
= val
;
202 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
204 w
->right_margin_cols
= val
;
207 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
209 w
->scroll_bar_width
= val
;
212 wset_start (struct window
*w
, Lisp_Object val
)
217 wset_temslot (struct window
*w
, Lisp_Object val
)
222 wset_vchild (struct window
*w
, Lisp_Object val
)
227 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
229 w
->vertical_scroll_bar_type
= val
;
232 wset_window_parameters (struct window
*w
, Lisp_Object val
)
234 w
->window_parameters
= val
;
238 decode_live_window (register Lisp_Object window
)
241 return XWINDOW (selected_window
);
243 CHECK_LIVE_WINDOW (window
);
244 return XWINDOW (window
);
248 decode_any_window (register Lisp_Object window
)
253 return XWINDOW (selected_window
);
255 CHECK_WINDOW (window
);
256 w
= XWINDOW (window
);
260 static struct window
*
261 decode_valid_window (register Lisp_Object window
)
266 return XWINDOW (selected_window
);
268 CHECK_VALID_WINDOW (window
);
269 w
= XWINDOW (window
);
273 /* Build a frequently used 4-integer (X Y W H) list. */
276 quad (ptrdiff_t x
, ptrdiff_t y
, ptrdiff_t w
, ptrdiff_t h
)
278 return list4 (make_number (x
), make_number (y
),
279 make_number (w
), make_number (h
));
282 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
283 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
286 return WINDOWP (object
) ? Qt
: Qnil
;
289 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
290 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
291 A valid window is either a window that displays a buffer or an internal
292 window. Deleted windows are not live. */)
295 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
298 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
299 doc
: /* Return t if OBJECT is a live window and nil otherwise.
300 A live window is a window that displays a buffer.
301 Internal windows and deleted windows are not live. */)
304 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
307 /* Frames and windows. */
308 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
309 doc
: /* Return the frame that window WINDOW is on.
310 WINDOW must be a valid window and defaults to the selected one. */)
313 return decode_valid_window (window
)->frame
;
316 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
317 doc
: /* Return the root window of FRAME-OR-WINDOW.
318 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
319 With a frame argument, return that frame's root window.
320 With a window argument, return the root window of that window's frame. */)
321 (Lisp_Object frame_or_window
)
325 if (NILP (frame_or_window
))
326 window
= SELECTED_FRAME ()->root_window
;
327 else if (WINDOW_VALID_P (frame_or_window
))
328 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
331 CHECK_LIVE_FRAME (frame_or_window
);
332 window
= XFRAME (frame_or_window
)->root_window
;
338 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
339 doc
: /* Return the minibuffer window for frame FRAME.
340 If FRAME is omitted or nil, it defaults to the selected frame. */)
343 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
346 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
347 Swindow_minibuffer_p
, 0, 1, 0,
348 doc
: /* Return non-nil if WINDOW is a minibuffer window.
349 WINDOW must be a valid window and defaults to the selected one. */)
352 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
355 /* Don't move this to window.el - this must be a safe routine. */
356 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
357 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
358 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
359 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
360 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
361 the first window of that frame. */)
362 (Lisp_Object frame_or_window
)
366 if (NILP (frame_or_window
))
367 window
= SELECTED_FRAME ()->root_window
;
368 else if (WINDOW_VALID_P (frame_or_window
))
369 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
372 CHECK_LIVE_FRAME (frame_or_window
);
373 window
= XFRAME (frame_or_window
)->root_window
;
376 while (NILP (XWINDOW (window
)->buffer
))
378 if (! NILP (XWINDOW (window
)->hchild
))
379 window
= XWINDOW (window
)->hchild
;
380 else if (! NILP (XWINDOW (window
)->vchild
))
381 window
= XWINDOW (window
)->vchild
;
389 DEFUN ("frame-selected-window", Fframe_selected_window
,
390 Sframe_selected_window
, 0, 1, 0,
391 doc
: /* Return the selected window of FRAME-OR-WINDOW.
392 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
393 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
394 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
395 return the selected window of that frame. */)
396 (Lisp_Object frame_or_window
)
400 if (NILP (frame_or_window
))
401 window
= SELECTED_FRAME ()->selected_window
;
402 else if (WINDOW_VALID_P (frame_or_window
))
403 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
406 CHECK_LIVE_FRAME (frame_or_window
);
407 window
= XFRAME (frame_or_window
)->selected_window
;
413 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
414 Sset_frame_selected_window
, 2, 3, 0,
415 doc
: /* Set selected window of FRAME to WINDOW.
416 FRAME must be a live frame and defaults to the selected one. If FRAME
417 is the selected frame, this makes WINDOW the selected window. Optional
418 argument NORECORD non-nil means to neither change the order of recently
419 selected windows nor the buffer list. WINDOW must denote a live window.
421 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
424 frame
= selected_frame
;
426 CHECK_LIVE_FRAME (frame
);
427 CHECK_LIVE_WINDOW (window
);
429 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
430 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
432 if (EQ (frame
, selected_frame
))
433 return Fselect_window (window
, norecord
);
436 fset_selected_window (XFRAME (frame
), window
);
441 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
442 doc
: /* Return the selected window.
443 The selected window is the window in which the standard cursor for
444 selected windows appears and to which many commands apply. */)
447 return selected_window
;
450 int window_select_count
;
452 /* If select_window is called with inhibit_point_swap non-zero it will
453 not store point of the old selected window's buffer back into that
454 window's pointm slot. This is needed by Fset_window_configuration to
455 avoid that the display routine is called with selected_window set to
456 Qnil causing a subsequent crash. */
458 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
460 register struct window
*w
;
461 register struct window
*ow
;
464 CHECK_LIVE_WINDOW (window
);
466 w
= XWINDOW (window
);
467 w
->frozen_window_start_p
= 0;
471 w
->use_time
= ++window_select_count
;
472 record_buffer (w
->buffer
);
475 /* Make the selected window's buffer current. */
476 Fset_buffer (w
->buffer
);
478 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
481 sf
= SELECTED_FRAME ();
482 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
484 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
485 /* Use this rather than Fhandle_switch_frame
486 so that FRAME_FOCUS_FRAME is moved appropriately as we
487 move around in the state where a minibuffer in a separate
489 Fselect_frame (WINDOW_FRAME (w
), norecord
);
490 /* Fselect_frame called us back so we've done all the work already. */
491 eassert (EQ (window
, selected_window
));
495 fset_selected_window (sf
, window
);
497 /* Store the old selected window's buffer's point in pointm of the old
498 selected window. It belongs to that window, and when the window is
499 not selected, must be in the window. */
500 if (!inhibit_point_swap
)
502 ow
= XWINDOW (selected_window
);
503 if (! NILP (ow
->buffer
))
504 set_marker_both (ow
->pointm
, ow
->buffer
,
505 BUF_PT (XBUFFER (ow
->buffer
)),
506 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
509 selected_window
= window
;
510 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
512 /* Go to the point recorded in the window.
513 This is important when the buffer is in more
514 than one window. It also matters when
515 redisplay_window has altered point after scrolling,
516 because it makes the change only in the window. */
518 register ptrdiff_t new_point
= marker_position (w
->pointm
);
519 if (new_point
< BEGV
)
521 else if (new_point
> ZV
)
527 windows_or_buffers_changed
++;
531 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
532 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
533 Also make WINDOW's buffer current and make WINDOW the frame's selected
534 window. Return WINDOW.
536 Optional second arg NORECORD non-nil means do not put this buffer at the
537 front of the buffer list and do not make this window the most recently
540 Note that the main editor command loop sets the current buffer to the
541 buffer of the selected window before each command. */)
542 (register Lisp_Object window
, Lisp_Object norecord
)
544 return select_window (window
, norecord
, 0);
547 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
548 doc
: /* Return the buffer displayed in window WINDOW.
549 If WINDOW is omitted or nil, it defaults to the selected window.
550 Return nil for an internal window or a deleted window. */)
553 return decode_any_window (window
)->buffer
;
556 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
557 doc
: /* Return the parent window of window WINDOW.
558 WINDOW must be a valid window and defaults to the selected one.
559 Return nil for a window with no parent (e.g. a root window). */)
562 return decode_valid_window (window
)->parent
;
565 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
566 doc
: /* Return the topmost child window of window WINDOW.
567 WINDOW must be a valid window and defaults to the selected one.
568 Return nil if WINDOW is a live window (live windows have no children).
569 Return nil if WINDOW is an internal window whose children form a
570 horizontal combination. */)
573 return decode_valid_window (window
)->vchild
;
576 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
577 doc
: /* Return the leftmost child window of window WINDOW.
578 WINDOW must be a valid window and defaults to the selected one.
579 Return nil if WINDOW is a live window (live windows have no children).
580 Return nil if WINDOW is an internal window whose children form a
581 vertical combination. */)
584 return decode_valid_window (window
)->hchild
;
587 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
588 doc
: /* Return the next sibling window of window WINDOW.
589 WINDOW must be a valid window and defaults to the selected one.
590 Return nil if WINDOW has no next sibling. */)
593 return decode_valid_window (window
)->next
;
596 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
597 doc
: /* Return the previous sibling window of window WINDOW.
598 WINDOW must be a valid window and defaults to the selected one.
599 Return nil if WINDOW has no previous sibling. */)
602 return decode_valid_window (window
)->prev
;
605 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 0, 1, 0,
606 doc
: /* Return combination limit of window WINDOW.
607 WINDOW must be a valid window and defaults to the selected one.
608 If the return value is nil, child windows of WINDOW can be recombined with
609 WINDOW's siblings. A return value of t means that child windows of
610 WINDOW are never \(re-)combined with WINDOW's siblings. */)
613 return decode_valid_window (window
)->combination_limit
;
616 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
617 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
618 WINDOW must be a valid window and defaults to the selected one.
619 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
620 siblings. LIMIT t means that child windows of WINDOW are never
621 \(re-)combined with WINDOW's siblings. Other values are reserved for
623 (Lisp_Object window
, Lisp_Object limit
)
625 wset_combination_limit (decode_valid_window (window
), limit
);
629 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
630 doc
: /* Return the use time of window WINDOW.
631 WINDOW must be a live window and defaults to the selected one.
632 The window with the highest use time is the most recently selected
633 one. The window with the lowest use time is the least recently
637 return make_number (decode_live_window (window
)->use_time
);
640 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
641 doc
: /* Return the total height, in lines, of window WINDOW.
642 WINDOW must be a valid window and defaults to the selected one.
644 The return value includes the mode line and header line, if any.
645 If WINDOW is an internal window, the total height is the height
646 of the screen areas spanned by its children.
648 On a graphical display, this total height is reported as an
649 integer multiple of the default character height. */)
652 return decode_valid_window (window
)->total_lines
;
655 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
656 doc
: /* Return the total width, in columns, of window WINDOW.
657 WINDOW must be a valid window and defaults to the selected one.
659 The return value includes any vertical dividers or scroll bars
660 belonging to WINDOW. If WINDOW is an internal window, the total width
661 is the width of the screen areas spanned by its children.
663 On a graphical display, this total width is reported as an
664 integer multiple of the default character width. */)
667 return decode_valid_window (window
)->total_cols
;
670 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
671 doc
: /* Return the new total size of window WINDOW.
672 WINDOW must be a valid window and defaults to the selected one. */)
675 return decode_valid_window (window
)->new_total
;
678 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
679 doc
: /* Return the normal height of window WINDOW.
680 WINDOW must be a valid window and defaults to the selected one.
681 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
682 (Lisp_Object window
, Lisp_Object horizontal
)
684 struct window
*w
= decode_valid_window (window
);
686 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
689 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
690 doc
: /* Return new normal size of window WINDOW.
691 WINDOW must be a valid window and defaults to the selected one. */)
694 return decode_valid_window (window
)->new_normal
;
697 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
698 doc
: /* Return left column of window WINDOW.
699 This is the distance, in columns, between the left edge of WINDOW and
700 the left edge of the frame's window area. For instance, the return
701 value is 0 if there is no window to the left of WINDOW.
703 WINDOW must be a valid window and defaults to the selected one. */)
706 return decode_valid_window (window
)->left_col
;
709 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
710 doc
: /* Return top line of window WINDOW.
711 This is the distance, in lines, between the top of WINDOW and the top
712 of the frame's window area. For instance, the return value is 0 if
713 there is no window above WINDOW.
715 WINDOW must be a valid window and defaults to the selected one. */)
718 return decode_valid_window (window
)->top_line
;
721 /* Return the number of lines of W's body. Don't count any mode or
725 window_body_lines (struct window
*w
)
727 int height
= XFASTINT (w
->total_lines
);
729 if (!MINI_WINDOW_P (w
))
731 if (WINDOW_WANTS_MODELINE_P (w
))
733 if (WINDOW_WANTS_HEADER_LINE_P (w
))
740 /* Return the number of columns of W's body. Don't count columns
741 occupied by the scroll bar or the vertical bar separating W from its
742 right sibling. On window-systems don't count fringes or display
746 window_body_cols (struct window
*w
)
748 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
749 int width
= XINT (w
->total_cols
);
751 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
752 /* Scroll bars occupy a few columns. */
753 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
754 else if (!FRAME_WINDOW_P (f
)
755 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
756 /* The column of `|' characters separating side-by-side windows
757 occupies one column only. */
760 if (FRAME_WINDOW_P (f
))
761 /* On window-systems, fringes and display margins cannot be
762 used for normal text. */
763 width
-= (WINDOW_FRINGE_COLS (w
)
764 + WINDOW_LEFT_MARGIN_COLS (w
)
765 + WINDOW_RIGHT_MARGIN_COLS (w
));
770 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
771 doc
: /* Return the height, in lines, of WINDOW's text area.
772 WINDOW must be a live window and defaults to the selected one.
774 The returned height does not include the mode line or header line.
775 On a graphical display, the height is expressed as an integer multiple
776 of the default character height. If a line at the bottom of the text
777 area is only partially visible, that counts as a whole line; to
778 exclude partially-visible lines, use `window-text-height'. */)
781 return make_number (window_body_lines (decode_live_window (window
)));
784 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
785 doc
: /* Return the width, in columns, of WINDOW's text area.
786 WINDOW must be a live window and defaults to the selected one.
788 The return value does not include any vertical dividers, fringe or
789 marginal areas, or scroll bars. On a graphical display, the width is
790 expressed as an integer multiple of the default character width. */)
793 return make_number (window_body_cols (decode_live_window (window
)));
796 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
797 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
798 WINDOW must be a live window and defaults to the selected one. */)
801 return make_number (decode_live_window (window
)->hscroll
);
804 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
805 range, returning the new amount as a fixnum. */
807 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
809 /* Horizontal scrolling has problems with large scroll amounts.
810 It's too slow with long lines, and even with small lines the
811 display can be messed up. For now, though, impose only the limits
812 required by the internal representation: horizontal scrolling must
813 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
814 (since it's stored in a ptrdiff_t). */
815 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
816 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
818 /* Prevent redisplay shortcuts when changing the hscroll. */
819 if (w
->hscroll
!= new_hscroll
)
820 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
822 w
->hscroll
= new_hscroll
;
823 return make_number (new_hscroll
);
826 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
827 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
828 WINDOW must be a live window and defaults to the selected one.
829 Clip the number to a reasonable value if out of range.
830 Return the new number. NCOL should be zero or positive.
832 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
833 window so that the location of point moves off-window. */)
834 (Lisp_Object window
, Lisp_Object ncol
)
837 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
840 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
841 Swindow_redisplay_end_trigger
, 0, 1, 0,
842 doc
: /* Return WINDOW's redisplay end trigger value.
843 WINDOW must be a live window and defaults to the selected one.
844 See `set-window-redisplay-end-trigger' for more information. */)
847 return decode_live_window (window
)->redisplay_end_trigger
;
850 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
851 Sset_window_redisplay_end_trigger
, 2, 2, 0,
852 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
853 WINDOW must be a live window and defaults to the selected one. VALUE
854 should be a buffer position (typically a marker) or nil. If it is a
855 buffer position, then if redisplay in WINDOW reaches a position beyond
856 VALUE, the functions in `redisplay-end-trigger-functions' are called
857 with two arguments: WINDOW, and the end trigger value. Afterwards the
858 end-trigger value is reset to nil. */)
859 (register Lisp_Object window
, Lisp_Object value
)
861 wset_redisplay_end_trigger (decode_live_window (window
), value
);
865 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
866 doc
: /* Return a list of the edge coordinates of WINDOW.
867 WINDOW must be a valid window and defaults to the selected one.
869 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
870 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
871 0 at top left corner of frame.
873 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
874 is one more than the bottommost row occupied by WINDOW. The edges
875 include the space used by WINDOW's scroll bar, display margins, fringes,
876 header line, and/or mode line. For the edges of just the text area, use
877 `window-inside-edges'. */)
880 register struct window
*w
= decode_valid_window (window
);
882 return quad (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
883 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
886 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
887 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
888 WINDOW must be a valid window and defaults to the selected one.
890 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
891 0, 0 at the top left corner of the frame.
893 RIGHT is one more than the rightmost x position occupied by WINDOW.
894 BOTTOM is one more than the bottommost y position occupied by WINDOW.
895 The pixel edges include the space used by WINDOW's scroll bar, display
896 margins, fringes, header line, and/or mode line. For the pixel edges
897 of just the text area, use `window-inside-pixel-edges'. */)
900 register struct window
*w
= decode_valid_window (window
);
902 return quad (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
903 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
907 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
909 struct frame
*f
= XFRAME (w
->frame
);
911 #ifdef FRAME_MENUBAR_HEIGHT
912 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
914 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
915 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
916 #elif FRAME_TOOLBAR_HEIGHT
917 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
919 #ifdef FRAME_NS_TITLEBAR_HEIGHT
920 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
922 *add_x
= f
->left_pos
;
923 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
924 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
928 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
929 Swindow_absolute_pixel_edges
, 0, 1, 0,
930 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
931 WINDOW must be a valid window and defaults to the selected one.
933 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
934 0, 0 at the top left corner of the display.
936 RIGHT is one more than the rightmost x position occupied by WINDOW.
937 BOTTOM is one more than the bottommost y position occupied by WINDOW.
938 The pixel edges include the space used by WINDOW's scroll bar, display
939 margins, fringes, header line, and/or mode line. For the pixel edges
940 of just the text area, use `window-inside-absolute-pixel-edges'. */)
943 register struct window
*w
= decode_valid_window (window
);
946 calc_absolute_offset (w
, &add_x
, &add_y
);
948 return quad (WINDOW_LEFT_EDGE_X (w
) + add_x
,
949 WINDOW_TOP_EDGE_Y (w
) + add_y
,
950 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
951 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
954 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
955 doc
: /* Return a list of the edge coordinates of WINDOW.
956 WINDOW must be a live window and defaults to the selected one.
958 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
959 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
960 0 at top left corner of frame.
962 RIGHT is one more than the rightmost column of WINDOW's text area.
963 BOTTOM is one more than the bottommost row of WINDOW's text area. The
964 inside edges do not include the space used by the WINDOW's scroll bar,
965 display margins, fringes, header line, and/or mode line. */)
968 register struct window
*w
= decode_live_window (window
);
970 return quad (WINDOW_BOX_LEFT_EDGE_COL (w
)
971 + WINDOW_LEFT_MARGIN_COLS (w
)
972 + WINDOW_LEFT_FRINGE_COLS (w
),
973 WINDOW_TOP_EDGE_LINE (w
)
974 + WINDOW_HEADER_LINE_LINES (w
),
975 WINDOW_BOX_RIGHT_EDGE_COL (w
)
976 - WINDOW_RIGHT_MARGIN_COLS (w
)
977 - WINDOW_RIGHT_FRINGE_COLS (w
),
978 WINDOW_BOTTOM_EDGE_LINE (w
)
979 - WINDOW_MODE_LINE_LINES (w
));
982 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
983 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
984 WINDOW must be a live window and defaults to the selected one.
986 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
987 (0,0) at the top left corner of the frame's window area.
989 RIGHT is one more than the rightmost x position of WINDOW's text area.
990 BOTTOM is one more than the bottommost y position of WINDOW's text area.
991 The inside edges do not include the space used by WINDOW's scroll bar,
992 display margins, fringes, header line, and/or mode line. */)
995 register struct window
*w
= decode_live_window (window
);
997 return quad (WINDOW_BOX_LEFT_EDGE_X (w
)
998 + WINDOW_LEFT_MARGIN_WIDTH (w
)
999 + WINDOW_LEFT_FRINGE_WIDTH (w
),
1000 WINDOW_TOP_EDGE_Y (w
)
1001 + WINDOW_HEADER_LINE_HEIGHT (w
),
1002 WINDOW_BOX_RIGHT_EDGE_X (w
)
1003 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1004 - WINDOW_RIGHT_FRINGE_WIDTH (w
),
1005 WINDOW_BOTTOM_EDGE_Y (w
)
1006 - WINDOW_MODE_LINE_HEIGHT (w
));
1009 DEFUN ("window-inside-absolute-pixel-edges",
1010 Fwindow_inside_absolute_pixel_edges
,
1011 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1012 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1013 WINDOW must be a live window and defaults to the selected one.
1015 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1016 (0,0) at the top left corner of the frame's window area.
1018 RIGHT is one more than the rightmost x position of WINDOW's text area.
1019 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1020 The inside edges do not include the space used by WINDOW's scroll bar,
1021 display margins, fringes, header line, and/or mode line. */)
1022 (Lisp_Object window
)
1024 register struct window
*w
= decode_live_window (window
);
1027 calc_absolute_offset (w
, &add_x
, &add_y
);
1029 return quad (WINDOW_BOX_LEFT_EDGE_X (w
)
1030 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1031 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
,
1032 WINDOW_TOP_EDGE_Y (w
)
1033 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
,
1034 WINDOW_BOX_RIGHT_EDGE_X (w
)
1035 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1036 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
,
1037 WINDOW_BOTTOM_EDGE_Y (w
)
1038 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
);
1041 /* Test if the character at column X, row Y is within window W.
1042 If it is not, return ON_NOTHING;
1043 if it is in the window's text area, return ON_TEXT;
1044 if it is on the window's modeline, return ON_MODE_LINE;
1045 if it is on the border between the window and its right sibling,
1046 return ON_VERTICAL_BORDER.
1047 if it is on a scroll bar, return ON_SCROLL_BAR.
1048 if it is on the window's top line, return ON_HEADER_LINE;
1049 if it is in left or right fringe of the window,
1050 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1051 if it is in the marginal area to the left/right of the window,
1052 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1054 X and Y are frame relative pixel coordinates. */
1056 static enum window_part
1057 coordinates_in_window (register struct window
*w
, int x
, int y
)
1059 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1060 enum window_part part
;
1061 int ux
= FRAME_COLUMN_WIDTH (f
);
1062 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1063 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1064 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1065 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1066 /* The width of the area where the vertical line can be dragged.
1067 (Between mode lines for instance. */
1068 int grabbable_width
= ux
;
1069 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1071 /* Outside any interesting row or column? */
1072 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1075 /* On the mode line or header line? */
1076 if ((WINDOW_WANTS_MODELINE_P (w
)
1077 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1078 && (part
= ON_MODE_LINE
))
1079 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1080 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1081 && (part
= ON_HEADER_LINE
)))
1083 /* If it's under/over the scroll bar portion of the mode/header
1084 line, say it's on the vertical line. That's to be able to
1085 resize windows horizontally in case we're using toolkit scroll
1086 bars. Note: If scrollbars are on the left, the window that
1087 must be eventually resized is that on the left of WINDOW. */
1088 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1089 && !WINDOW_LEFTMOST_P (w
)
1090 && eabs (x
- left_x
) < grabbable_width
)
1091 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1092 && !WINDOW_RIGHTMOST_P (w
)
1093 && eabs (x
- right_x
) < grabbable_width
))
1094 return ON_VERTICAL_BORDER
;
1099 /* In what's below, we subtract 1 when computing right_x because we
1100 want the rightmost pixel, which is given by left_pixel+width-1. */
1101 if (w
->pseudo_window_p
)
1104 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1108 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1109 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1112 /* Outside any interesting column? */
1113 if (x
< left_x
|| x
> right_x
)
1114 return ON_SCROLL_BAR
;
1116 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1117 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1119 text_left
= window_box_left (w
, TEXT_AREA
);
1120 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1122 if (FRAME_WINDOW_P (f
))
1124 if (!w
->pseudo_window_p
1125 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1126 && !WINDOW_RIGHTMOST_P (w
)
1127 && (eabs (x
- right_x
) < grabbable_width
))
1128 return ON_VERTICAL_BORDER
;
1130 /* Need to say "x > right_x" rather than >=, since on character
1131 terminals, the vertical line's x coordinate is right_x. */
1132 else if (!w
->pseudo_window_p
1133 && !WINDOW_RIGHTMOST_P (w
)
1134 && x
> right_x
- ux
)
1135 return ON_VERTICAL_BORDER
;
1139 if (lmargin_width
> 0
1140 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1141 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1142 : (x
< left_x
+ lmargin_width
)))
1143 return ON_LEFT_MARGIN
;
1145 return ON_LEFT_FRINGE
;
1148 if (x
>= text_right
)
1150 if (rmargin_width
> 0
1151 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1152 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1153 : (x
>= right_x
- rmargin_width
)))
1154 return ON_RIGHT_MARGIN
;
1156 return ON_RIGHT_FRINGE
;
1159 /* Everything special ruled out - must be on text area */
1163 /* Take X is the frame-relative pixel x-coordinate, and return the
1164 x-coordinate relative to part PART of window W. */
1166 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1168 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1173 return x
- window_box_left (w
, TEXT_AREA
);
1175 case ON_LEFT_FRINGE
:
1178 case ON_RIGHT_FRINGE
:
1179 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1181 case ON_LEFT_MARGIN
:
1183 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1184 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1186 case ON_RIGHT_MARGIN
:
1188 - ((w
->pseudo_window_p
)
1189 ? WINDOW_TOTAL_WIDTH (w
)
1190 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1191 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1192 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1193 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1196 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1201 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1202 Scoordinates_in_window_p
, 2, 2, 0,
1203 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1204 WINDOW must be a live window and defaults to the selected one.
1205 COORDINATES is a cons of the form (X . Y), X and Y being distances
1206 measured in characters from the upper-left corner of the frame.
1207 \(0 . 0) denotes the character in the upper left corner of the
1209 If COORDINATES are in the text portion of WINDOW,
1210 the coordinates relative to the window are returned.
1211 If they are in the mode line of WINDOW, `mode-line' is returned.
1212 If they are in the top mode line of WINDOW, `header-line' is returned.
1213 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1214 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1215 If they are on the border between WINDOW and its right sibling,
1216 `vertical-line' is returned.
1217 If they are in the windows's left or right marginal areas, `left-margin'\n\
1218 or `right-margin' is returned. */)
1219 (register Lisp_Object coordinates
, Lisp_Object window
)
1226 w
= decode_live_window (window
);
1227 f
= XFRAME (w
->frame
);
1228 CHECK_CONS (coordinates
);
1229 lx
= Fcar (coordinates
);
1230 ly
= Fcdr (coordinates
);
1231 CHECK_NUMBER_OR_FLOAT (lx
);
1232 CHECK_NUMBER_OR_FLOAT (ly
);
1233 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1234 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1236 switch (coordinates_in_window (w
, x
, y
))
1242 /* Convert X and Y to window relative pixel coordinates, and
1243 return the canonical char units. */
1244 x
-= window_box_left (w
, TEXT_AREA
);
1245 y
-= WINDOW_TOP_EDGE_Y (w
);
1246 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1247 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1252 case ON_VERTICAL_BORDER
:
1253 return Qvertical_line
;
1255 case ON_HEADER_LINE
:
1256 return Qheader_line
;
1258 case ON_LEFT_FRINGE
:
1259 return Qleft_fringe
;
1261 case ON_RIGHT_FRINGE
:
1262 return Qright_fringe
;
1264 case ON_LEFT_MARGIN
:
1265 return Qleft_margin
;
1267 case ON_RIGHT_MARGIN
:
1268 return Qright_margin
;
1271 /* Historically we are supposed to return nil in this case. */
1280 /* Callback for foreach_window, used in window_from_coordinates.
1281 Check if window W contains coordinates specified by USER_DATA which
1282 is actually a pointer to a struct check_window_data CW.
1284 Check if window W contains coordinates *CW->x and *CW->y. If it
1285 does, return W in *CW->window, as Lisp_Object, and return in
1286 *CW->part the part of the window under coordinates *X,*Y. Return
1287 zero from this function to stop iterating over windows. */
1289 struct check_window_data
1291 Lisp_Object
*window
;
1293 enum window_part
*part
;
1297 check_window_containing (struct window
*w
, void *user_data
)
1299 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1300 enum window_part found
;
1303 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1304 if (found
!= ON_NOTHING
)
1307 XSETWINDOW (*cw
->window
, w
);
1315 /* Find the window containing frame-relative pixel position X/Y and
1316 return it as a Lisp_Object.
1318 If X, Y is on one of the window's special `window_part' elements,
1319 set *PART to the id of that element.
1321 If there is no window under X, Y return nil and leave *PART
1322 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1324 This function was previously implemented with a loop cycling over
1325 windows with Fnext_window, and starting with the frame's selected
1326 window. It turned out that this doesn't work with an
1327 implementation of next_window using Vwindow_list, because
1328 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1329 tree of F when this function is called asynchronously from
1330 note_mouse_highlight. The original loop didn't terminate in this
1334 window_from_coordinates (struct frame
*f
, int x
, int y
,
1335 enum window_part
*part
, int tool_bar_p
)
1338 struct check_window_data cw
;
1339 enum window_part dummy
;
1345 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1346 foreach_window (f
, check_window_containing
, &cw
);
1348 /* If not found above, see if it's in the tool bar window, if a tool
1352 && WINDOWP (f
->tool_bar_window
)
1353 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1354 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1358 window
= f
->tool_bar_window
;
1364 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1365 doc
: /* Return window containing coordinates X and Y on FRAME.
1366 FRAME must be a live frame and defaults to the selected one.
1367 The top left corner of the frame is considered to be row 0,
1369 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1371 struct frame
*f
= decode_live_frame (frame
);
1373 /* Check that arguments are integers or floats. */
1374 CHECK_NUMBER_OR_FLOAT (x
);
1375 CHECK_NUMBER_OR_FLOAT (y
);
1377 return window_from_coordinates (f
,
1378 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1379 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1380 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1381 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1385 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1386 doc
: /* Return current value of point in WINDOW.
1387 WINDOW must be a live window and defaults to the selected one.
1389 For a nonselected window, this is the value point would have if that
1390 window were selected.
1392 Note that, when WINDOW is selected, the value returned is the same as
1393 that returned by `point' for WINDOW's buffer. It would be more strictly
1394 correct to return the `top-level' value of `point', outside of any
1395 `save-excursion' forms. But that is hard to define. */)
1396 (Lisp_Object window
)
1398 register struct window
*w
= decode_live_window (window
);
1400 if (w
== XWINDOW (selected_window
))
1401 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1403 return Fmarker_position (w
->pointm
);
1406 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1407 doc
: /* Return position at which display currently starts in WINDOW.
1408 WINDOW must be a live window and defaults to the selected one.
1409 This is updated by redisplay or by calling `set-window-start'. */)
1410 (Lisp_Object window
)
1412 return Fmarker_position (decode_live_window (window
)->start
);
1415 /* This is text temporarily removed from the doc string below.
1417 This function returns nil if the position is not currently known.
1418 That happens when redisplay is preempted and doesn't finish.
1419 If in that case you want to compute where the end of the window would
1420 have been if redisplay had finished, do this:
1422 (goto-char (window-start window))
1423 (vertical-motion (1- (window-height window)) window)
1426 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1427 doc
: /* Return position at which display currently ends in WINDOW.
1428 WINDOW must be a live window and defaults to the selected one.
1429 This is updated by redisplay, when it runs to completion.
1430 Simply changing the buffer text or setting `window-start'
1431 does not update this value.
1432 Return nil if there is no recorded value. (This can happen if the
1433 last redisplay of WINDOW was preempted, and did not finish.)
1434 If UPDATE is non-nil, compute the up-to-date position
1435 if it isn't already recorded. */)
1436 (Lisp_Object window
, Lisp_Object update
)
1439 struct window
*w
= decode_live_window (window
);
1447 #if 0 /* This change broke some things. We should make it later. */
1448 /* If we don't know the end position, return nil.
1449 The user can compute it with vertical-motion if he wants to.
1450 It would be nicer to do it automatically,
1451 but that's so slow that it would probably bother people. */
1452 if (NILP (w
->window_end_valid
))
1457 && (windows_or_buffers_changed
|| NILP (w
->window_end_valid
))
1460 struct text_pos startp
;
1462 struct buffer
*old_buffer
= NULL
;
1463 void *itdata
= NULL
;
1465 /* Cannot use Fvertical_motion because that function doesn't
1466 cope with variable-height lines. */
1467 if (b
!= current_buffer
)
1469 old_buffer
= current_buffer
;
1470 set_buffer_internal (b
);
1473 /* In case W->start is out of the range, use something
1474 reasonable. This situation occurred when loading a file with
1475 `-l' containing a call to `rmail' with subsequent other
1476 commands. At the end, W->start happened to be BEG, while
1477 rmail had already narrowed the buffer. */
1478 if (XMARKER (w
->start
)->charpos
< BEGV
)
1479 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1480 else if (XMARKER (w
->start
)->charpos
> ZV
)
1481 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1483 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1485 itdata
= bidi_shelve_cache ();
1486 start_display (&it
, w
, startp
);
1487 move_it_vertically (&it
, window_box_height (w
));
1488 if (it
.current_y
< it
.last_visible_y
)
1489 move_it_past_eol (&it
);
1490 value
= make_number (IT_CHARPOS (it
));
1491 bidi_unshelve_cache (itdata
, 0);
1494 set_buffer_internal (old_buffer
);
1497 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1502 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1503 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1504 WINDOW must be a live window and defaults to the selected one.
1506 (Lisp_Object window
, Lisp_Object pos
)
1508 register struct window
*w
= decode_live_window (window
);
1510 CHECK_NUMBER_COERCE_MARKER (pos
);
1512 if (w
== XWINDOW (selected_window
))
1514 if (XBUFFER (w
->buffer
) == current_buffer
)
1518 struct buffer
*old_buffer
= current_buffer
;
1520 set_buffer_internal (XBUFFER (w
->buffer
));
1522 set_buffer_internal (old_buffer
);
1527 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1528 /* We have to make sure that redisplay updates the window to show
1529 the new value of point. */
1530 ++windows_or_buffers_changed
;
1536 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1537 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1538 WINDOW must be a live window and defaults to the selected one. Return
1539 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1540 overriding motion of point in order to display at this exact start. */)
1541 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1543 register struct window
*w
= decode_live_window (window
);
1545 CHECK_NUMBER_COERCE_MARKER (pos
);
1546 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1547 /* this is not right, but much easier than doing what is right. */
1548 w
->start_at_line_beg
= 0;
1551 w
->update_mode_line
= 1;
1552 w
->last_modified
= 0;
1553 w
->last_overlay_modified
= 0;
1554 if (!EQ (window
, selected_window
))
1555 windows_or_buffers_changed
++;
1560 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1561 Spos_visible_in_window_p
, 0, 3, 0,
1562 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1563 WINDOW must be a live window and defaults to the selected one.
1565 Return nil if that position is scrolled vertically out of view. If a
1566 character is only partially visible, nil is returned, unless the
1567 optional argument PARTIALLY is non-nil. If POS is only out of view
1568 because of horizontal scrolling, return non-nil. If POS is t, it
1569 specifies the position of the last visible glyph in WINDOW. POS
1570 defaults to point in WINDOW; WINDOW defaults to the selected window.
1572 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1573 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1574 where X and Y are the pixel coordinates relative to the top left corner
1575 of the window. The remaining elements are omitted if the character after
1576 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1577 off-window at the top and bottom of the row, ROWH is the height of the
1578 display row, and VPOS is the row number (0-based) containing POS. */)
1579 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1581 register struct window
*w
;
1582 register EMACS_INT posint
;
1583 register struct buffer
*buf
;
1584 struct text_pos top
;
1585 Lisp_Object in_window
= Qnil
;
1586 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1589 w
= decode_live_window (window
);
1590 buf
= XBUFFER (w
->buffer
);
1591 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1595 else if (!NILP (pos
))
1597 CHECK_NUMBER_COERCE_MARKER (pos
);
1598 posint
= XINT (pos
);
1600 else if (w
== XWINDOW (selected_window
))
1603 posint
= XMARKER (w
->pointm
)->charpos
;
1605 /* If position is above window start or outside buffer boundaries,
1606 or if window start is out of range, position is not visible. */
1608 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1609 && CHARPOS (top
) >= BUF_BEGV (buf
)
1610 && CHARPOS (top
) <= BUF_ZV (buf
)
1611 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1612 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1615 if (!NILP (in_window
) && !NILP (partially
))
1617 Lisp_Object part
= Qnil
;
1619 part
= quad (rtop
, rbot
, rowh
, vpos
);
1620 in_window
= Fcons (make_number (x
),
1621 Fcons (make_number (y
), part
));
1627 DEFUN ("window-line-height", Fwindow_line_height
,
1628 Swindow_line_height
, 0, 2, 0,
1629 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1630 WINDOW must be a live window and defaults to the selected one.
1632 Return height of current line if LINE is omitted or nil. Return height of
1633 header or mode line if LINE is `header-line' or `mode-line'.
1634 Otherwise, LINE is a text line number starting from 0. A negative number
1635 counts from the end of the window.
1637 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1638 in pixels of the visible part of the line, VPOS and YPOS are the
1639 vertical position in lines and pixels of the line, relative to the top
1640 of the first text line, and OFFBOT is the number of off-window pixels at
1641 the bottom of the text line. If there are off-window pixels at the top
1642 of the (first) text line, YPOS is negative.
1644 Return nil if window display is not up-to-date. In that case, use
1645 `pos-visible-in-window-p' to obtain the information. */)
1646 (Lisp_Object line
, Lisp_Object window
)
1648 register struct window
*w
;
1649 register struct buffer
*b
;
1650 struct glyph_row
*row
, *end_row
;
1654 w
= decode_live_window (window
);
1656 if (noninteractive
|| w
->pseudo_window_p
)
1659 CHECK_BUFFER (w
->buffer
);
1660 b
= XBUFFER (w
->buffer
);
1662 /* Fail if current matrix is not up-to-date. */
1663 if (NILP (w
->window_end_valid
)
1664 || current_buffer
->clip_changed
1665 || current_buffer
->prevent_redisplay_optimizations_p
1666 || w
->last_modified
< BUF_MODIFF (b
)
1667 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1673 if (i
< 0 || i
>= w
->current_matrix
->nrows
1674 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1676 max_y
= window_text_bottom_y (w
);
1680 if (EQ (line
, Qheader_line
))
1682 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1684 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1685 return row
->enabled_p
? quad (row
->height
, 0, 0, 0) : Qnil
;
1688 if (EQ (line
, Qmode_line
))
1690 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1691 return (row
->enabled_p
?
1693 0, /* not accurate */
1694 WINDOW_HEADER_LINE_HEIGHT (w
)
1695 + window_text_bottom_y (w
), 0)
1699 CHECK_NUMBER (line
);
1702 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1703 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1704 max_y
= window_text_bottom_y (w
);
1707 while ((n
< 0 || i
< n
)
1708 && row
<= end_row
&& row
->enabled_p
1709 && row
->y
+ row
->height
< max_y
)
1712 if (row
> end_row
|| !row
->enabled_p
)
1724 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1725 return quad (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1728 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1730 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1731 More precisely, return the value assigned by the last call of
1732 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1733 never called with WINDOW as its argument, or the value set by that
1734 function was internally reset since its last call. WINDOW must be a
1735 live window and defaults to the selected one.
1737 When a window is dedicated to its buffer, `display-buffer' will refrain
1738 from displaying another buffer in it. `get-lru-window' and
1739 `get-largest-window' treat dedicated windows specially.
1740 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1741 `kill-buffer' can delete a dedicated window and the containing frame.
1743 Functions like `set-window-buffer' may change the buffer displayed by a
1744 window, unless that window is "strongly" dedicated to its buffer, that
1745 is the value returned by `window-dedicated-p' is t. */)
1746 (Lisp_Object window
)
1748 return decode_live_window (window
)->dedicated
;
1751 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1752 Sset_window_dedicated_p
, 2, 2, 0,
1753 doc
: /* Mark WINDOW as dedicated according to FLAG.
1754 WINDOW must be a live window and defaults to the selected one. FLAG
1755 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1756 mark WINDOW as non-dedicated. Return FLAG.
1758 When a window is dedicated to its buffer, `display-buffer' will refrain
1759 from displaying another buffer in it. `get-lru-window' and
1760 `get-largest-window' treat dedicated windows specially.
1761 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1762 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1763 and the containing frame.
1765 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1766 its buffer. Functions like `set-window-buffer' may change the buffer
1767 displayed by a window, unless that window is strongly dedicated to its
1768 buffer. If and when `set-window-buffer' displays another buffer in a
1769 window, it also makes sure that the window is no more dedicated. */)
1770 (Lisp_Object window
, Lisp_Object flag
)
1772 wset_dedicated (decode_live_window (window
), flag
);
1776 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1778 doc
: /* Return buffers previously shown in WINDOW.
1779 WINDOW must be a live window and defaults to the selected one.
1781 The return value is a list of elements (BUFFER WINDOW-START POS),
1782 where BUFFER is a buffer, WINDOW-START is the start position of the
1783 window for that buffer, and POS is a window-specific point value. */)
1784 (Lisp_Object window
)
1786 return decode_live_window (window
)->prev_buffers
;
1789 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1790 Sset_window_prev_buffers
, 2, 2, 0,
1791 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1792 WINDOW must be a live window and defaults to the selected one.
1794 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1795 where BUFFER is a buffer, WINDOW-START is the start position of the
1796 window for that buffer, and POS is a window-specific point value. */)
1797 (Lisp_Object window
, Lisp_Object prev_buffers
)
1799 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1800 return prev_buffers
;
1803 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1805 doc
: /* Return list of buffers recently re-shown in WINDOW.
1806 WINDOW must be a live window and defaults to the selected one. */)
1807 (Lisp_Object window
)
1809 return decode_live_window (window
)->next_buffers
;
1812 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1813 Sset_window_next_buffers
, 2, 2, 0,
1814 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1815 WINDOW must be a live window and defaults to the selected one.
1816 NEXT-BUFFERS should be a list of buffers. */)
1817 (Lisp_Object window
, Lisp_Object next_buffers
)
1819 wset_next_buffers (decode_live_window (window
), next_buffers
);
1820 return next_buffers
;
1823 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1825 doc
: /* Return the parameters of WINDOW and their values.
1826 WINDOW must be a valid window and defaults to the selected one. The
1827 return value is a list of elements of the form (PARAMETER . VALUE). */)
1828 (Lisp_Object window
)
1830 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1833 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1835 doc
: /* Return WINDOW's value for PARAMETER.
1836 WINDOW can be any window and defaults to the selected one. */)
1837 (Lisp_Object window
, Lisp_Object parameter
)
1841 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1842 return CDR_SAFE (result
);
1845 DEFUN ("set-window-parameter", Fset_window_parameter
,
1846 Sset_window_parameter
, 3, 3, 0,
1847 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1848 WINDOW can be any window and defaults to the selected one.
1850 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1852 register struct window
*w
= decode_any_window (window
);
1853 Lisp_Object old_alist_elt
;
1855 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1856 if (NILP (old_alist_elt
))
1857 wset_window_parameters
1858 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1860 Fsetcdr (old_alist_elt
, value
);
1864 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1866 doc
: /* Return the display-table that WINDOW is using.
1867 WINDOW must be a live window and defaults to the selected one. */)
1868 (Lisp_Object window
)
1870 return decode_live_window (window
)->display_table
;
1873 /* Get the display table for use on window W. This is either W's
1874 display table or W's buffer's display table. Ignore the specified
1875 tables if they are not valid; if no valid table is specified,
1878 struct Lisp_Char_Table
*
1879 window_display_table (struct window
*w
)
1881 struct Lisp_Char_Table
*dp
= NULL
;
1883 if (DISP_TABLE_P (w
->display_table
))
1884 dp
= XCHAR_TABLE (w
->display_table
);
1885 else if (BUFFERP (w
->buffer
))
1887 struct buffer
*b
= XBUFFER (w
->buffer
);
1889 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1890 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1891 else if (DISP_TABLE_P (Vstandard_display_table
))
1892 dp
= XCHAR_TABLE (Vstandard_display_table
);
1898 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1899 doc
: /* Set WINDOW's display-table to TABLE.
1900 WINDOW must be a live window and defaults to the selected one. */)
1901 (register Lisp_Object window
, Lisp_Object table
)
1903 wset_display_table (decode_live_window (window
), table
);
1907 /* Record info on buffer window W is displaying
1908 when it is about to cease to display that buffer. */
1910 unshow_buffer (register struct window
*w
)
1917 if (b
!= XMARKER (w
->pointm
)->buffer
)
1921 if (w
== XWINDOW (selected_window
)
1922 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1923 /* Do this except when the selected window's buffer
1924 is being removed from some other window. */
1926 /* last_window_start records the start position that this buffer
1927 had in the last window to be disconnected from it.
1928 Now that this statement is unconditional,
1929 it is possible for the buffer to be displayed in the
1930 selected window, while last_window_start reflects another
1931 window which was recently showing the same buffer.
1932 Some people might say that might be a good thing. Let's see. */
1933 b
->last_window_start
= marker_position (w
->start
);
1935 /* Point in the selected window's buffer
1936 is actually stored in that buffer, and the window's pointm isn't used.
1937 So don't clobber point in that buffer. */
1938 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1939 /* Don't clobber point in current buffer either (this could be
1940 useful in connection with bug#12208).
1941 && XBUFFER (buf) != current_buffer */
1942 /* This line helps to fix Horsley's testbug.el bug. */
1943 && !(WINDOWP (BVAR (b
, last_selected_window
))
1944 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1945 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1946 temp_set_point_both (b
,
1947 clip_to_bounds (BUF_BEGV (b
),
1948 XMARKER (w
->pointm
)->charpos
,
1950 clip_to_bounds (BUF_BEGV_BYTE (b
),
1951 marker_byte_position (w
->pointm
),
1954 if (WINDOWP (BVAR (b
, last_selected_window
))
1955 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1956 bset_last_selected_window (b
, Qnil
);
1959 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1960 means change window structure only. Otherwise store geometry and
1961 other settings as well. */
1963 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1965 register Lisp_Object tem
;
1966 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1968 /* If OLD is its frame's root window, then NEW is the new
1969 root window for that frame. */
1970 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1971 fset_root_window (XFRAME (o
->frame
), new);
1975 wset_left_col (n
, o
->left_col
);
1976 wset_top_line (n
, o
->top_line
);
1977 wset_total_cols (n
, o
->total_cols
);
1978 wset_total_lines (n
, o
->total_lines
);
1979 wset_normal_cols (n
, o
->normal_cols
);
1980 wset_normal_cols (o
, make_float (1.0));
1981 wset_normal_lines (n
, o
->normal_lines
);
1982 wset_normal_lines (o
, make_float (1.0));
1983 n
->desired_matrix
= n
->current_matrix
= 0;
1985 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1986 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1987 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1988 n
->phys_cursor_type
= -1;
1989 n
->phys_cursor_width
= -1;
1990 n
->must_be_updated_p
= 0;
1991 n
->pseudo_window_p
= 0;
1992 wset_window_end_vpos (n
, make_number (0));
1993 wset_window_end_pos (n
, make_number (0));
1994 wset_window_end_valid (n
, Qnil
);
1995 n
->frozen_window_start_p
= 0;
2001 wset_prev (XWINDOW (tem
), new);
2006 wset_next (XWINDOW (tem
), new);
2009 wset_parent (n
, tem
);
2012 if (EQ (XWINDOW (tem
)->vchild
, old
))
2013 wset_vchild (XWINDOW (tem
), new);
2014 if (EQ (XWINDOW (tem
)->hchild
, old
))
2015 wset_hchild (XWINDOW (tem
), new);
2019 /* If window WINDOW and its parent window are iso-combined, merge
2020 WINDOW's children into those of its parent window and mark WINDOW as
2024 recombine_windows (Lisp_Object window
)
2026 struct window
*w
, *p
, *c
;
2027 Lisp_Object parent
, child
;
2030 w
= XWINDOW (window
);
2032 if (!NILP (parent
) && NILP (w
->combination_limit
))
2034 p
= XWINDOW (parent
);
2035 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2036 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2037 /* WINDOW and PARENT are both either a vertical or a horizontal
2040 horflag
= NILP (w
->vchild
);
2041 child
= horflag
? w
->hchild
: w
->vchild
;
2042 c
= XWINDOW (child
);
2044 /* Splice WINDOW's children into its parent's children and
2045 assign new normal sizes. */
2048 wset_hchild (p
, child
);
2050 wset_vchild (p
, child
);
2053 wset_prev (c
, w
->prev
);
2054 wset_next (XWINDOW (w
->prev
), child
);
2059 wset_parent (c
, parent
);
2062 wset_normal_cols (c
,
2063 make_float (XFLOATINT (c
->total_cols
)
2064 / XFLOATINT (p
->total_cols
)));
2066 wset_normal_lines (c
,
2067 make_float (XFLOATINT (c
->total_lines
)
2068 / XFLOATINT (p
->total_lines
)));
2072 if (!NILP (w
->next
))
2074 wset_next (c
, w
->next
);
2075 wset_prev (XWINDOW (c
->next
), child
);
2083 c
= XWINDOW (child
);
2087 /* WINDOW can be deleted now. */
2088 wset_vchild (w
, Qnil
);
2089 wset_hchild (w
, Qnil
);
2094 /* If WINDOW can be deleted, delete it. */
2096 delete_deletable_window (Lisp_Object window
)
2098 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2099 call1 (Qdelete_window
, window
);
2102 /***********************************************************************
2104 ***********************************************************************/
2106 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2107 pointer. This is a callback function for foreach_window, used in
2108 the window_list function. */
2111 add_window_to_list (struct window
*w
, void *user_data
)
2113 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2115 XSETWINDOW (window
, w
);
2116 *list
= Fcons (window
, *list
);
2121 /* Return a list of all windows, for use by next_window. If
2122 Vwindow_list is a list, return that list. Otherwise, build a new
2123 list, cache it in Vwindow_list, and return that. */
2128 if (!CONSP (Vwindow_list
))
2132 Vwindow_list
= Qnil
;
2133 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
2135 Lisp_Object args
[2];
2137 /* We are visiting windows in canonical order, and add
2138 new windows at the front of args[1], which means we
2139 have to reverse this list at the end. */
2141 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
2142 args
[0] = Vwindow_list
;
2143 args
[1] = Fnreverse (args
[1]);
2144 Vwindow_list
= Fnconc (2, args
);
2148 return Vwindow_list
;
2152 /* Value is non-zero if WINDOW satisfies the constraints given by
2153 OWINDOW, MINIBUF and ALL_FRAMES.
2155 MINIBUF t means WINDOW may be minibuffer windows.
2156 `lambda' means WINDOW may not be a minibuffer window.
2157 a window means a specific minibuffer window
2159 ALL_FRAMES t means search all frames,
2160 nil means search just current frame,
2161 `visible' means search just visible frames on the
2163 0 means search visible and iconified frames on the
2165 a window means search the frame that window belongs to,
2166 a frame means consider windows on that frame, only. */
2169 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2171 struct window
*w
= XWINDOW (window
);
2172 struct frame
*f
= XFRAME (w
->frame
);
2173 int candidate_p
= 1;
2175 if (!BUFFERP (w
->buffer
))
2177 else if (MINI_WINDOW_P (w
)
2178 && (EQ (minibuf
, Qlambda
)
2179 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2181 /* If MINIBUF is `lambda' don't consider any mini-windows.
2182 If it is a window, consider only that one. */
2185 else if (EQ (all_frames
, Qt
))
2187 else if (NILP (all_frames
))
2189 eassert (WINDOWP (owindow
));
2190 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2192 else if (EQ (all_frames
, Qvisible
))
2194 FRAME_SAMPLE_VISIBILITY (f
);
2195 candidate_p
= FRAME_VISIBLE_P (f
)
2196 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2197 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2200 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2202 FRAME_SAMPLE_VISIBILITY (f
);
2203 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2204 #ifdef HAVE_X_WINDOWS
2205 /* Yuck!! If we've just created the frame and the
2206 window-manager requested the user to place it
2207 manually, the window may still not be considered
2208 `visible'. I'd argue it should be at least
2209 something like `iconified', but don't know how to do
2211 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2212 && !f
->output_data
.x
->has_been_visible
)
2215 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2216 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2218 else if (WINDOWP (all_frames
))
2219 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2220 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2221 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2222 else if (FRAMEP (all_frames
))
2223 candidate_p
= EQ (all_frames
, w
->frame
);
2229 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2230 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2231 MINIBUF, and ALL_FRAMES. */
2234 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2236 struct window
*w
= decode_live_window (*window
);
2238 XSETWINDOW (*window
, w
);
2239 /* MINIBUF nil may or may not include minibuffers. Decide if it
2241 if (NILP (*minibuf
))
2242 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2243 else if (!EQ (*minibuf
, Qt
))
2246 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2247 => count none of them, or a specific minibuffer window (the
2248 active one) to count. */
2250 /* ALL_FRAMES nil doesn't specify which frames to include. */
2251 if (NILP (*all_frames
))
2253 = (!EQ (*minibuf
, Qlambda
)
2254 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2256 else if (EQ (*all_frames
, Qvisible
))
2258 else if (EQ (*all_frames
, make_number (0)))
2260 else if (FRAMEP (*all_frames
))
2262 else if (!EQ (*all_frames
, Qt
))
2267 /* Return the next or previous window of WINDOW in cyclic ordering
2268 of windows. NEXT_P non-zero means return the next window. See the
2269 documentation string of next-window for the meaning of MINIBUF and
2273 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2275 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2277 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2278 return the first window on the frame. */
2279 if (FRAMEP (all_frames
)
2280 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2281 return Fframe_first_window (all_frames
);
2287 /* Find WINDOW in the list of all windows. */
2288 list
= Fmemq (window
, window_list ());
2290 /* Scan forward from WINDOW to the end of the window list. */
2292 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2293 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2296 /* Scan from the start of the window list up to WINDOW. */
2298 for (list
= Vwindow_list
;
2299 CONSP (list
) && !EQ (XCAR (list
), window
);
2301 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2305 window
= XCAR (list
);
2309 Lisp_Object candidate
, list
;
2311 /* Scan through the list of windows for candidates. If there are
2312 candidate windows in front of WINDOW, the last one of these
2313 is the one we want. If there are candidates following WINDOW
2314 in the list, again the last one of these is the one we want. */
2316 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2318 if (EQ (XCAR (list
), window
))
2320 if (WINDOWP (candidate
))
2323 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2325 candidate
= XCAR (list
);
2328 if (WINDOWP (candidate
))
2336 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2337 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2338 WINDOW must be a live window and defaults to the selected one. The
2339 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2342 MINIBUF nil or omitted means consider the minibuffer window only if the
2343 minibuffer is active. MINIBUF t means consider the minibuffer window
2344 even if the minibuffer is not active. Any other value means do not
2345 consider the minibuffer window even if the minibuffer is active.
2347 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2348 plus the minibuffer window if specified by the MINIBUF argument. If the
2349 minibuffer counts, consider all windows on all frames that share that
2350 minibuffer too. The following non-nil values of ALL-FRAMES have special
2353 - t means consider all windows on all existing frames.
2355 - `visible' means consider all windows on all visible frames.
2357 - 0 (the number zero) means consider all windows on all visible and
2360 - A frame means consider all windows on that frame only.
2362 Anything else means consider all windows on WINDOW's frame and no
2365 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2366 `next-window' to iterate through the entire cycle of acceptable
2367 windows, eventually ending up back at the window you started with.
2368 `previous-window' traverses the same cycle, in the reverse order. */)
2369 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2371 return next_window (window
, minibuf
, all_frames
, 1);
2375 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2376 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2377 WINDOW must be a live window and defaults to the selected one. The
2378 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2381 MINIBUF nil or omitted means consider the minibuffer window only if the
2382 minibuffer is active. MINIBUF t means consider the minibuffer window
2383 even if the minibuffer is not active. Any other value means do not
2384 consider the minibuffer window even if the minibuffer is active.
2386 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2387 plus the minibuffer window if specified by the MINIBUF argument. If the
2388 minibuffer counts, consider all windows on all frames that share that
2389 minibuffer too. The following non-nil values of ALL-FRAMES have special
2392 - t means consider all windows on all existing frames.
2394 - `visible' means consider all windows on all visible frames.
2396 - 0 (the number zero) means consider all windows on all visible and
2399 - A frame means consider all windows on that frame only.
2401 Anything else means consider all windows on WINDOW's frame and no
2404 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2405 use `previous-window' to iterate through the entire cycle of
2406 acceptable windows, eventually ending up back at the window you
2407 started with. `next-window' traverses the same cycle, in the
2409 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2411 return next_window (window
, minibuf
, all_frames
, 0);
2415 /* Return a list of windows in cyclic ordering. Arguments are like
2416 for `next-window'. */
2419 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2421 Lisp_Object tail
, list
, rest
;
2423 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2426 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2427 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2428 list
= Fcons (XCAR (tail
), list
);
2430 /* Rotate the list to start with WINDOW. */
2431 list
= Fnreverse (list
);
2432 rest
= Fmemq (window
, list
);
2433 if (!NILP (rest
) && !EQ (rest
, list
))
2435 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2437 XSETCDR (tail
, Qnil
);
2438 list
= nconc2 (rest
, list
);
2444 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2445 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2446 FRAME nil or omitted means use the selected frame.
2447 WINDOW nil or omitted means use the window selected within FRAME.
2448 MINIBUF t means include the minibuffer window, even if it isn't active.
2449 MINIBUF nil or omitted means include the minibuffer window only
2451 MINIBUF neither nil nor t means never include the minibuffer window. */)
2452 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2455 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2456 CHECK_WINDOW (window
);
2458 frame
= selected_frame
;
2460 if (!EQ (frame
, XWINDOW (window
)->frame
))
2461 error ("Window is on a different frame");
2463 return window_list_1 (window
, minibuf
, frame
);
2467 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2468 doc
: /* Return a list of all live windows.
2469 WINDOW specifies the first window to list and defaults to the selected
2472 Optional argument MINIBUF nil or omitted means consider the minibuffer
2473 window only if the minibuffer is active. MINIBUF t means consider the
2474 minibuffer window even if the minibuffer is not active. Any other value
2475 means do not consider the minibuffer window even if the minibuffer is
2478 Optional argument ALL-FRAMES nil or omitted means consider all windows
2479 on WINDOW's frame, plus the minibuffer window if specified by the
2480 MINIBUF argument. If the minibuffer counts, consider all windows on all
2481 frames that share that minibuffer too. The following non-nil values of
2482 ALL-FRAMES have special meanings:
2484 - t means consider all windows on all existing frames.
2486 - `visible' means consider all windows on all visible frames.
2488 - 0 (the number zero) means consider all windows on all visible and
2491 - A frame means consider all windows on that frame only.
2493 Anything else means consider all windows on WINDOW's frame and no
2496 If WINDOW is not on the list of windows returned, some other window will
2497 be listed first but no error is signaled. */)
2498 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2500 return window_list_1 (window
, minibuf
, all_frames
);
2503 /* Look at all windows, performing an operation specified by TYPE
2505 If FRAMES is Qt, look at all frames;
2506 Qnil, look at just the selected frame;
2507 Qvisible, look at visible frames;
2508 a frame, just look at windows on that frame.
2509 If MINI is non-zero, perform the operation on minibuffer windows too. */
2514 GET_BUFFER_WINDOW
, /* Arg is buffer */
2515 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2516 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2521 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2523 Lisp_Object window
, windows
, best_window
, frame_arg
;
2524 int frame_best_window_flag
= 0;
2526 struct gcpro gcpro1
;
2528 /* If we're only looping through windows on a particular frame,
2529 frame points to that frame. If we're looping through windows
2530 on all frames, frame is 0. */
2531 if (FRAMEP (frames
))
2532 f
= XFRAME (frames
);
2533 else if (NILP (frames
))
2534 f
= SELECTED_FRAME ();
2539 frame_arg
= Qlambda
;
2540 else if (EQ (frames
, make_number (0)))
2542 else if (EQ (frames
, Qvisible
))
2547 /* frame_arg is Qlambda to stick to one frame,
2548 Qvisible to consider all visible frames,
2551 /* Pick a window to start with. */
2555 window
= FRAME_SELECTED_WINDOW (f
);
2557 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2559 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2563 for (; CONSP (windows
); windows
= XCDR (windows
))
2567 window
= XCAR (windows
);
2568 w
= XWINDOW (window
);
2570 /* Note that we do not pay attention here to whether the frame
2571 is visible, since Fwindow_list skips non-visible frames if
2572 that is desired, under the control of frame_arg. */
2573 if (!MINI_WINDOW_P (w
)
2574 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2575 consider all windows. */
2576 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2577 || (mini
&& minibuf_level
> 0))
2580 case GET_BUFFER_WINDOW
:
2581 if (EQ (w
->buffer
, obj
)
2582 /* Don't find any minibuffer window except the one that
2583 is currently in use. */
2584 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2586 if (EQ (window
, selected_window
))
2587 /* Preferably return the selected window. */
2588 RETURN_UNGCPRO (window
);
2589 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2590 && !frame_best_window_flag
)
2591 /* Prefer windows on the current frame (but don't
2592 choose another one if we have one already). */
2594 best_window
= window
;
2595 frame_best_window_flag
= 1;
2597 else if (NILP (best_window
))
2598 best_window
= window
;
2602 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2603 /* We could simply check whether the buffer shown by window
2604 is live, and show another buffer in case it isn't. */
2605 if (EQ (w
->buffer
, obj
))
2607 /* Undedicate WINDOW. */
2608 wset_dedicated (w
, Qnil
);
2609 /* Make WINDOW show the buffer returned by
2610 other_buffer_safely, don't run any hooks. */
2612 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2613 /* If WINDOW is the selected window, make its buffer
2614 current. But do so only if the window shows the
2615 current buffer (Bug#6454). */
2616 if (EQ (window
, selected_window
)
2617 && XBUFFER (w
->buffer
) == current_buffer
)
2618 Fset_buffer (w
->buffer
);
2622 case REDISPLAY_BUFFER_WINDOWS
:
2623 if (EQ (w
->buffer
, obj
))
2625 mark_window_display_accurate (window
, 0);
2626 w
->update_mode_line
= 1;
2627 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2628 ++update_mode_lines
;
2629 best_window
= window
;
2633 /* Check for a window that has a killed buffer. */
2634 case CHECK_ALL_WINDOWS
:
2635 if (! NILP (w
->buffer
)
2636 && !BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
2640 case WINDOW_LOOP_UNUSED
:
2649 /* Used for debugging. Abort if any window has a dead buffer. */
2651 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2653 check_all_windows (void)
2655 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2658 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2659 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2660 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2663 The optional argument ALL-FRAMES specifies the frames to consider:
2665 - t means consider all windows on all existing frames.
2667 - `visible' means consider all windows on all visible frames.
2669 - 0 (the number zero) means consider all windows on all visible
2670 and iconified frames.
2672 - A frame means consider all windows on that frame only.
2674 Any other value of ALL-FRAMES means consider all windows on the
2675 selected frame and no others. */)
2676 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2680 if (NILP (buffer_or_name
))
2681 buffer
= Fcurrent_buffer ();
2683 buffer
= Fget_buffer (buffer_or_name
);
2685 if (BUFFERP (buffer
))
2686 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2692 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2694 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2698 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2699 Sdelete_other_windows_internal
, 0, 2, "",
2700 doc
: /* Make WINDOW fill its frame.
2701 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2702 and defaults to the selected one.
2704 Optional argument ROOT, if non-nil, must specify an internal window such
2705 that WINDOW is in its window subtree. If this is the case, replace ROOT
2706 by WINDOW and leave alone any windows not part of ROOT's subtree.
2708 When WINDOW is live try to reduce display jumps by keeping the text
2709 previously visible in WINDOW in the same place on the frame. Doing this
2710 depends on the value of (window-start WINDOW), so if calling this
2711 function in a program gives strange scrolling, make sure the
2712 window-start value is reasonable when this function is called. */)
2713 (Lisp_Object window
, Lisp_Object root
)
2715 struct window
*w
, *r
, *s
;
2717 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2718 ptrdiff_t startpos
IF_LINT (= 0);
2719 int top
IF_LINT (= 0), new_top
, resize_failed
;
2721 w
= decode_valid_window (window
);
2722 XSETWINDOW (window
, w
);
2723 f
= XFRAME (w
->frame
);
2726 /* ROOT is the frame's root window. */
2728 root
= FRAME_ROOT_WINDOW (f
);
2732 /* ROOT must be an ancestor of WINDOW. */
2734 r
= decode_valid_window (root
);
2735 pwindow
= XWINDOW (window
)->parent
;
2736 while (!NILP (pwindow
))
2737 if (EQ (pwindow
, root
))
2740 pwindow
= XWINDOW (pwindow
)->parent
;
2741 if (!EQ (pwindow
, root
))
2742 error ("Specified root is not an ancestor of specified window");
2745 if (EQ (window
, root
))
2748 /* I don't understand the "top > 0" part below. If we deal with a
2749 standalone minibuffer it would have been caught by the preceding
2751 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2752 error ("Can't expand minibuffer to full frame");
2754 if (!NILP (w
->buffer
))
2756 startpos
= marker_position (w
->start
);
2757 top
= WINDOW_TOP_EDGE_LINE (w
)
2758 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2759 /* Make sure WINDOW is the frame's selected window. */
2760 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2762 if (EQ (selected_frame
, w
->frame
))
2763 Fselect_window (window
, Qnil
);
2765 fset_selected_window (f
, window
);
2770 /* See if the frame's selected window is a part of the window
2771 subtree rooted at WINDOW, by finding all the selected window's
2772 parents and comparing each one with WINDOW. If it isn't we
2773 need a new selected window for this frame. */
2774 swindow
= FRAME_SELECTED_WINDOW (f
);
2778 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2779 pwindow
= XWINDOW (pwindow
)->parent
;
2781 if (EQ (window
, pwindow
))
2782 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2783 as the new selected window. */
2786 /* Else try the previous window of SWINDOW. */
2787 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2790 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2792 if (EQ (selected_frame
, w
->frame
))
2793 Fselect_window (swindow
, Qnil
);
2795 fset_selected_window (f
, swindow
);
2800 if (!FRAME_INITIAL_P (f
))
2802 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2804 /* We are going to free the glyph matrices of WINDOW, and with
2805 that we might lose any information about glyph rows that have
2806 some of their glyphs highlighted in mouse face. (These rows
2807 are marked with a non-zero mouse_face_p flag.) If WINDOW
2808 indeed has some glyphs highlighted in mouse face, signal to
2809 frame's up-to-date hook that mouse highlight was overwritten,
2810 so that it will arrange for redisplaying the highlight. */
2811 if (EQ (hlinfo
->mouse_face_window
, window
))
2813 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2814 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2815 hlinfo
->mouse_face_window
= Qnil
;
2818 free_window_matrices (r
);
2820 windows_or_buffers_changed
++;
2821 Vwindow_list
= Qnil
;
2822 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2825 if (NILP (w
->buffer
))
2827 /* Resize child windows vertically. */
2828 XSETINT (delta
, XINT (r
->total_lines
)
2829 - XINT (w
->total_lines
));
2830 wset_top_line (w
, r
->top_line
);
2831 resize_root_window (window
, delta
, Qnil
, Qnil
);
2832 if (window_resize_check (w
, 0))
2833 window_resize_apply (w
, 0);
2836 resize_root_window (window
, delta
, Qnil
, Qt
);
2837 if (window_resize_check (w
, 0))
2838 window_resize_apply (w
, 0);
2843 /* Resize child windows horizontally. */
2846 wset_left_col (w
, r
->left_col
);
2848 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2849 wset_left_col (w
, r
->left_col
);
2850 resize_root_window (window
, delta
, Qt
, Qnil
);
2851 if (window_resize_check (w
, 1))
2852 window_resize_apply (w
, 1);
2855 resize_root_window (window
, delta
, Qt
, Qt
);
2856 if (window_resize_check (w
, 1))
2857 window_resize_apply (w
, 1);
2864 /* Play safe, if we still can ... */
2867 w
= XWINDOW (window
);
2871 /* Cleanly unlink WINDOW from window-tree. */
2872 if (!NILP (w
->prev
))
2873 /* Get SIBLING above (on the left of) WINDOW. */
2876 s
= XWINDOW (sibling
);
2877 wset_next (s
, w
->next
);
2878 if (!NILP (s
->next
))
2879 wset_prev (XWINDOW (s
->next
), sibling
);
2882 /* Get SIBLING below (on the right of) WINDOW. */
2885 s
= XWINDOW (sibling
);
2886 wset_prev (s
, Qnil
);
2887 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2888 wset_vchild (XWINDOW (w
->parent
), sibling
);
2890 wset_hchild (XWINDOW (w
->parent
), sibling
);
2893 /* Delete ROOT and all child windows of ROOT. */
2894 if (!NILP (r
->vchild
))
2896 delete_all_child_windows (r
->vchild
);
2897 wset_vchild (r
, Qnil
);
2899 else if (!NILP (r
->hchild
))
2901 delete_all_child_windows (r
->hchild
);
2902 wset_hchild (r
, Qnil
);
2905 replace_window (root
, window
, 1);
2907 /* This must become SWINDOW anyway ....... */
2908 if (!NILP (w
->buffer
) && !resize_failed
)
2910 /* Try to minimize scrolling, by setting the window start to the
2911 point will cause the text at the old window start to be at the
2912 same place on the frame. But don't try to do this if the
2913 window start is outside the visible portion (as might happen
2914 when the display is not current, due to typeahead). */
2915 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2917 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2918 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2920 struct position pos
;
2921 struct buffer
*obuf
= current_buffer
;
2923 Fset_buffer (w
->buffer
);
2924 /* This computation used to temporarily move point, but that
2925 can have unwanted side effects due to text properties. */
2926 pos
= *vmotion (startpos
, -top
, w
);
2928 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2929 wset_window_end_valid (w
, Qnil
);
2930 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2931 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2932 /* We need to do this, so that the window-scroll-functions
2934 w
->optional_new_start
= 1;
2936 set_buffer_internal (obuf
);
2943 run_window_configuration_change_hook (f
);
2950 replace_buffer_in_windows (Lisp_Object buffer
)
2952 call1 (Qreplace_buffer_in_windows
, buffer
);
2956 /* Safely replace BUFFER with some other buffer in all windows of all
2957 frames, even those on other keyboards. */
2960 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2962 Lisp_Object tail
, frame
;
2964 /* A single call to window_loop won't do the job because it only
2965 considers frames on the current keyboard. So loop manually over
2966 frames, and handle each one. */
2967 FOR_EACH_FRAME (tail
, frame
)
2968 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2971 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2972 minimum allowable size. */
2975 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2977 /* For height, we have to see:
2978 how many windows the frame has at minimum (one or two),
2979 and whether it has a menu bar or other special stuff at the top. */
2981 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2982 ? MIN_SAFE_WINDOW_HEIGHT
2983 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2985 if (FRAME_TOP_MARGIN (frame
) > 0)
2986 min_height
+= FRAME_TOP_MARGIN (frame
);
2988 if (*rows
< min_height
)
2990 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2991 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2994 /* Adjust the margins of window W if text area is too small.
2995 Return 1 if window width is ok after adjustment; 0 if window
2996 is still too narrow. */
2999 adjust_window_margins (struct window
*w
)
3001 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3002 - WINDOW_FRINGE_COLS (w
)
3003 - WINDOW_SCROLL_BAR_COLS (w
));
3004 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3005 + WINDOW_RIGHT_MARGIN_COLS (w
));
3007 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3010 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3013 /* Window's text area is too narrow, but reducing the window
3014 margins will fix that. */
3015 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3016 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3018 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3020 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3021 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3024 wset_right_margin_cols (w
, make_number (margin_cols
));
3027 wset_left_margin_cols (w
, make_number (margin_cols
));
3031 /* The following three routines are needed for running a window's
3032 configuration change hook. */
3034 run_funs (Lisp_Object funs
)
3036 for (; CONSP (funs
); funs
= XCDR (funs
))
3037 if (!EQ (XCAR (funs
), Qt
))
3038 call0 (XCAR (funs
));
3042 select_window_norecord (Lisp_Object window
)
3044 return WINDOW_LIVE_P (window
)
3045 ? Fselect_window (window
, Qt
) : selected_window
;
3049 select_frame_norecord (Lisp_Object frame
)
3051 return FRAME_LIVE_P (XFRAME (frame
))
3052 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3056 run_window_configuration_change_hook (struct frame
*f
)
3058 ptrdiff_t count
= SPECPDL_INDEX ();
3059 Lisp_Object frame
, global_wcch
3060 = Fdefault_value (Qwindow_configuration_change_hook
);
3061 XSETFRAME (frame
, f
);
3063 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3066 /* Use the right buffer. Matters when running the local hooks. */
3067 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3069 record_unwind_current_buffer ();
3070 Fset_buffer (Fwindow_buffer (Qnil
));
3073 if (SELECTED_FRAME () != f
)
3075 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3076 select_frame_norecord (frame
);
3079 /* Look for buffer-local values. */
3081 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3082 for (; CONSP (windows
); windows
= XCDR (windows
))
3084 Lisp_Object window
= XCAR (windows
);
3085 Lisp_Object buffer
= Fwindow_buffer (window
);
3086 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3089 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3090 record_unwind_protect (select_window_norecord
, Fselected_window ());
3091 select_window_norecord (window
);
3092 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3094 unbind_to (inner_count
, Qnil
);
3099 run_funs (global_wcch
);
3100 unbind_to (count
, Qnil
);
3103 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3104 Srun_window_configuration_change_hook
, 0, 1, 0,
3105 doc
: /* Run `window-configuration-change-hook' for FRAME.
3106 If FRAME is omitted or nil, it defaults to the selected frame. */)
3109 run_window_configuration_change_hook (decode_live_frame (frame
));
3113 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3114 means it's allowed to run hooks. See make_frame for a case where
3115 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3116 margins, fringes, and scroll-bar settings of the window are not
3117 reset from the buffer's local settings. */
3120 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3122 struct window
*w
= XWINDOW (window
);
3123 struct buffer
*b
= XBUFFER (buffer
);
3124 ptrdiff_t count
= SPECPDL_INDEX ();
3125 int samebuf
= EQ (buffer
, w
->buffer
);
3127 wset_buffer (w
, buffer
);
3129 if (EQ (window
, selected_window
))
3130 bset_last_selected_window (b
, window
);
3132 /* Let redisplay errors through. */
3133 b
->display_error_modiff
= 0;
3135 /* Update time stamps of buffer display. */
3136 if (INTEGERP (BVAR (b
, display_count
)))
3137 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3138 bset_display_time (b
, Fcurrent_time ());
3140 wset_window_end_pos (w
, make_number (0));
3141 wset_window_end_vpos (w
, make_number (0));
3142 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3143 wset_window_end_valid (w
, Qnil
);
3144 if (!(keep_margins_p
&& samebuf
))
3145 { /* If we're not actually changing the buffer, don't reset hscroll and
3146 vscroll. This case happens for example when called from
3147 change_frame_size_1, where we use a dummy call to
3148 Fset_window_buffer on the frame's selected window (and no other)
3149 just in order to run window-configuration-change-hook.
3150 Resetting hscroll and vscroll here is problematic for things like
3151 image-mode and doc-view-mode since it resets the image's position
3152 whenever we resize the frame. */
3153 w
->hscroll
= w
->min_hscroll
= 0;
3155 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3156 set_marker_restricted (w
->start
,
3157 make_number (b
->last_window_start
),
3159 w
->start_at_line_beg
= 0;
3161 w
->last_modified
= 0;
3162 w
->last_overlay_modified
= 0;
3164 /* Maybe we could move this into the `if' but it's not obviously safe and
3165 I doubt it's worth the trouble. */
3166 windows_or_buffers_changed
++;
3168 /* We must select BUFFER for running the window-scroll-functions. */
3169 /* We can't check ! NILP (Vwindow_scroll_functions) here
3170 because that might itself be a local variable. */
3171 if (window_initialized
)
3173 record_unwind_current_buffer ();
3174 Fset_buffer (buffer
);
3177 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3179 if (!keep_margins_p
)
3181 /* Set left and right marginal area width etc. from buffer. */
3183 /* This may call adjust_window_margins three times, so
3184 temporarily disable window margins. */
3185 Lisp_Object save_left
= w
->left_margin_cols
;
3186 Lisp_Object save_right
= w
->right_margin_cols
;
3188 wset_left_margin_cols (w
, Qnil
);
3189 wset_right_margin_cols (w
, Qnil
);
3191 Fset_window_fringes (window
,
3192 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3193 BVAR (b
, fringes_outside_margins
));
3195 Fset_window_scroll_bars (window
,
3196 BVAR (b
, scroll_bar_width
),
3197 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3199 wset_left_margin_cols (w
, save_left
);
3200 wset_right_margin_cols (w
, save_right
);
3202 Fset_window_margins (window
,
3203 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3208 if (! NILP (Vwindow_scroll_functions
))
3209 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3210 Fmarker_position (w
->start
));
3211 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3214 unbind_to (count
, Qnil
);
3217 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3218 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3219 WINDOW must be a live window and defaults to the selected one.
3220 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3222 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3223 display margins, fringe widths, and scroll bar settings are preserved;
3224 the default is to reset these from the local settings for BUFFER-OR-NAME
3225 or the frame defaults. Return nil.
3227 This function throws an error when WINDOW is strongly dedicated to its
3228 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3229 already display BUFFER-OR-NAME.
3231 This function runs `window-scroll-functions' before running
3232 `window-configuration-change-hook'. */)
3233 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3235 register Lisp_Object tem
, buffer
;
3236 register struct window
*w
= decode_live_window (window
);
3238 XSETWINDOW (window
, w
);
3239 buffer
= Fget_buffer (buffer_or_name
);
3240 CHECK_BUFFER (buffer
);
3241 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3242 error ("Attempt to display deleted buffer");
3246 error ("Window is deleted");
3247 else if (!EQ (tem
, Qt
))
3248 /* w->buffer is t when the window is first being set up. */
3250 if (!EQ (tem
, buffer
))
3252 if (EQ (w
->dedicated
, Qt
))
3253 /* WINDOW is strongly dedicated to its buffer, signal an
3255 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3257 /* WINDOW is weakly dedicated to its buffer, reset
3259 wset_dedicated (w
, Qnil
);
3261 call1 (Qrecord_window_buffer
, window
);
3267 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3273 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3275 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3278 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3280 doc
: /* Force all windows to be updated on next redisplay.
3281 If optional arg OBJECT is a window, force redisplay of that window only.
3282 If OBJECT is a buffer or buffer name, force redisplay of all windows
3283 displaying that buffer. */)
3284 (Lisp_Object object
)
3288 windows_or_buffers_changed
++;
3289 update_mode_lines
++;
3293 if (WINDOWP (object
))
3295 struct window
*w
= XWINDOW (object
);
3296 mark_window_display_accurate (object
, 0);
3297 w
->update_mode_line
= 1;
3298 if (BUFFERP (w
->buffer
))
3299 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3300 ++update_mode_lines
;
3304 if (STRINGP (object
))
3305 object
= Fget_buffer (object
);
3306 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
3308 /* Walk all windows looking for buffer, and force update
3309 of each of those windows. */
3311 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3312 return NILP (object
) ? Qnil
: Qt
;
3315 /* If nothing suitable was found, just return.
3316 We could signal an error, but this feature will typically be used
3317 asynchronously in timers or process sentinels, so we don't. */
3321 /* Obsolete since 24.3. */
3323 temp_output_buffer_show (register Lisp_Object buf
)
3325 register struct buffer
*old
= current_buffer
;
3326 register Lisp_Object window
;
3327 register struct window
*w
;
3329 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3332 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3336 set_buffer_internal (old
);
3338 if (!NILP (Vtemp_buffer_show_function
))
3339 call1 (Vtemp_buffer_show_function
, buf
);
3342 window
= display_buffer (buf
, Qnil
, Qnil
);
3344 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3345 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3346 Vminibuf_scroll_window
= window
;
3347 w
= XWINDOW (window
);
3350 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3351 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3353 /* Run temp-buffer-show-hook, with the chosen window selected
3354 and its buffer current. */
3356 ptrdiff_t count
= SPECPDL_INDEX ();
3357 Lisp_Object prev_window
, prev_buffer
;
3358 prev_window
= selected_window
;
3359 XSETBUFFER (prev_buffer
, old
);
3361 /* Select the window that was chosen, for running the hook.
3362 Note: Both Fselect_window and select_window_norecord may
3363 set-buffer to the buffer displayed in the window,
3364 so we need to save the current buffer. --stef */
3365 record_unwind_protect (Fset_buffer
, prev_buffer
);
3366 record_unwind_protect (select_window_norecord
, prev_window
);
3367 Fselect_window (window
, Qt
);
3368 Fset_buffer (w
->buffer
);
3369 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3370 unbind_to (count
, Qnil
);
3375 /* Make new window, have it replace WINDOW in window-tree, and make
3376 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3377 horizontal child). */
3379 make_parent_window (Lisp_Object window
, int horflag
)
3382 register struct window
*o
, *p
;
3384 o
= XWINDOW (window
);
3385 p
= allocate_window ();
3386 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3387 (char *) o
+ sizeof (struct vectorlike_header
),
3388 word_size
* VECSIZE (struct window
));
3389 XSETWINDOW (parent
, p
);
3391 p
->sequence_number
= ++sequence_number
;
3393 replace_window (window
, parent
, 1);
3395 wset_next (o
, Qnil
);
3396 wset_prev (o
, Qnil
);
3397 wset_parent (o
, parent
);
3399 wset_hchild (p
, horflag
? window
: Qnil
);
3400 wset_vchild (p
, horflag
? Qnil
: window
);
3401 wset_start (p
, Qnil
);
3402 wset_pointm (p
, Qnil
);
3403 wset_buffer (p
, Qnil
);
3404 wset_combination_limit (p
, Qnil
);
3405 wset_window_parameters (p
, Qnil
);
3408 /* Make new window from scratch. */
3413 register struct window
*w
;
3415 w
= allocate_window ();
3416 /* Initialize Lisp data. Note that allocate_window initializes all
3417 Lisp data to nil, so do it only for slots which should not be nil. */
3418 wset_left_col (w
, make_number (0));
3419 wset_top_line (w
, make_number (0));
3420 wset_total_lines (w
, make_number (0));
3421 wset_total_cols (w
, make_number (0));
3422 wset_normal_lines (w
, make_float (1.0));
3423 wset_normal_cols (w
, make_float (1.0));
3424 wset_new_total (w
, make_number (0));
3425 wset_new_normal (w
, make_number (0));
3426 wset_start (w
, Fmake_marker ());
3427 wset_pointm (w
, Fmake_marker ());
3428 wset_vertical_scroll_bar_type (w
, Qt
);
3429 wset_window_end_pos (w
, make_number (0));
3430 wset_window_end_vpos (w
, make_number (0));
3431 /* These Lisp fields are marked specially so they're not set to nil by
3433 wset_prev_buffers (w
, Qnil
);
3434 wset_next_buffers (w
, Qnil
);
3436 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3437 non-Lisp data, so do it only for slots which should not be zero. */
3438 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3439 w
->phys_cursor_type
= -1;
3440 w
->phys_cursor_width
= -1;
3441 w
->sequence_number
= ++sequence_number
;
3443 /* Reset window_list. */
3444 Vwindow_list
= Qnil
;
3445 /* Return window. */
3446 XSETWINDOW (window
, w
);
3450 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3451 doc
: /* Set new total size of WINDOW to SIZE.
3452 WINDOW must be a valid window and defaults to the selected one.
3455 Optional argument ADD non-nil means add SIZE to the new total size of
3456 WINDOW and return the sum.
3458 Note: This function does not operate on any child windows of WINDOW. */)
3459 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3461 struct window
*w
= decode_valid_window (window
);
3463 CHECK_NUMBER (size
);
3465 wset_new_total (w
, size
);
3467 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3469 return w
->new_total
;
3472 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3473 doc
: /* Set new normal size of WINDOW to SIZE.
3474 WINDOW must be a valid window and defaults to the selected one.
3477 Note: This function does not operate on any child windows of WINDOW. */)
3478 (Lisp_Object window
, Lisp_Object size
)
3480 wset_new_normal (decode_valid_window (window
), size
);
3484 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3485 non-zero) to w->new_total would result in correct heights (widths)
3486 for window W and recursively all child windows of W.
3488 Note: This function does not check any of `window-fixed-size-p',
3489 `window-min-height' or `window-min-width'. It does check that window
3490 sizes do not drop below one line (two columns). */
3492 window_resize_check (struct window
*w
, int horflag
)
3496 if (!NILP (w
->vchild
))
3497 /* W is a vertical combination. */
3499 c
= XWINDOW (w
->vchild
);
3501 /* All child windows of W must have the same width as W. */
3505 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3506 || !window_resize_check (c
, horflag
))
3508 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3513 /* The sum of the heights of the child windows of W must equal
3516 int sum_of_sizes
= 0;
3519 if (!window_resize_check (c
, horflag
))
3521 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3522 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3524 return (sum_of_sizes
== XINT (w
->new_total
));
3527 else if (!NILP (w
->hchild
))
3528 /* W is a horizontal combination. */
3530 c
= XWINDOW (w
->hchild
);
3532 /* The sum of the widths of the child windows of W must equal W's
3535 int sum_of_sizes
= 0;
3538 if (!window_resize_check (c
, horflag
))
3540 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3541 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3543 return (sum_of_sizes
== XINT (w
->new_total
));
3546 /* All child windows of W must have the same height as W. */
3550 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3551 || !window_resize_check (c
, horflag
))
3553 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3559 /* A leaf window. Make sure it's not too small. The following
3560 hardcodes the values of `window-safe-min-width' (2) and
3561 `window-safe-min-height' (1) which are defined in window.el. */
3562 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3565 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3566 w->new_total for window W and recursively all child windows of W.
3567 Also calculate and assign the new vertical (horizontal) start
3568 positions of each of these windows.
3570 This function does not perform any error checks. Make sure you have
3571 run window_resize_check on W before applying this function. */
3573 window_resize_apply (struct window
*w
, int horflag
)
3578 /* Note: Assigning new_normal requires that the new total size of the
3579 parent window has been set *before*. */
3582 wset_total_cols (w
, w
->new_total
);
3583 if (NUMBERP (w
->new_normal
))
3584 wset_normal_cols (w
, w
->new_normal
);
3586 pos
= XINT (w
->left_col
);
3590 wset_total_lines (w
, w
->new_total
);
3591 if (NUMBERP (w
->new_normal
))
3592 wset_normal_lines (w
, w
->new_normal
);
3594 pos
= XINT (w
->top_line
);
3597 if (!NILP (w
->vchild
))
3598 /* W is a vertical combination. */
3600 c
= XWINDOW (w
->vchild
);
3604 wset_left_col (c
, make_number (pos
));
3606 wset_top_line (c
, make_number (pos
));
3607 window_resize_apply (c
, horflag
);
3609 pos
= pos
+ XINT (c
->total_lines
);
3610 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3613 else if (!NILP (w
->hchild
))
3614 /* W is a horizontal combination. */
3616 c
= XWINDOW (w
->hchild
);
3620 wset_left_col (c
, make_number (pos
));
3622 wset_top_line (c
, make_number (pos
));
3623 window_resize_apply (c
, horflag
);
3625 pos
= pos
+ XINT (c
->total_cols
);
3626 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3630 /* Clear out some redisplay caches. */
3631 w
->last_modified
= 0;
3632 w
->last_overlay_modified
= 0;
3636 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3637 doc
: /* Apply requested size values for window-tree of FRAME.
3638 If FRAME is omitted or nil, it defaults to the selected frame.
3640 Optional argument HORIZONTAL omitted or nil means apply requested
3641 height values. HORIZONTAL non-nil means apply requested width values.
3643 This function checks whether the requested values sum up to a valid
3644 window layout, recursively assigns the new sizes of all child windows
3645 and calculates and assigns the new start positions of these windows.
3647 Note: This function does not check any of `window-fixed-size-p',
3648 `window-min-height' or `window-min-width'. All these checks have to
3649 be applied on the Elisp level. */)
3650 (Lisp_Object frame
, Lisp_Object horizontal
)
3652 struct frame
*f
= decode_live_frame (frame
);
3653 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3654 int horflag
= !NILP (horizontal
);
3656 if (!window_resize_check (r
, horflag
)
3657 || ! EQ (r
->new_total
,
3658 (horflag
? r
->total_cols
: r
->total_lines
)))
3662 window_resize_apply (r
, horflag
);
3664 windows_or_buffers_changed
++;
3665 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3670 run_window_configuration_change_hook (f
);
3676 /* Resize frame F's windows when number of lines of F is set to SIZE.
3677 HORFLAG 1 means resize windows when number of columns of F is set to
3680 This function can delete all windows but the selected one in order to
3681 satisfy the request. The result will be meaningful if and only if
3682 F's windows have meaningful sizes when you call this. */
3684 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3686 Lisp_Object root
= f
->root_window
;
3687 struct window
*r
= XWINDOW (root
);
3688 Lisp_Object mini
= f
->minibuffer_window
;
3690 /* new_size is the new size of the frame's root window. */
3691 int new_size
= (horflag
3694 - FRAME_TOP_MARGIN (f
)
3695 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3698 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3699 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3700 /* For a leaf root window just set the size. */
3702 wset_total_cols (r
, make_number (new_size
));
3704 wset_total_lines (r
, make_number (new_size
));
3707 /* old_size is the old size of the frame's root window. */
3708 int old_size
= XFASTINT (horflag
? r
->total_cols
3712 XSETINT (delta
, new_size
- old_size
);
3713 /* Try a "normal" resize first. */
3714 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3715 if (window_resize_check (r
, horflag
)
3716 && new_size
== XINT (r
->new_total
))
3717 window_resize_apply (r
, horflag
);
3720 /* Try with "reasonable" minimum sizes next. */
3721 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3722 if (window_resize_check (r
, horflag
)
3723 && new_size
== XINT (r
->new_total
))
3724 window_resize_apply (r
, horflag
);
3727 /* Finally, try with "safe" minimum sizes. */
3728 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3729 if (window_resize_check (r
, horflag
)
3730 && new_size
== XINT (r
->new_total
))
3731 window_resize_apply (r
, horflag
);
3734 /* We lost. Delete all windows but the frame's
3736 root
= f
->selected_window
;
3737 Fdelete_other_windows_internal (root
, Qnil
);
3739 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3741 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3747 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3751 wset_total_cols (m
, make_number (size
));
3754 /* Are we sure we always want 1 line here? */
3755 wset_total_lines (m
, make_number (1));
3757 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3761 windows_or_buffers_changed
++;
3765 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3766 doc
: /* Split window OLD.
3767 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3768 new window. In any case TOTAL-SIZE must be a positive integer.
3770 Third argument SIDE nil (or `below') specifies that the new window shall
3771 be located below WINDOW. SIDE `above' means the new window shall be
3772 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3773 lines of the new window including space reserved for the mode and/or
3776 SIDE t (or `right') specifies that the new window shall be located on
3777 the right side of WINDOW. SIDE `left' means the new window shall be
3778 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3779 number of columns of the new window including space reserved for fringes
3780 and the scrollbar or a divider column.
3782 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3783 according to the SIDE argument.
3785 The new total and normal sizes of all involved windows must have been
3786 set correctly. See the code of `split-window' for how this is done. */)
3787 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3789 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3790 parent window or an internal window we have to install as OLD's new
3791 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3792 provided OLD is a leaf window, or to the frame's selected window.
3793 NEW (*n) is the new window created with some parameters taken from
3795 register Lisp_Object
new, frame
, reference
;
3796 register struct window
*o
, *p
, *n
, *r
;
3799 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3800 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3801 int combination_limit
= 0;
3805 frame
= WINDOW_FRAME (o
);
3808 CHECK_NUMBER (total_size
);
3810 /* Set combination_limit to 1 if we have to make a new parent window.
3811 We do that if either `window-combination-limit' is t, or OLD has no
3812 parent, or OLD is ortho-combined. */
3814 EQ (Vwindow_combination_limit
, Qt
)
3817 ? (XWINDOW (o
->parent
)->hchild
)
3818 : (XWINDOW (o
->parent
)->vchild
));
3820 /* We need a live reference window to initialize some parameters. */
3821 if (WINDOW_LIVE_P (old
))
3822 /* OLD is live, use it as reference window. */
3825 /* Use the frame's selected window as reference window. */
3826 reference
= FRAME_SELECTED_WINDOW (f
);
3827 r
= XWINDOW (reference
);
3829 /* The following bugs are caught by `split-window'. */
3830 if (MINI_WINDOW_P (o
))
3831 error ("Attempt to split minibuffer window");
3832 else if (XINT (total_size
) < (horflag
? 2 : 1))
3833 error ("Size of new window too small (after split)");
3834 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3835 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3838 p
= XWINDOW (o
->parent
);
3839 /* Temporarily pretend we split the parent window. */
3841 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3842 - XINT (total_size
)));
3843 if (!window_resize_check (p
, horflag
))
3844 error ("Window sizes don't fit");
3846 /* Undo the temporary pretension. */
3847 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3851 if (!window_resize_check (o
, horflag
))
3852 error ("Resizing old window failed");
3853 else if (XINT (total_size
) + XINT (o
->new_total
)
3854 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3855 error ("Sum of sizes of old and new window don't fit");
3858 /* This is our point of no return. */
3859 if (combination_limit
)
3861 /* Save the old value of o->normal_cols/lines. It gets corrupted
3862 by make_parent_window and we need it below for assigning it to
3864 Lisp_Object new_normal
3865 = horflag
? o
->normal_cols
: o
->normal_lines
;
3867 make_parent_window (old
, horflag
);
3868 p
= XWINDOW (o
->parent
);
3869 /* Store t in the new parent's combination_limit slot to avoid
3870 that its children get merged into another window. */
3871 wset_combination_limit (p
, Qt
);
3872 /* These get applied below. */
3873 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3874 wset_new_normal (p
, new_normal
);
3877 p
= XWINDOW (o
->parent
);
3879 windows_or_buffers_changed
++;
3880 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3881 new = make_window ();
3883 wset_frame (n
, frame
);
3884 wset_parent (n
, o
->parent
);
3885 wset_vchild (n
, Qnil
);
3886 wset_hchild (n
, Qnil
);
3888 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3890 wset_prev (n
, o
->prev
);
3893 wset_hchild (p
, new);
3895 wset_vchild (p
, new);
3897 wset_next (XWINDOW (n
->prev
), new);
3903 wset_next (n
, o
->next
);
3904 if (!NILP (n
->next
))
3905 wset_prev (XWINDOW (n
->next
), new);
3910 wset_buffer (n
, Qt
);
3911 wset_window_end_valid (n
, Qnil
);
3912 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3914 /* Get special geometry settings from reference window. */
3915 wset_left_margin_cols (n
, r
->left_margin_cols
);
3916 wset_right_margin_cols (n
, r
->right_margin_cols
);
3917 wset_left_fringe_width (n
, r
->left_fringe_width
);
3918 wset_right_fringe_width (n
, r
->right_fringe_width
);
3919 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3920 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3921 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3923 /* Directly assign orthogonal coordinates and sizes. */
3926 wset_top_line (n
, o
->top_line
);
3927 wset_total_lines (n
, o
->total_lines
);
3931 wset_left_col (n
, o
->left_col
);
3932 wset_total_cols (n
, o
->total_cols
);
3935 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3936 get them ready here. */
3937 wset_new_total (n
, total_size
);
3938 wset_new_normal (n
, normal_size
);
3941 window_resize_apply (p
, horflag
);
3943 /* Set buffer of NEW to buffer of reference window. Don't run
3945 set_window_buffer (new, r
->buffer
, 0, 1);
3948 /* Maybe we should run the scroll functions in Elisp (which already
3949 runs the configuration change hook). */
3950 if (! NILP (Vwindow_scroll_functions
))
3951 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3952 Fmarker_position (n
->start
));
3958 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3959 doc
: /* Remove WINDOW from its frame.
3960 WINDOW defaults to the selected window. Return nil.
3961 Signal an error when WINDOW is the only window on its frame. */)
3962 (register Lisp_Object window
)
3964 register Lisp_Object parent
, sibling
, frame
, root
;
3965 struct window
*w
, *p
, *s
, *r
;
3968 int before_sibling
= 0;
3970 w
= decode_any_window (window
);
3971 XSETWINDOW (window
, w
);
3972 if (NILP (w
->buffer
)
3973 && NILP (w
->hchild
) && NILP (w
->vchild
))
3974 /* It's a no-op to delete an already deleted window. */
3979 /* Never delete a minibuffer or frame root window. */
3980 error ("Attempt to delete minibuffer or sole ordinary window");
3981 else if (NILP (w
->prev
) && NILP (w
->next
))
3982 /* Rather bow out here, this case should be handled on the Elisp
3984 error ("Attempt to delete sole window of parent");
3986 p
= XWINDOW (parent
);
3987 horflag
= NILP (p
->vchild
);
3989 frame
= WINDOW_FRAME (w
);
3992 root
= FRAME_ROOT_WINDOW (f
);
3995 /* Unlink WINDOW from window tree. */
3997 /* Get SIBLING below (on the right of) WINDOW. */
3999 /* before_sibling 1 means WINDOW is the first child of its
4000 parent and thus before the sibling. */
4003 s
= XWINDOW (sibling
);
4004 wset_prev (s
, Qnil
);
4006 wset_hchild (p
, sibling
);
4008 wset_vchild (p
, sibling
);
4011 /* Get SIBLING above (on the left of) WINDOW. */
4014 s
= XWINDOW (sibling
);
4015 wset_next (s
, w
->next
);
4016 if (!NILP (s
->next
))
4017 wset_prev (XWINDOW (s
->next
), sibling
);
4020 if (window_resize_check (r
, horflag
)
4021 && EQ (r
->new_total
,
4022 (horflag
? r
->total_cols
: r
->total_lines
)))
4023 /* We can delete WINDOW now. */
4028 window_resize_apply (p
, horflag
);
4030 /* If this window is referred to by the dpyinfo's mouse
4031 highlight, invalidate that slot to be safe (Bug#9904). */
4032 if (!FRAME_INITIAL_P (f
))
4034 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4036 if (EQ (hlinfo
->mouse_face_window
, window
))
4037 hlinfo
->mouse_face_window
= Qnil
;
4040 windows_or_buffers_changed
++;
4041 Vwindow_list
= Qnil
;
4042 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4044 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4045 free_window_matrices (w
);
4047 if (!NILP (w
->vchild
))
4049 delete_all_child_windows (w
->vchild
);
4050 wset_vchild (w
, Qnil
);
4052 else if (!NILP (w
->hchild
))
4054 delete_all_child_windows (w
->hchild
);
4055 wset_hchild (w
, Qnil
);
4057 else if (!NILP (w
->buffer
))
4060 unchain_marker (XMARKER (w
->pointm
));
4061 unchain_marker (XMARKER (w
->start
));
4062 wset_buffer (w
, Qnil
);
4065 if (NILP (s
->prev
) && NILP (s
->next
))
4066 /* A matrjoshka where SIBLING has become the only child of
4069 /* Put SIBLING into PARENT's place. */
4070 replace_window (parent
, sibling
, 0);
4071 /* Have SIBLING inherit the following three slot values from
4072 PARENT (the combination_limit slot is not inherited). */
4073 wset_normal_cols (s
, p
->normal_cols
);
4074 wset_normal_lines (s
, p
->normal_lines
);
4075 /* Mark PARENT as deleted. */
4076 wset_vchild (p
, Qnil
);
4077 wset_hchild (p
, Qnil
);
4078 /* Try to merge SIBLING into its new parent. */
4079 recombine_windows (sibling
);
4084 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4085 /* We deleted the frame's selected window. */
4087 /* Use the frame's first window as fallback ... */
4088 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4089 /* ... but preferably use its most recently used window. */
4090 Lisp_Object mru_window
;
4092 /* `get-mru-window' might fail for some reason so play it safe
4093 - promote the first window _without recording it_ first. */
4094 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4095 Fselect_window (new_selected_window
, Qt
);
4097 fset_selected_window (f
, new_selected_window
);
4101 /* Now look whether `get-mru-window' gets us something. */
4102 mru_window
= call1 (Qget_mru_window
, frame
);
4103 if (WINDOW_LIVE_P (mru_window
)
4104 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4105 new_selected_window
= mru_window
;
4107 /* If all ended up well, we now promote the mru window. */
4108 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4109 Fselect_window (new_selected_window
, Qnil
);
4111 fset_selected_window (f
, new_selected_window
);
4116 /* Must be run by the caller:
4117 run_window_configuration_change_hook (f); */
4120 /* We failed: Relink WINDOW into window tree. */
4124 wset_prev (s
, window
);
4126 wset_hchild (p
, window
);
4128 wset_vchild (p
, window
);
4132 wset_next (s
, window
);
4133 if (!NILP (w
->next
))
4134 wset_prev (XWINDOW (w
->next
), window
);
4136 error ("Deletion failed");
4142 /***********************************************************************
4143 Resizing Mini-Windows
4144 ***********************************************************************/
4146 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4149 grow_mini_window (struct window
*w
, int delta
)
4151 struct frame
*f
= XFRAME (w
->frame
);
4153 Lisp_Object root
, value
;
4155 eassert (MINI_WINDOW_P (w
));
4156 eassert (delta
>= 0);
4158 root
= FRAME_ROOT_WINDOW (f
);
4160 value
= call2 (Qwindow_resize_root_window_vertically
,
4161 root
, make_number (- delta
));
4162 if (INTEGERP (value
) && window_resize_check (r
, 0))
4165 window_resize_apply (r
, 0);
4167 /* Grow the mini-window. */
4169 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4171 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4172 w
->last_modified
= 0;
4173 w
->last_overlay_modified
= 0;
4175 windows_or_buffers_changed
++;
4182 /* Shrink mini-window W. */
4184 shrink_mini_window (struct window
*w
)
4186 struct frame
*f
= XFRAME (w
->frame
);
4188 Lisp_Object root
, value
;
4191 eassert (MINI_WINDOW_P (w
));
4193 size
= XINT (w
->total_lines
);
4196 root
= FRAME_ROOT_WINDOW (f
);
4198 value
= call2 (Qwindow_resize_root_window_vertically
,
4199 root
, make_number (size
- 1));
4200 if (INTEGERP (value
) && window_resize_check (r
, 0))
4203 window_resize_apply (r
, 0);
4205 /* Shrink the mini-window. */
4206 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4207 + XFASTINT (r
->total_lines
)));
4208 wset_total_lines (w
, make_number (1));
4210 w
->last_modified
= 0;
4211 w
->last_overlay_modified
= 0;
4213 windows_or_buffers_changed
++;
4217 /* If the above failed for whatever strange reason we must make a
4218 one window frame here. The same routine will be needed when
4219 shrinking the frame (and probably when making the initial
4220 *scratch* window). For the moment leave things as they are. */
4224 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4225 doc
: /* Resize minibuffer window WINDOW. */)
4226 (Lisp_Object window
)
4228 struct window
*w
= XWINDOW (window
);
4233 CHECK_WINDOW (window
);
4234 f
= XFRAME (w
->frame
);
4236 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4237 error ("Not a valid minibuffer window");
4238 else if (FRAME_MINIBUF_ONLY_P (f
))
4239 error ("Cannot resize a minibuffer-only frame");
4241 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4242 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4243 if (window_resize_check (r
, 0)
4244 && XINT (w
->new_total
) > 0
4245 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4248 window_resize_apply (r
, 0);
4250 wset_total_lines (w
, w
->new_total
);
4251 wset_top_line (w
, make_number (XINT (r
->top_line
)
4252 + XINT (r
->total_lines
)));
4254 windows_or_buffers_changed
++;
4255 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4259 run_window_configuration_change_hook (f
);
4262 else error ("Failed to resize minibuffer window");
4265 /* Mark window cursors off for all windows in the window tree rooted
4266 at W by setting their phys_cursor_on_p flag to zero. Called from
4267 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4268 the frame are cleared. */
4271 mark_window_cursors_off (struct window
*w
)
4275 if (!NILP (w
->hchild
))
4276 mark_window_cursors_off (XWINDOW (w
->hchild
));
4277 else if (!NILP (w
->vchild
))
4278 mark_window_cursors_off (XWINDOW (w
->vchild
));
4280 w
->phys_cursor_on_p
= 0;
4282 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4287 /* Return number of lines of text (not counting mode lines) in W. */
4290 window_internal_height (struct window
*w
)
4292 int ht
= XFASTINT (w
->total_lines
);
4294 if (!MINI_WINDOW_P (w
))
4296 if (!NILP (w
->parent
)
4297 || !NILP (w
->vchild
)
4298 || !NILP (w
->hchild
)
4301 || WINDOW_WANTS_MODELINE_P (w
))
4304 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4311 /************************************************************************
4313 ***********************************************************************/
4315 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4316 N screen-fulls, which is defined as the height of the window minus
4317 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4318 instead. Negative values of N mean scroll down. NOERROR non-zero
4319 means don't signal an error if we try to move over BEGV or ZV,
4323 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4326 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4328 /* If we must, use the pixel-based version which is much slower than
4329 the line-based one but can handle varying line heights. */
4330 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4331 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4333 window_scroll_line_based (window
, n
, whole
, noerror
);
4339 /* Implementation of window_scroll that works based on pixel line
4340 heights. See the comment of window_scroll for parameter
4344 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4347 struct window
*w
= XWINDOW (window
);
4348 struct text_pos start
;
4349 int this_scroll_margin
;
4350 /* True if we fiddled the window vscroll field without really scrolling. */
4352 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4353 void *itdata
= NULL
;
4355 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4356 /* Scrolling a minibuffer window via scroll bar when the echo area
4357 shows long text sometimes resets the minibuffer contents behind
4359 if (CHARPOS (start
) > ZV
)
4360 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4362 /* If PT is not visible in WINDOW, move back one half of
4363 the screen. Allow PT to be partially visible, otherwise
4364 something like (scroll-down 1) with PT in the line before
4365 the partially visible one would recenter. */
4367 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4369 itdata
= bidi_shelve_cache ();
4370 /* Move backward half the height of the window. Performance note:
4371 vmotion used here is about 10% faster, but would give wrong
4372 results for variable height lines. */
4373 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4374 it
.current_y
= it
.last_visible_y
;
4375 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4377 /* The function move_iterator_vertically may move over more than
4378 the specified y-distance. If it->w is small, e.g. a
4379 mini-buffer window, we may end up in front of the window's
4380 display area. This is the case when Start displaying at the
4381 start of the line containing PT in this case. */
4382 if (it
.current_y
<= 0)
4384 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4385 move_it_vertically_backward (&it
, 0);
4389 start
= it
.current
.pos
;
4390 bidi_unshelve_cache (itdata
, 0);
4392 else if (auto_window_vscroll_p
)
4394 if (rtop
|| rbot
) /* partially visible */
4397 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4399 dy
= max ((window_box_height (w
)
4400 - next_screen_context_lines
* dy
),
4406 /* Only vscroll backwards if already vscrolled forwards. */
4407 if (w
->vscroll
< 0 && rtop
> 0)
4409 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4410 Fset_window_vscroll (window
, make_number (px
), Qt
);
4416 /* Do vscroll if already vscrolled or only display line. */
4417 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4419 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4420 Fset_window_vscroll (window
, make_number (px
), Qt
);
4424 /* Maybe modify window start instead of scrolling. */
4425 if (rbot
> 0 || w
->vscroll
< 0)
4429 Fset_window_vscroll (window
, make_number (0), Qt
);
4430 /* If there are other text lines above the current row,
4431 move window start to current row. Else to next row. */
4433 spos
= XINT (Fline_beginning_position (Qnil
));
4435 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4436 set_marker_restricted (w
->start
, make_number (spos
),
4438 w
->start_at_line_beg
= 1;
4439 w
->update_mode_line
= 1;
4440 w
->last_modified
= 0;
4441 w
->last_overlay_modified
= 0;
4442 /* Set force_start so that redisplay_window will run the
4443 window-scroll-functions. */
4449 /* Cancel previous vscroll. */
4450 Fset_window_vscroll (window
, make_number (0), Qt
);
4453 itdata
= bidi_shelve_cache ();
4454 /* If scroll_preserve_screen_position is non-nil, we try to set
4455 point in the same window line as it is now, so get that line. */
4456 if (!NILP (Vscroll_preserve_screen_position
))
4458 /* We preserve the goal pixel coordinate across consecutive
4459 calls to scroll-up, scroll-down and other commands that
4460 have the `scroll-command' property. This avoids the
4461 possibility of point becoming "stuck" on a tall line when
4462 scrolling by one line. */
4463 if (window_scroll_pixel_based_preserve_y
< 0
4464 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4465 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4467 start_display (&it
, w
, start
);
4468 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4469 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4470 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4474 window_scroll_pixel_based_preserve_y
4475 = window_scroll_pixel_based_preserve_x
= -1;
4477 /* Move iterator it from start the specified distance forward or
4478 backward. The result is the new window start. */
4479 start_display (&it
, w
, start
);
4482 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4483 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4484 dy
= max ((window_box_height (w
)
4485 - next_screen_context_lines
* dy
),
4488 /* Note that move_it_vertically always moves the iterator to the
4489 start of a line. So, if the last line doesn't have a newline,
4490 we would end up at the start of the line ending at ZV. */
4493 move_it_vertically_backward (&it
, -dy
);
4494 /* Ensure we actually do move, e.g. in case we are currently
4495 looking at an image that is taller that the window height. */
4496 while (start_pos
== IT_CHARPOS (it
)
4497 && start_pos
> BEGV
)
4498 move_it_by_lines (&it
, -1);
4502 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4503 MOVE_TO_POS
| MOVE_TO_Y
);
4504 /* Ensure we actually do move, e.g. in case we are currently
4505 looking at an image that is taller that the window height. */
4506 while (start_pos
== IT_CHARPOS (it
)
4508 move_it_by_lines (&it
, 1);
4512 move_it_by_lines (&it
, n
);
4514 /* We failed if we find ZV is already on the screen (scrolling up,
4515 means there's nothing past the end), or if we can't start any
4516 earlier (scrolling down, means there's nothing past the top). */
4517 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4518 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4520 if (IT_CHARPOS (it
) == ZV
)
4522 if (it
.current_y
< it
.last_visible_y
4523 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4524 > it
.last_visible_y
))
4526 /* The last line was only partially visible, make it fully
4528 w
->vscroll
= (it
.last_visible_y
4529 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4530 adjust_glyphs (it
.f
);
4534 bidi_unshelve_cache (itdata
, 0);
4537 else if (n
< 0) /* could happen with empty buffers */
4538 xsignal0 (Qbeginning_of_buffer
);
4540 xsignal0 (Qend_of_buffer
);
4545 if (w
->vscroll
!= 0)
4546 /* The first line was only partially visible, make it fully
4551 bidi_unshelve_cache (itdata
, 0);
4555 xsignal0 (Qbeginning_of_buffer
);
4559 /* If control gets here, then we vscrolled. */
4561 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4563 /* Don't try to change the window start below. */
4569 ptrdiff_t pos
= IT_CHARPOS (it
);
4572 /* If in the middle of a multi-glyph character move forward to
4573 the next character. */
4574 if (in_display_vector_p (&it
))
4577 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4580 /* Set the window start, and set up the window for redisplay. */
4581 set_marker_restricted (w
->start
, make_number (pos
),
4583 bytepos
= XMARKER (w
->start
)->bytepos
;
4584 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4585 w
->update_mode_line
= 1;
4586 w
->last_modified
= 0;
4587 w
->last_overlay_modified
= 0;
4588 /* Set force_start so that redisplay_window will run the
4589 window-scroll-functions. */
4593 /* The rest of this function uses current_y in a nonstandard way,
4594 not including the height of the header line if any. */
4595 it
.current_y
= it
.vpos
= 0;
4597 /* Move PT out of scroll margins.
4598 This code wants current_y to be zero at the window start position
4599 even if there is a header line. */
4600 this_scroll_margin
= max (0, scroll_margin
);
4602 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4603 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4607 /* We moved the window start towards ZV, so PT may be now
4608 in the scroll margin at the top. */
4609 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4610 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4611 && (NILP (Vscroll_preserve_screen_position
)
4612 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4613 /* We found PT at a legitimate height. Leave it alone. */
4615 else if (window_scroll_pixel_based_preserve_y
>= 0)
4617 /* If we have a header line, take account of it.
4618 This is necessary because we set it.current_y to 0, above. */
4619 move_it_to (&it
, -1,
4620 window_scroll_pixel_based_preserve_x
,
4621 window_scroll_pixel_based_preserve_y
4622 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4623 -1, MOVE_TO_Y
| MOVE_TO_X
);
4624 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4628 while (it
.current_y
< this_scroll_margin
)
4630 int prev
= it
.current_y
;
4631 move_it_by_lines (&it
, 1);
4632 if (prev
== it
.current_y
)
4635 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4640 ptrdiff_t charpos
, bytepos
;
4643 /* Save our position, for the
4644 window_scroll_pixel_based_preserve_y case. */
4645 charpos
= IT_CHARPOS (it
);
4646 bytepos
= IT_BYTEPOS (it
);
4648 /* We moved the window start towards BEGV, so PT may be now
4649 in the scroll margin at the bottom. */
4650 move_it_to (&it
, PT
, -1,
4651 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4652 - this_scroll_margin
- 1),
4654 MOVE_TO_POS
| MOVE_TO_Y
);
4656 /* Save our position, in case it's correct. */
4657 charpos
= IT_CHARPOS (it
);
4658 bytepos
= IT_BYTEPOS (it
);
4660 /* See if point is on a partially visible line at the end. */
4661 if (it
.what
== IT_EOB
)
4662 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4665 move_it_by_lines (&it
, 1);
4666 partial_p
= it
.current_y
> it
.last_visible_y
;
4669 if (charpos
== PT
&& !partial_p
4670 && (NILP (Vscroll_preserve_screen_position
)
4671 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4672 /* We found PT before we found the display margin, so PT is ok. */
4674 else if (window_scroll_pixel_based_preserve_y
>= 0)
4676 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4677 start_display (&it
, w
, start
);
4678 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4679 here because we called start_display again and did not
4680 alter it.current_y this time. */
4681 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4682 window_scroll_pixel_based_preserve_y
, -1,
4683 MOVE_TO_Y
| MOVE_TO_X
);
4684 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4689 /* The last line was only partially visible, so back up two
4690 lines to make sure we're on a fully visible line. */
4692 move_it_by_lines (&it
, -2);
4693 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4696 /* No, the position we saved is OK, so use it. */
4697 SET_PT_BOTH (charpos
, bytepos
);
4700 bidi_unshelve_cache (itdata
, 0);
4704 /* Implementation of window_scroll that works based on screen lines.
4705 See the comment of window_scroll for parameter descriptions. */
4708 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4710 register struct window
*w
= XWINDOW (window
);
4711 /* Fvertical_motion enters redisplay, which can trigger
4712 fontification, which in turn can modify buffer text (e.g., if the
4713 fontification functions replace escape sequences with faces, as
4714 in `grep-mode-font-lock-keywords'). So we use a marker to record
4715 the old point position, to prevent crashes in SET_PT_BOTH. */
4716 Lisp_Object opoint_marker
= Fpoint_marker ();
4717 register ptrdiff_t pos
, pos_byte
;
4718 register int ht
= window_internal_height (w
);
4719 register Lisp_Object tem
;
4723 Lisp_Object original_pos
= Qnil
;
4725 /* If scrolling screen-fulls, compute the number of lines to
4726 scroll from the window's height. */
4728 n
*= max (1, ht
- next_screen_context_lines
);
4730 startpos
= marker_position (w
->start
);
4732 if (!NILP (Vscroll_preserve_screen_position
))
4734 if (window_scroll_preserve_vpos
<= 0
4735 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4736 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4738 struct position posit
4739 = *compute_motion (startpos
, 0, 0, 0,
4743 window_scroll_preserve_vpos
= posit
.vpos
;
4744 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4747 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4748 make_number (window_scroll_preserve_vpos
));
4751 XSETFASTINT (tem
, PT
);
4752 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4756 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4761 lose
= n
< 0 && PT
== BEGV
;
4762 Fvertical_motion (make_number (n
), window
);
4766 SET_PT_BOTH (marker_position (opoint_marker
),
4767 marker_byte_position (opoint_marker
));
4774 xsignal0 (Qbeginning_of_buffer
);
4779 /* Don't use a scroll margin that is negative or too large. */
4780 int this_scroll_margin
=
4781 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4783 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4784 w
->start_at_line_beg
= !NILP (bolp
);
4785 w
->update_mode_line
= 1;
4786 w
->last_modified
= 0;
4787 w
->last_overlay_modified
= 0;
4788 /* Set force_start so that redisplay_window will run
4789 the window-scroll-functions. */
4792 if (!NILP (Vscroll_preserve_screen_position
)
4793 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4795 SET_PT_BOTH (pos
, pos_byte
);
4796 Fvertical_motion (original_pos
, window
);
4798 /* If we scrolled forward, put point enough lines down
4799 that it is outside the scroll margin. */
4804 if (this_scroll_margin
> 0)
4806 SET_PT_BOTH (pos
, pos_byte
);
4807 Fvertical_motion (make_number (this_scroll_margin
), window
);
4813 if (top_margin
<= marker_position (opoint_marker
))
4814 SET_PT_BOTH (marker_position (opoint_marker
),
4815 marker_byte_position (opoint_marker
));
4816 else if (!NILP (Vscroll_preserve_screen_position
))
4818 SET_PT_BOTH (pos
, pos_byte
);
4819 Fvertical_motion (original_pos
, window
);
4822 SET_PT (top_margin
);
4828 /* If we scrolled backward, put point near the end of the window
4829 but not within the scroll margin. */
4830 SET_PT_BOTH (pos
, pos_byte
);
4831 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4832 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4835 bottom_margin
= PT
+ 1;
4837 if (bottom_margin
> marker_position (opoint_marker
))
4838 SET_PT_BOTH (marker_position (opoint_marker
),
4839 marker_byte_position (opoint_marker
));
4842 if (!NILP (Vscroll_preserve_screen_position
))
4844 SET_PT_BOTH (pos
, pos_byte
);
4845 Fvertical_motion (original_pos
, window
);
4848 Fvertical_motion (make_number (-1), window
);
4857 xsignal0 (Qend_of_buffer
);
4862 /* Scroll selected_window up or down. If N is nil, scroll a
4863 screen-full which is defined as the height of the window minus
4864 next_screen_context_lines. If N is the symbol `-', scroll.
4865 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4866 up. This is the guts of Fscroll_up and Fscroll_down. */
4869 scroll_command (Lisp_Object n
, int direction
)
4871 ptrdiff_t count
= SPECPDL_INDEX ();
4873 eassert (eabs (direction
) == 1);
4875 /* If selected window's buffer isn't current, make it current for
4876 the moment. But don't screw up if window_scroll gets an error. */
4877 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4879 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4880 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4882 /* Make redisplay consider other windows than just selected_window. */
4883 ++windows_or_buffers_changed
;
4887 window_scroll (selected_window
, direction
, 1, 0);
4888 else if (EQ (n
, Qminus
))
4889 window_scroll (selected_window
, -direction
, 1, 0);
4892 n
= Fprefix_numeric_value (n
);
4893 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4896 unbind_to (count
, Qnil
);
4899 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4900 doc
: /* Scroll text of selected window upward ARG lines.
4901 If ARG is omitted or nil, scroll upward by a near full screen.
4902 A near full screen is `next-screen-context-lines' less than a full screen.
4903 Negative ARG means scroll downward.
4904 If ARG is the atom `-', scroll downward by nearly full screen.
4905 When calling from a program, supply as argument a number, nil, or `-'. */)
4908 scroll_command (arg
, 1);
4912 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4913 doc
: /* Scroll text of selected window down ARG lines.
4914 If ARG is omitted or nil, scroll down by a near full screen.
4915 A near full screen is `next-screen-context-lines' less than a full screen.
4916 Negative ARG means scroll upward.
4917 If ARG is the atom `-', scroll upward by nearly full screen.
4918 When calling from a program, supply as argument a number, nil, or `-'. */)
4921 scroll_command (arg
, -1);
4925 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4926 doc
: /* Return the other window for \"other window scroll\" commands.
4927 If `other-window-scroll-buffer' is non-nil, a window
4928 showing that buffer is used.
4929 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4930 specifies the window. This takes precedence over
4931 `other-window-scroll-buffer'. */)
4936 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4937 && !NILP (Vminibuf_scroll_window
))
4938 window
= Vminibuf_scroll_window
;
4939 /* If buffer is specified, scroll that buffer. */
4940 else if (!NILP (Vother_window_scroll_buffer
))
4942 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4944 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4948 /* Nothing specified; look for a neighboring window on the same
4950 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4952 if (EQ (window
, selected_window
))
4953 /* That didn't get us anywhere; look for a window on another
4956 window
= Fnext_window (window
, Qnil
, Qt
);
4957 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4958 && ! EQ (window
, selected_window
));
4961 CHECK_LIVE_WINDOW (window
);
4963 if (EQ (window
, selected_window
))
4964 error ("There is no other window");
4969 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4970 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4971 A near full screen is `next-screen-context-lines' less than a full screen.
4972 The next window is the one below the current one; or the one at the top
4973 if the current one is at the bottom. Negative ARG means scroll downward.
4974 If ARG is the atom `-', scroll downward by nearly full screen.
4975 When calling from a program, supply as argument a number, nil, or `-'.
4977 If `other-window-scroll-buffer' is non-nil, scroll the window
4978 showing that buffer, popping the buffer up if necessary.
4979 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4980 specifies the window to scroll. This takes precedence over
4981 `other-window-scroll-buffer'. */)
4986 ptrdiff_t count
= SPECPDL_INDEX ();
4988 window
= Fother_window_for_scrolling ();
4989 w
= XWINDOW (window
);
4991 /* Don't screw up if window_scroll gets an error. */
4992 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4993 ++windows_or_buffers_changed
;
4995 Fset_buffer (w
->buffer
);
4996 SET_PT (marker_position (w
->pointm
));
4999 window_scroll (window
, 1, 1, 1);
5000 else if (EQ (arg
, Qminus
))
5001 window_scroll (window
, -1, 1, 1);
5007 window_scroll (window
, XINT (arg
), 0, 1);
5010 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5011 unbind_to (count
, Qnil
);
5016 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5017 doc
: /* Scroll selected window display ARG columns left.
5018 Default for ARG is window width minus 2.
5019 Value is the total amount of leftward horizontal scrolling in
5020 effect after the change.
5021 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5022 lower bound for automatic scrolling, i.e. automatic scrolling
5023 will not scroll a window to a column less than the value returned
5024 by this function. This happens in an interactive call. */)
5025 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5027 struct window
*w
= XWINDOW (selected_window
);
5028 EMACS_INT requested_arg
= (NILP (arg
)
5029 ? window_body_cols (w
) - 2
5030 : XINT (Fprefix_numeric_value (arg
)));
5031 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5033 if (!NILP (set_minimum
))
5034 w
->min_hscroll
= w
->hscroll
;
5039 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5040 doc
: /* Scroll selected window display ARG columns right.
5041 Default for ARG is window width minus 2.
5042 Value is the total amount of leftward horizontal scrolling in
5043 effect after the change.
5044 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5045 lower bound for automatic scrolling, i.e. automatic scrolling
5046 will not scroll a window to a column less than the value returned
5047 by this function. This happens in an interactive call. */)
5048 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5050 struct window
*w
= XWINDOW (selected_window
);
5051 EMACS_INT requested_arg
= (NILP (arg
)
5052 ? window_body_cols (w
) - 2
5053 : XINT (Fprefix_numeric_value (arg
)));
5054 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5056 if (!NILP (set_minimum
))
5057 w
->min_hscroll
= w
->hscroll
;
5062 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5063 doc
: /* Return the window which was selected when entering the minibuffer.
5064 Returns nil, if selected window is not a minibuffer window. */)
5067 if (minibuf_level
> 0
5068 && MINI_WINDOW_P (XWINDOW (selected_window
))
5069 && WINDOW_LIVE_P (minibuf_selected_window
))
5070 return minibuf_selected_window
;
5075 /* Value is the number of lines actually displayed in window W,
5076 as opposed to its height. */
5079 displayed_window_lines (struct window
*w
)
5082 struct text_pos start
;
5083 int height
= window_box_height (w
);
5084 struct buffer
*old_buffer
;
5086 void *itdata
= NULL
;
5088 if (XBUFFER (w
->buffer
) != current_buffer
)
5090 old_buffer
= current_buffer
;
5091 set_buffer_internal (XBUFFER (w
->buffer
));
5096 /* In case W->start is out of the accessible range, do something
5097 reasonable. This happens in Info mode when Info-scroll-down
5098 calls (recenter -1) while W->start is 1. */
5099 if (XMARKER (w
->start
)->charpos
< BEGV
)
5100 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5101 else if (XMARKER (w
->start
)->charpos
> ZV
)
5102 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5104 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5106 itdata
= bidi_shelve_cache ();
5107 start_display (&it
, w
, start
);
5108 move_it_vertically (&it
, height
);
5109 bottom_y
= line_bottom_y (&it
);
5110 bidi_unshelve_cache (itdata
, 0);
5112 /* rms: On a non-window display,
5113 the value of it.vpos at the bottom of the screen
5114 seems to be 1 larger than window_box_height (w).
5115 This kludge fixes a bug whereby (move-to-window-line -1)
5116 when ZV is on the last screen line
5117 moves to the previous screen line instead of the last one. */
5118 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5121 /* Add in empty lines at the bottom of the window. */
5122 if (bottom_y
< height
)
5124 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5125 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5129 set_buffer_internal (old_buffer
);
5135 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5136 doc
: /* Center point in selected window and maybe redisplay frame.
5137 With prefix argument ARG, recenter putting point on screen line ARG
5138 relative to the selected window. If ARG is negative, it counts up from the
5139 bottom of the window. (ARG should be less than the height of the window.)
5141 If ARG is omitted or nil, then recenter with point on the middle line of
5142 the selected window; if the variable `recenter-redisplay' is non-nil,
5143 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5144 is set to `grow-only', this resets the tool-bar's height to the minimum
5145 height needed); if `recenter-redisplay' has the special value `tty',
5146 then only tty frames are redrawn.
5148 Just C-u as prefix means put point in the center of the window
5149 and redisplay normally--don't erase and redraw the frame. */)
5150 (register Lisp_Object arg
)
5152 struct window
*w
= XWINDOW (selected_window
);
5153 struct buffer
*buf
= XBUFFER (w
->buffer
);
5154 struct buffer
*obuf
= current_buffer
;
5156 ptrdiff_t charpos
, bytepos
;
5157 EMACS_INT iarg
IF_LINT (= 0);
5158 int this_scroll_margin
;
5160 /* If redisplay is suppressed due to an error, try again. */
5161 obuf
->display_error_modiff
= 0;
5165 if (!NILP (Vrecenter_redisplay
)
5166 && (!EQ (Vrecenter_redisplay
, Qtty
)
5167 || !NILP (Ftty_type (selected_frame
))))
5171 /* Invalidate pixel data calculated for all compositions. */
5172 for (i
= 0; i
< n_compositions
; i
++)
5173 composition_table
[i
]->font
= NULL
;
5175 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5177 Fredraw_frame (WINDOW_FRAME (w
));
5178 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5183 else if (CONSP (arg
)) /* Just C-u. */
5187 arg
= Fprefix_numeric_value (arg
);
5192 set_buffer_internal (buf
);
5194 /* Do this after making BUF current
5195 in case scroll_margin is buffer-local. */
5196 this_scroll_margin
=
5197 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5199 /* Handle centering on a graphical frame specially. Such frames can
5200 have variable-height lines and centering point on the basis of
5201 line counts would lead to strange effects. */
5202 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5208 void *itdata
= bidi_shelve_cache ();
5210 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5211 start_display (&it
, w
, pt
);
5212 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5213 charpos
= IT_CHARPOS (it
);
5214 bytepos
= IT_BYTEPOS (it
);
5215 bidi_unshelve_cache (itdata
, 0);
5221 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5222 int extra_line_spacing
;
5223 int h
= window_box_height (w
);
5224 void *itdata
= bidi_shelve_cache ();
5226 iarg
= - max (-iarg
, this_scroll_margin
);
5228 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5229 start_display (&it
, w
, pt
);
5231 /* Be sure we have the exact height of the full line containing PT. */
5232 move_it_by_lines (&it
, 0);
5234 /* The amount of pixels we have to move back is the window
5235 height minus what's displayed in the line containing PT,
5236 and the lines below. */
5239 move_it_by_lines (&it
, nlines
);
5241 if (it
.vpos
== nlines
)
5245 /* Last line has no newline */
5246 h
-= line_bottom_y (&it
);
5250 /* Don't reserve space for extra line spacing of last line. */
5251 extra_line_spacing
= it
.max_extra_line_spacing
;
5253 /* If we can't move down NLINES lines because we hit
5254 the end of the buffer, count in some empty lines. */
5255 if (it
.vpos
< nlines
)
5258 extra_line_spacing
= it
.extra_line_spacing
;
5259 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5263 bidi_unshelve_cache (itdata
, 0);
5267 /* Now find the new top line (starting position) of the window. */
5268 start_display (&it
, w
, pt
);
5270 move_it_vertically_backward (&it
, h
);
5272 /* If extra line spacing is present, we may move too far
5273 back. This causes the last line to be only partially
5274 visible (which triggers redisplay to recenter that line
5275 in the middle), so move forward.
5276 But ignore extra line spacing on last line, as it is not
5277 considered to be part of the visible height of the line.
5279 h
+= extra_line_spacing
;
5280 while (-it
.current_y
> h
)
5281 move_it_by_lines (&it
, 1);
5283 charpos
= IT_CHARPOS (it
);
5284 bytepos
= IT_BYTEPOS (it
);
5286 bidi_unshelve_cache (itdata
, 0);
5290 struct position pos
;
5292 iarg
= max (iarg
, this_scroll_margin
);
5294 pos
= *vmotion (PT
, -iarg
, w
);
5295 charpos
= pos
.bufpos
;
5296 bytepos
= pos
.bytepos
;
5301 struct position pos
;
5302 int ht
= window_internal_height (w
);
5309 /* Don't let it get into the margin at either top or bottom. */
5310 iarg
= max (iarg
, this_scroll_margin
);
5311 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5313 pos
= *vmotion (PT
, - iarg
, w
);
5314 charpos
= pos
.bufpos
;
5315 bytepos
= pos
.bytepos
;
5318 /* Set the new window start. */
5319 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5320 wset_window_end_valid (w
, Qnil
);
5322 w
->optional_new_start
= 1;
5324 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5325 FETCH_BYTE (bytepos
- 1) == '\n');
5327 set_buffer_internal (obuf
);
5331 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5333 doc
: /* Return the height in lines of the text display area of WINDOW.
5334 WINDOW must be a live window and defaults to the selected one.
5336 The returned height does not include the mode line, any header line,
5337 nor any partial-height lines at the bottom of the text area. */)
5338 (Lisp_Object window
)
5340 struct window
*w
= decode_live_window (window
);
5341 int pixel_height
= window_box_height (w
);
5342 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5343 return make_number (line_height
);
5348 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5350 doc
: /* Position point relative to window.
5351 ARG nil means position point at center of window.
5352 Else, ARG specifies vertical position within the window;
5353 zero means top of window, negative means relative to bottom of window. */)
5356 struct window
*w
= XWINDOW (selected_window
);
5360 int this_scroll_margin
;
5363 if (!(BUFFERP (w
->buffer
)
5364 && XBUFFER (w
->buffer
) == current_buffer
))
5365 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5366 when passed below to set_marker_both. */
5367 error ("move-to-window-line called from unrelated buffer");
5369 window
= selected_window
;
5370 start
= marker_position (w
->start
);
5371 if (start
< BEGV
|| start
> ZV
)
5373 int height
= window_internal_height (w
);
5374 Fvertical_motion (make_number (- (height
/ 2)), window
);
5375 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5376 w
->start_at_line_beg
= !NILP (Fbolp ());
5380 Fgoto_char (w
->start
);
5382 lines
= displayed_window_lines (w
);
5385 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5389 XSETFASTINT (arg
, lines
/ 2);
5392 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5395 iarg
= iarg
+ lines
;
5397 #if 0 /* This code would prevent move-to-window-line from moving point
5398 to a place inside the scroll margins (which would cause the
5399 next redisplay to scroll). I wrote this code, but then concluded
5400 it is probably better not to install it. However, it is here
5401 inside #if 0 so as not to lose it. -- rms. */
5403 /* Don't let it get into the margin at either top or bottom. */
5404 iarg
= max (iarg
, this_scroll_margin
);
5405 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5408 arg
= make_number (iarg
);
5411 /* Skip past a partially visible first line. */
5413 XSETINT (arg
, XINT (arg
) + 1);
5415 return Fvertical_motion (arg
, window
);
5420 /***********************************************************************
5421 Window Configuration
5422 ***********************************************************************/
5424 struct save_window_data
5426 struct vectorlike_header header
;
5427 Lisp_Object selected_frame
;
5428 Lisp_Object current_window
;
5429 Lisp_Object current_buffer
;
5430 Lisp_Object minibuf_scroll_window
;
5431 Lisp_Object minibuf_selected_window
;
5432 Lisp_Object root_window
;
5433 Lisp_Object focus_frame
;
5434 /* A vector, each of whose elements is a struct saved_window
5436 Lisp_Object saved_windows
;
5438 /* All fields above are traced by the GC.
5439 From `fame-cols' down, the fields are ignored by the GC. */
5441 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5442 int frame_tool_bar_lines
;
5445 /* This is saved as a Lisp_Vector */
5448 struct vectorlike_header header
;
5450 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5451 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5452 Lisp_Object normal_cols
, normal_lines
;
5453 Lisp_Object hscroll
, min_hscroll
;
5454 Lisp_Object parent
, prev
;
5455 Lisp_Object start_at_line_beg
;
5456 Lisp_Object display_table
;
5457 Lisp_Object left_margin_cols
, right_margin_cols
;
5458 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5459 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5460 Lisp_Object combination_limit
, window_parameters
;
5463 #define SAVED_WINDOW_N(swv,n) \
5464 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5466 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5467 doc
: /* Return t if OBJECT is a window-configuration object. */)
5468 (Lisp_Object object
)
5470 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5473 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5474 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5475 (Lisp_Object config
)
5477 register struct save_window_data
*data
;
5478 struct Lisp_Vector
*saved_windows
;
5480 CHECK_WINDOW_CONFIGURATION (config
);
5482 data
= (struct save_window_data
*) XVECTOR (config
);
5483 saved_windows
= XVECTOR (data
->saved_windows
);
5484 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5487 DEFUN ("set-window-configuration", Fset_window_configuration
,
5488 Sset_window_configuration
, 1, 1, 0,
5489 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5490 CONFIGURATION must be a value previously returned
5491 by `current-window-configuration' (which see).
5492 If CONFIGURATION was made from a frame that is now deleted,
5493 only frame-independent values can be restored. In this case,
5494 the return value is nil. Otherwise the value is t. */)
5495 (Lisp_Object configuration
)
5497 register struct save_window_data
*data
;
5498 struct Lisp_Vector
*saved_windows
;
5499 Lisp_Object new_current_buffer
;
5502 ptrdiff_t old_point
= -1;
5504 CHECK_WINDOW_CONFIGURATION (configuration
);
5506 data
= (struct save_window_data
*) XVECTOR (configuration
);
5507 saved_windows
= XVECTOR (data
->saved_windows
);
5509 new_current_buffer
= data
->current_buffer
;
5510 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5511 new_current_buffer
= Qnil
;
5514 if (XBUFFER (new_current_buffer
) == current_buffer
)
5515 /* The code further down "preserves point" by saving here PT in
5516 old_point and then setting it later back into PT. When the
5517 current-selected-window and the final-selected-window both show
5518 the current buffer, this suffers from the problem that the
5519 current PT is the window-point of the current-selected-window,
5520 while the final PT is the point of the final-selected-window, so
5521 this copy from one PT to the other would end up moving the
5522 window-point of the final-selected-window to the window-point of
5523 the current-selected-window. So we have to be careful which
5524 point of the current-buffer we copy into old_point. */
5525 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5526 && WINDOWP (selected_window
)
5527 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5528 && !EQ (selected_window
, data
->current_window
))
5529 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5533 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5534 point in new_current_buffer as of the last time this buffer was
5535 used. This can be non-deterministic since it can be changed by
5536 things like jit-lock by mere temporary selection of some random
5537 window that happens to show this buffer.
5538 So if possible we want this arbitrary choice of "which point" to
5539 be the one from the to-be-selected-window so as to prevent this
5540 window's cursor from being copied from another window. */
5541 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5542 /* If current_window = selected_window, its point is in BUF_PT. */
5543 && !EQ (selected_window
, data
->current_window
))
5544 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5546 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5549 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5552 /* If f is a dead frame, don't bother rebuilding its window tree.
5553 However, there is other stuff we should still try to do below. */
5554 if (FRAME_LIVE_P (f
))
5557 Lisp_Object dead_windows
= Qnil
;
5558 register Lisp_Object tem
, par
, pers
;
5559 register struct window
*w
;
5560 register struct saved_window
*p
;
5561 struct window
*root_window
;
5562 struct window
**leaf_windows
;
5567 /* If the frame has been resized since this window configuration was
5568 made, we change the frame to the size specified in the
5569 configuration, restore the configuration, and then resize it
5570 back. We keep track of the prevailing height in these variables. */
5571 int previous_frame_lines
= FRAME_LINES (f
);
5572 int previous_frame_cols
= FRAME_COLS (f
);
5573 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5574 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5576 /* Don't do this within the main loop below: This may call Lisp
5577 code and is thus potentially unsafe while input is blocked. */
5578 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5580 p
= SAVED_WINDOW_N (saved_windows
, k
);
5582 w
= XWINDOW (window
);
5583 if (!NILP (w
->buffer
)
5584 && !EQ (w
->buffer
, p
->buffer
)
5585 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5586 /* If a window we restore gets another buffer, record the
5587 window's old buffer. */
5588 call1 (Qrecord_window_buffer
, window
);
5591 /* The mouse highlighting code could get screwed up
5592 if it runs during this. */
5595 if (data
->frame_lines
!= previous_frame_lines
5596 || data
->frame_cols
!= previous_frame_cols
)
5597 change_frame_size (f
, data
->frame_lines
,
5598 data
->frame_cols
, 0, 0, 0);
5599 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5600 if (data
->frame_menu_bar_lines
5601 != previous_frame_menu_bar_lines
)
5602 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5604 #ifdef HAVE_WINDOW_SYSTEM
5605 if (data
->frame_tool_bar_lines
5606 != previous_frame_tool_bar_lines
)
5607 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5612 /* "Swap out" point from the selected window's buffer
5613 into the window itself. (Normally the pointm of the selected
5614 window holds garbage.) We do this now, before
5615 restoring the window contents, and prevent it from
5616 being done later on when we select a new window. */
5617 if (! NILP (XWINDOW (selected_window
)->buffer
))
5619 w
= XWINDOW (selected_window
);
5620 set_marker_both (w
->pointm
,
5622 BUF_PT (XBUFFER (w
->buffer
)),
5623 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5626 windows_or_buffers_changed
++;
5627 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5629 /* Problem: Freeing all matrices and later allocating them again
5630 is a serious redisplay flickering problem. What we would
5631 really like to do is to free only those matrices not reused
5633 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5634 leaf_windows
= alloca (count_windows (root_window
)
5635 * sizeof *leaf_windows
);
5636 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5639 Mark all windows now on frame as "deleted".
5640 Restoring the new configuration "undeletes" any that are in it.
5642 Save their current buffers in their height fields, since we may
5643 need it later, if a buffer saved in the configuration is now
5645 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5647 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5649 p
= SAVED_WINDOW_N (saved_windows
, k
);
5651 w
= XWINDOW (window
);
5652 wset_next (w
, Qnil
);
5654 if (!NILP (p
->parent
))
5656 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5658 wset_parent (w
, Qnil
);
5660 if (!NILP (p
->prev
))
5663 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5664 wset_next (XWINDOW (w
->prev
), p
->window
);
5668 wset_prev (w
, Qnil
);
5669 if (!NILP (w
->parent
))
5671 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5673 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5674 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5678 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5679 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5684 /* If we squirreled away the buffer in the window's height,
5686 if (BUFFERP (w
->total_lines
))
5687 wset_buffer (w
, w
->total_lines
);
5688 wset_left_col (w
, p
->left_col
);
5689 wset_top_line (w
, p
->top_line
);
5690 wset_total_cols (w
, p
->total_cols
);
5691 wset_total_lines (w
, p
->total_lines
);
5692 wset_normal_cols (w
, p
->normal_cols
);
5693 wset_normal_lines (w
, p
->normal_lines
);
5694 w
->hscroll
= XFASTINT (p
->hscroll
);
5695 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5696 wset_display_table (w
, p
->display_table
);
5697 wset_left_margin_cols (w
, p
->left_margin_cols
);
5698 wset_right_margin_cols (w
, p
->right_margin_cols
);
5699 wset_left_fringe_width (w
, p
->left_fringe_width
);
5700 wset_right_fringe_width (w
, p
->right_fringe_width
);
5701 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5702 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5703 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5704 wset_dedicated (w
, p
->dedicated
);
5705 wset_combination_limit (w
, p
->combination_limit
);
5706 /* Restore any window parameters that have been saved.
5707 Parameters that have not been saved are left alone. */
5708 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5713 if (NILP (XCDR (pers
)))
5715 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5716 if (CONSP (par
) && !NILP (XCDR (par
)))
5717 /* Reset a parameter to nil if and only if it
5718 has a non-nil association. Don't make new
5720 Fsetcdr (par
, Qnil
);
5723 /* Always restore a non-nil value. */
5724 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5728 w
->last_modified
= 0;
5729 w
->last_overlay_modified
= 0;
5731 /* Reinstall the saved buffer and pointers into it. */
5732 if (NILP (p
->buffer
))
5733 /* An internal window. */
5734 wset_buffer (w
, p
->buffer
);
5735 else if (BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5736 /* If saved buffer is alive, install it. */
5738 wset_buffer (w
, p
->buffer
);
5739 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5740 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5741 set_marker_restricted (w
->pointm
, p
->pointm
,
5743 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5744 p
->mark
, w
->buffer
);
5746 /* As documented in Fcurrent_window_configuration, don't
5747 restore the location of point in the buffer which was
5748 current when the window configuration was recorded. */
5749 if (!EQ (p
->buffer
, new_current_buffer
)
5750 && XBUFFER (p
->buffer
) == current_buffer
)
5751 Fgoto_char (w
->pointm
);
5753 else if (!NILP (w
->buffer
)
5754 && BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
5755 /* Keep window's old buffer; make sure the markers are
5758 /* Set window markers at start of visible range. */
5759 if (XMARKER (w
->start
)->buffer
== 0)
5760 set_marker_restricted (w
->start
, make_number (0),
5762 if (XMARKER (w
->pointm
)->buffer
== 0)
5763 set_marker_restricted_both
5764 (w
->pointm
, w
->buffer
,
5765 BUF_PT (XBUFFER (w
->buffer
)),
5766 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5767 w
->start_at_line_beg
= 1;
5770 /* Window has no live buffer, get one. */
5772 /* Get the buffer via other_buffer_safely in order to
5773 avoid showing an unimportant buffer and, if necessary, to
5774 recreate *scratch* in the course (part of Juanma's bs-show
5775 scenario from March 2011). */
5776 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5777 /* This will set the markers to beginning of visible
5779 set_marker_restricted (w
->start
,
5780 make_number (0), w
->buffer
);
5781 set_marker_restricted (w
->pointm
,
5782 make_number (0), w
->buffer
);
5783 w
->start_at_line_beg
= 1;
5784 if (!NILP (w
->dedicated
))
5785 /* Record this window as dead. */
5786 dead_windows
= Fcons (window
, dead_windows
);
5787 /* Make sure window is no more dedicated. */
5788 wset_dedicated (w
, Qnil
);
5792 fset_root_window (f
, data
->root_window
);
5793 /* Arrange *not* to restore point in the buffer that was
5794 current when the window configuration was saved. */
5795 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5796 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5797 make_number (old_point
),
5798 XWINDOW (data
->current_window
)->buffer
);
5800 /* In the following call to `select-window', prevent "swapping out
5801 point" in the old selected window using the buffer that has
5802 been restored into it. We already swapped out that point from
5803 that window's old buffer. */
5804 select_window (data
->current_window
, Qnil
, 1);
5805 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5808 if (NILP (data
->focus_frame
)
5809 || (FRAMEP (data
->focus_frame
)
5810 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5811 Fredirect_frame_focus (frame
, data
->focus_frame
);
5813 /* Set the screen height to the value it had before this function. */
5814 if (previous_frame_lines
!= FRAME_LINES (f
)
5815 || previous_frame_cols
!= FRAME_COLS (f
))
5816 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5818 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5819 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5820 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5822 #ifdef HAVE_WINDOW_SYSTEM
5823 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5824 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5829 /* Now, free glyph matrices in windows that were not reused. */
5830 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5832 if (NILP (leaf_windows
[i
]->buffer
))
5834 /* Assert it's not reused as a combination. */
5835 eassert (NILP (leaf_windows
[i
]->hchild
)
5836 && NILP (leaf_windows
[i
]->vchild
));
5837 free_window_matrices (leaf_windows
[i
]);
5839 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5846 /* Scan dead buffer windows. */
5847 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5849 window
= XCAR (dead_windows
);
5850 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5851 delete_deletable_window (window
);
5854 /* Fselect_window will have made f the selected frame, so we
5855 reselect the proper frame here. Fhandle_switch_frame will change the
5856 selected window too, but that doesn't make the call to
5857 Fselect_window above totally superfluous; it still sets f's
5859 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5860 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5862 run_window_configuration_change_hook (f
);
5865 if (!NILP (new_current_buffer
))
5867 Fset_buffer (new_current_buffer
);
5868 /* If the new current buffer doesn't appear in the selected
5869 window, go to its old point (see bug#12208). */
5870 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5871 Fgoto_char (make_number (old_point
));
5874 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5875 minibuf_selected_window
= data
->minibuf_selected_window
;
5877 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5881 /* Recursively delete all child windows reachable via the next, vchild,
5882 and hchild slots of WINDOW. */
5884 delete_all_child_windows (Lisp_Object window
)
5886 register struct window
*w
;
5888 w
= XWINDOW (window
);
5890 if (!NILP (w
->next
))
5891 /* Delete WINDOW's siblings (we traverse postorderly). */
5892 delete_all_child_windows (w
->next
);
5894 /* See Fset_window_configuration for excuse. */
5895 wset_total_lines (w
, w
->buffer
);
5897 if (!NILP (w
->vchild
))
5899 delete_all_child_windows (w
->vchild
);
5900 wset_vchild (w
, Qnil
);
5902 else if (!NILP (w
->hchild
))
5904 delete_all_child_windows (w
->hchild
);
5905 wset_hchild (w
, Qnil
);
5907 else if (!NILP (w
->buffer
))
5910 unchain_marker (XMARKER (w
->pointm
));
5911 unchain_marker (XMARKER (w
->start
));
5912 wset_buffer (w
, Qnil
);
5915 Vwindow_list
= Qnil
;
5919 count_windows (register struct window
*window
)
5921 register int count
= 1;
5922 if (!NILP (window
->next
))
5923 count
+= count_windows (XWINDOW (window
->next
));
5924 if (!NILP (window
->vchild
))
5925 count
+= count_windows (XWINDOW (window
->vchild
));
5926 if (!NILP (window
->hchild
))
5927 count
+= count_windows (XWINDOW (window
->hchild
));
5932 /* Fill vector FLAT with leaf windows under W, starting at index I.
5933 Value is last index + 1. */
5935 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5939 if (!NILP (w
->hchild
))
5940 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5941 else if (!NILP (w
->vchild
))
5942 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5946 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5953 /* Return a pointer to the glyph W's physical cursor is on. Value is
5954 null if W's current matrix is invalid, so that no meaningful glyph
5957 get_phys_cursor_glyph (struct window
*w
)
5959 struct glyph_row
*row
;
5960 struct glyph
*glyph
;
5961 int hpos
= w
->phys_cursor
.hpos
;
5963 if (!(w
->phys_cursor
.vpos
>= 0
5964 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5967 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5968 if (!row
->enabled_p
)
5973 /* When the window is hscrolled, cursor hpos can legitimately be
5974 out of bounds, but we draw the cursor at the corresponding
5975 window margin in that case. */
5976 if (!row
->reversed_p
&& hpos
< 0)
5978 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
5979 hpos
= row
->used
[TEXT_AREA
] - 1;
5982 if (row
->used
[TEXT_AREA
] > hpos
5984 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
5993 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
5995 register struct saved_window
*p
;
5996 register struct window
*w
;
5997 register Lisp_Object tem
, pers
, par
;
5999 for (;!NILP (window
); window
= w
->next
)
6001 p
= SAVED_WINDOW_N (vector
, i
);
6002 w
= XWINDOW (window
);
6004 wset_temslot (w
, make_number (i
)); i
++;
6006 p
->buffer
= w
->buffer
;
6007 p
->left_col
= w
->left_col
;
6008 p
->top_line
= w
->top_line
;
6009 p
->total_cols
= w
->total_cols
;
6010 p
->total_lines
= w
->total_lines
;
6011 p
->normal_cols
= w
->normal_cols
;
6012 p
->normal_lines
= w
->normal_lines
;
6013 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6014 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6015 p
->display_table
= w
->display_table
;
6016 p
->left_margin_cols
= w
->left_margin_cols
;
6017 p
->right_margin_cols
= w
->right_margin_cols
;
6018 p
->left_fringe_width
= w
->left_fringe_width
;
6019 p
->right_fringe_width
= w
->right_fringe_width
;
6020 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6021 p
->scroll_bar_width
= w
->scroll_bar_width
;
6022 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6023 p
->dedicated
= w
->dedicated
;
6024 p
->combination_limit
= w
->combination_limit
;
6025 p
->window_parameters
= Qnil
;
6027 if (!NILP (Vwindow_persistent_parameters
))
6029 /* Run cycle detection on Vwindow_persistent_parameters. */
6030 Lisp_Object tortoise
, hare
;
6032 hare
= tortoise
= Vwindow_persistent_parameters
;
6033 while (CONSP (hare
))
6040 tortoise
= XCDR (tortoise
);
6042 if (EQ (hare
, tortoise
))
6043 /* Reset Vwindow_persistent_parameters to Qnil. */
6045 Vwindow_persistent_parameters
= Qnil
;
6050 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6054 /* Save values for persistent window parameters. */
6055 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6057 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6059 /* If the window has no value for the parameter,
6061 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6062 p
->window_parameters
);
6064 /* If the window has a value for the parameter,
6066 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6068 p
->window_parameters
);
6073 if (!NILP (w
->buffer
))
6075 /* Save w's value of point in the window configuration. If w
6076 is the selected window, then get the value of point from
6077 the buffer; pointm is garbage in the selected window. */
6078 if (EQ (window
, selected_window
))
6079 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6080 BUF_PT (XBUFFER (w
->buffer
)),
6081 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6083 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6084 XMARKER (p
->pointm
)->insertion_type
6085 = !NILP (Vwindow_point_insertion_type
);
6087 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6088 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6090 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6091 p
->mark
= Fcopy_marker (tem
, Qnil
);
6098 p
->start_at_line_beg
= Qnil
;
6101 if (NILP (w
->parent
))
6104 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6109 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6111 if (!NILP (w
->vchild
))
6112 i
= save_window_save (w
->vchild
, vector
, i
);
6113 if (!NILP (w
->hchild
))
6114 i
= save_window_save (w
->hchild
, vector
, i
);
6120 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6121 Scurrent_window_configuration
, 0, 1, 0,
6122 doc
: /* Return an object representing the current window configuration of FRAME.
6123 If FRAME is nil or omitted, use the selected frame.
6124 This describes the number of windows, their sizes and current buffers,
6125 and for each displayed buffer, where display starts, and the positions of
6126 point and mark. An exception is made for point in the current buffer:
6127 its value is -not- saved.
6128 This also records the currently selected frame, and FRAME's focus
6129 redirection (see `redirect-frame-focus'). The variable
6130 `window-persistent-parameters' specifies which window parameters are
6131 saved by this function. */)
6134 register Lisp_Object tem
;
6135 register int n_windows
;
6136 register struct save_window_data
*data
;
6138 struct frame
*f
= decode_live_frame (frame
);
6140 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6141 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6142 PVEC_WINDOW_CONFIGURATION
);
6144 data
->frame_cols
= FRAME_COLS (f
);
6145 data
->frame_lines
= FRAME_LINES (f
);
6146 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6147 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6148 data
->selected_frame
= selected_frame
;
6149 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6150 XSETBUFFER (data
->current_buffer
, current_buffer
);
6151 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6152 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6153 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6154 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6155 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6156 data
->saved_windows
= tem
;
6157 for (i
= 0; i
< n_windows
; i
++)
6159 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6160 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6161 XSETWINDOW_CONFIGURATION (tem
, data
);
6165 /***********************************************************************
6167 ***********************************************************************/
6169 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6171 doc
: /* Set width of marginal areas of window WINDOW.
6172 WINDOW must be a live window and defaults to the selected one.
6174 Second arg LEFT-WIDTH specifies the number of character cells to
6175 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6176 does the same for the right marginal area. A nil width parameter
6177 means no margin. */)
6178 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6180 struct window
*w
= decode_live_window (window
);
6182 /* Translate negative or zero widths to nil.
6183 Margins that are too wide have to be checked elsewhere. */
6185 if (!NILP (left_width
))
6187 CHECK_NUMBER (left_width
);
6188 if (XINT (left_width
) <= 0)
6192 if (!NILP (right_width
))
6194 CHECK_NUMBER (right_width
);
6195 if (XINT (right_width
) <= 0)
6199 if (!EQ (w
->left_margin_cols
, left_width
)
6200 || !EQ (w
->right_margin_cols
, right_width
))
6202 wset_left_margin_cols (w
, left_width
);
6203 wset_right_margin_cols (w
, right_width
);
6205 adjust_window_margins (w
);
6207 ++windows_or_buffers_changed
;
6208 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6215 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6217 doc
: /* Get width of marginal areas of window WINDOW.
6218 WINDOW must be a live window and defaults to the selected one.
6220 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6221 If a marginal area does not exist, its width will be returned
6223 (Lisp_Object window
)
6225 struct window
*w
= decode_live_window (window
);
6226 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6231 /***********************************************************************
6233 ***********************************************************************/
6235 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6237 doc
: /* Set the fringe widths of window WINDOW.
6238 WINDOW must be a live window and defaults to the selected one.
6240 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6241 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6242 fringe width. If a fringe width arg is nil, that means to use the
6243 frame's default fringe width. Default fringe widths can be set with
6244 the command `set-fringe-style'.
6245 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6246 outside of the display margins. By default, fringes are drawn between
6247 display marginal areas and the text area. */)
6248 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6250 struct window
*w
= decode_live_window (window
);
6251 int outside
= !NILP (outside_margins
);
6253 if (!NILP (left_width
))
6254 CHECK_NATNUM (left_width
);
6255 if (!NILP (right_width
))
6256 CHECK_NATNUM (right_width
);
6258 /* Do nothing on a tty. */
6259 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6260 && (!EQ (w
->left_fringe_width
, left_width
)
6261 || !EQ (w
->right_fringe_width
, right_width
)
6262 || w
->fringes_outside_margins
!= outside
))
6264 wset_left_fringe_width (w
, left_width
);
6265 wset_right_fringe_width (w
, right_width
);
6266 w
->fringes_outside_margins
= outside
;
6268 adjust_window_margins (w
);
6270 clear_glyph_matrix (w
->current_matrix
);
6271 wset_window_end_valid (w
, Qnil
);
6273 ++windows_or_buffers_changed
;
6274 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6281 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6283 doc
: /* Get width of fringes of window WINDOW.
6284 WINDOW must be a live window and defaults to the selected one.
6286 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6287 (Lisp_Object window
)
6289 struct window
*w
= decode_live_window (window
);
6291 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6292 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6293 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6298 /***********************************************************************
6300 ***********************************************************************/
6302 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6303 Sset_window_scroll_bars
, 2, 4, 0,
6304 doc
: /* Set width and type of scroll bars of window WINDOW.
6305 WINDOW must be a live window and defaults to the selected one.
6307 Second parameter WIDTH specifies the pixel width for the scroll bar;
6308 this is automatically adjusted to a multiple of the frame column width.
6309 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6310 bar: left, right, or nil.
6311 If WIDTH is nil, use the frame's scroll-bar width.
6312 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6313 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6314 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6316 struct window
*w
= decode_live_window (window
);
6320 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6322 if (XINT (width
) == 0)
6323 vertical_type
= Qnil
;
6326 if (!(NILP (vertical_type
)
6327 || EQ (vertical_type
, Qleft
)
6328 || EQ (vertical_type
, Qright
)
6329 || EQ (vertical_type
, Qt
)))
6330 error ("Invalid type of vertical scroll bar");
6332 if (!EQ (w
->scroll_bar_width
, width
)
6333 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6335 wset_scroll_bar_width (w
, width
);
6336 wset_vertical_scroll_bar_type (w
, vertical_type
);
6338 adjust_window_margins (w
);
6340 clear_glyph_matrix (w
->current_matrix
);
6341 wset_window_end_valid (w
, Qnil
);
6343 ++windows_or_buffers_changed
;
6344 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6351 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6353 doc
: /* Get width and type of scroll bars of window WINDOW.
6354 WINDOW must be a live window and defaults to the selected one.
6356 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6357 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6359 (Lisp_Object window
)
6361 struct window
*w
= decode_live_window (window
);
6363 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6364 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6365 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6366 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6367 w
->vertical_scroll_bar_type
, Qnil
);
6372 /***********************************************************************
6374 ***********************************************************************/
6376 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6377 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6378 If WINDOW is omitted or nil, it defaults to the selected window.
6379 Normally, value is a multiple of the canonical character height of WINDOW;
6380 optional second arg PIXELS-P means value is measured in pixels. */)
6381 (Lisp_Object window
, Lisp_Object pixels_p
)
6384 struct window
*w
= decode_live_window (window
);
6385 struct frame
*f
= XFRAME (w
->frame
);
6387 if (FRAME_WINDOW_P (f
))
6388 result
= (NILP (pixels_p
)
6389 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6390 : make_number (-w
->vscroll
));
6392 result
= make_number (0);
6397 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6399 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6400 WINDOW nil means use the selected window. Normally, VSCROLL is a
6401 non-negative multiple of the canonical character height of WINDOW;
6402 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6403 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6404 corresponds to an integral number of pixels. The return value is the
6405 result of this rounding.
6406 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6407 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6409 struct window
*w
= decode_live_window (window
);
6410 struct frame
*f
= XFRAME (w
->frame
);
6412 CHECK_NUMBER_OR_FLOAT (vscroll
);
6414 if (FRAME_WINDOW_P (f
))
6416 int old_dy
= w
->vscroll
;
6418 w
->vscroll
= - (NILP (pixels_p
)
6419 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6420 : XFLOATINT (vscroll
));
6421 w
->vscroll
= min (w
->vscroll
, 0);
6423 if (w
->vscroll
!= old_dy
)
6425 /* Adjust glyph matrix of the frame if the virtual display
6426 area becomes larger than before. */
6427 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6430 /* Prevent redisplay shortcuts. */
6431 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6435 return Fwindow_vscroll (window
, pixels_p
);
6439 /* Call FN for all leaf windows on frame F. FN is called with the
6440 first argument being a pointer to the leaf window, and with
6441 additional argument USER_DATA. Stops when FN returns 0. */
6444 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6447 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6448 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6449 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6453 /* Helper function for foreach_window. Call FN for all leaf windows
6454 reachable from W. FN is called with the first argument being a
6455 pointer to the leaf window, and with additional argument USER_DATA.
6456 Stop when FN returns 0. Value is 0 if stopped by FN. */
6459 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6463 for (cont
= 1; w
&& cont
;)
6465 if (!NILP (w
->hchild
))
6466 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6467 else if (!NILP (w
->vchild
))
6468 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6470 cont
= fn (w
, user_data
);
6472 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6479 /* Freeze or unfreeze the window start of W unless it is a
6480 mini-window or the selected window. FREEZE_P non-null means freeze
6481 the window start. */
6484 freeze_window_start (struct window
*w
, void *freeze_p
)
6486 if (MINI_WINDOW_P (w
)
6487 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6488 && (w
== XWINDOW (selected_window
)
6489 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6490 && ! NILP (Vminibuf_scroll_window
)
6491 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6494 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6499 /* Freeze or unfreeze the window starts of all leaf windows on frame
6500 F, except the selected window and a mini-window. FREEZE_P non-zero
6501 means freeze the window start. */
6504 freeze_window_starts (struct frame
*f
, int freeze_p
)
6506 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6510 /***********************************************************************
6512 ***********************************************************************/
6514 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6515 describe the same state of affairs. This is used by Fequal.
6517 IGNORE_POSITIONS means ignore non-matching scroll positions
6520 This ignores a couple of things like the dedication status of
6521 window, combination_limit and the like. This might have to be
6525 compare_window_configurations (Lisp_Object configuration1
,
6526 Lisp_Object configuration2
,
6527 bool ignore_positions
)
6529 register struct save_window_data
*d1
, *d2
;
6530 struct Lisp_Vector
*sws1
, *sws2
;
6533 CHECK_WINDOW_CONFIGURATION (configuration1
);
6534 CHECK_WINDOW_CONFIGURATION (configuration2
);
6536 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6537 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6538 sws1
= XVECTOR (d1
->saved_windows
);
6539 sws2
= XVECTOR (d2
->saved_windows
);
6541 /* Frame settings must match. */
6542 if (d1
->frame_cols
!= d2
->frame_cols
6543 || d1
->frame_lines
!= d2
->frame_lines
6544 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6545 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6546 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6547 || (!ignore_positions
6548 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6549 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6550 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6551 /* Verify that the two configurations have the same number of windows. */
6552 || sws1
->header
.size
!= sws2
->header
.size
)
6555 for (i
= 0; i
< sws1
->header
.size
; i
++)
6557 struct saved_window
*sw1
, *sw2
;
6559 sw1
= SAVED_WINDOW_N (sws1
, i
);
6560 sw2
= SAVED_WINDOW_N (sws2
, i
);
6563 /* The "current" windows in the two configurations must
6564 correspond to each other. */
6565 EQ (d1
->current_window
, sw1
->window
)
6566 != EQ (d2
->current_window
, sw2
->window
)
6567 /* Windows' buffers must match. */
6568 || !EQ (sw1
->buffer
, sw2
->buffer
)
6569 || !EQ (sw1
->left_col
, sw2
->left_col
)
6570 || !EQ (sw1
->top_line
, sw2
->top_line
)
6571 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6572 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6573 || !EQ (sw1
->display_table
, sw2
->display_table
)
6574 /* The next two disjuncts check the window structure for
6576 || !EQ (sw1
->parent
, sw2
->parent
)
6577 || !EQ (sw1
->prev
, sw2
->prev
)
6578 || (!ignore_positions
6579 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6580 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6581 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6582 || NILP (Fequal (sw1
->start
, sw2
->start
))
6583 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6584 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6585 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6586 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6587 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6588 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6589 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6590 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6591 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6598 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6599 Scompare_window_configurations
, 2, 2, 0,
6600 doc
: /* Compare two window configurations as regards the structure of windows.
6601 This function ignores details such as the values of point and mark
6602 and scrolling positions. */)
6603 (Lisp_Object x
, Lisp_Object y
)
6605 if (compare_window_configurations (x
, y
, 1))
6611 init_window_once (void)
6613 struct frame
*f
= make_initial_frame ();
6614 XSETFRAME (selected_frame
, f
);
6615 Vterminal_frame
= selected_frame
;
6616 minibuf_window
= f
->minibuffer_window
;
6617 selected_window
= f
->selected_window
;
6618 last_nonminibuf_frame
= f
;
6620 window_initialized
= 1;
6626 Vwindow_list
= Qnil
;
6630 syms_of_window (void)
6632 DEFSYM (Qscroll_up
, "scroll-up");
6633 DEFSYM (Qscroll_down
, "scroll-down");
6634 DEFSYM (Qscroll_command
, "scroll-command");
6636 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6637 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6639 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6640 DEFSYM (Qwindowp
, "windowp");
6641 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6642 DEFSYM (Qwindow_live_p
, "window-live-p");
6643 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6644 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6645 DEFSYM (Qdelete_window
, "delete-window");
6646 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6647 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6648 DEFSYM (Qsafe
, "safe");
6649 DEFSYM (Qdisplay_buffer
, "display-buffer");
6650 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6651 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6652 DEFSYM (Qget_mru_window
, "get-mru-window");
6653 DEFSYM (Qwindow_size
, "window-size");
6654 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6655 DEFSYM (Qabove
, "above");
6656 DEFSYM (Qbelow
, "below");
6657 DEFSYM (Qclone_of
, "clone-of");
6659 staticpro (&Vwindow_list
);
6661 minibuf_selected_window
= Qnil
;
6662 staticpro (&minibuf_selected_window
);
6664 window_scroll_pixel_based_preserve_x
= -1;
6665 window_scroll_pixel_based_preserve_y
= -1;
6666 window_scroll_preserve_hpos
= -1;
6667 window_scroll_preserve_vpos
= -1;
6669 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6670 doc
: /* Non-nil means call as function to display a help buffer.
6671 The function is called with one argument, the buffer to be displayed.
6672 Used by `with-output-to-temp-buffer'.
6673 If this function is used, then it must do the entire job of showing
6674 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6675 Vtemp_buffer_show_function
= Qnil
;
6677 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6678 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6679 Vminibuf_scroll_window
= Qnil
;
6681 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6682 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6683 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6684 is displayed in the `mode-line' face. */);
6685 mode_line_in_non_selected_windows
= 1;
6687 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6688 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6689 Vother_window_scroll_buffer
= Qnil
;
6691 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6692 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6693 auto_window_vscroll_p
= 1;
6695 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6696 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6697 next_screen_context_lines
= 2;
6699 DEFVAR_LISP ("scroll-preserve-screen-position",
6700 Vscroll_preserve_screen_position
,
6701 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6702 A value of nil means point does not keep its screen position except
6703 at the scroll margin or window boundary respectively.
6704 A value of t means point keeps its screen position if the scroll
6705 command moved it vertically out of the window, e.g. when scrolling
6707 Any other value means point always keeps its screen position.
6708 Scroll commands should have the `scroll-command' property
6709 on their symbols to be controlled by this variable. */);
6710 Vscroll_preserve_screen_position
= Qnil
;
6712 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6713 doc
: /* Type of marker to use for `window-point'. */);
6714 Vwindow_point_insertion_type
= Qnil
;
6716 DEFVAR_LISP ("window-configuration-change-hook",
6717 Vwindow_configuration_change_hook
,
6718 doc
: /* Functions to call when window configuration changes.
6719 The buffer-local part is run once per window, with the relevant window
6720 selected; while the global part is run only once for the modified frame,
6721 with the relevant frame selected. */);
6722 Vwindow_configuration_change_hook
= Qnil
;
6724 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6725 doc
: /* Non-nil means `recenter' redraws entire frame.
6726 If this option is non-nil, then the `recenter' command with a nil
6727 argument will redraw the entire frame; the special value `tty' causes
6728 the frame to be redrawn only if it is a tty frame. */);
6729 Vrecenter_redisplay
= Qtty
;
6731 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6732 doc
: /* If t, resize window combinations proportionally.
6733 If this variable is nil, splitting a window gets the entire screen space
6734 for displaying the new window from the window to split. Deleting and
6735 resizing a window preferably resizes one adjacent window only.
6737 If this variable is t, splitting a window tries to get the space
6738 proportionally from all windows in the same combination. This also
6739 allows to split a window that is otherwise too small or of fixed size.
6740 Resizing and deleting a window proportionally resize all windows in the
6743 Other values are reserved for future use.
6745 This variable takes no effect if `window-combination-limit' is non-nil. */);
6746 Vwindow_combination_resize
= Qnil
;
6748 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6749 doc
: /* If non-nil, splitting a window makes a new parent window.
6750 The following values are recognized:
6752 nil means splitting a window will create a new parent window only if the
6753 window has no parent window or the window shall become part of a
6754 combination orthogonal to the one it is part of.
6756 `window-size' means that splitting a window for displaying a buffer
6757 makes a new parent window provided `display-buffer' is supposed to
6758 explicitly set the window's size due to the presence of a
6759 `window-height' or `window-width' entry in the alist used by
6760 `display-buffer'. Otherwise, this value is handled like nil.
6762 `temp-buffer' means that splitting a window for displaying a temporary
6763 buffer always makes a new parent window. Otherwise, this value is
6766 `display-buffer' means that splitting a window for displaying a buffer
6767 always makes a new parent window. Since temporary buffers are
6768 displayed by the function `display-buffer', this value is stronger
6769 than `temp-buffer'. Splitting a window for other purpose makes a
6770 new parent window only if needed.
6772 t means that splitting a window always creates a new parent window. If
6773 all splits behave this way, each frame's window tree is a binary
6774 tree and every window but the frame's root window has exactly one
6777 Other values are reserved for future use. */);
6778 Vwindow_combination_limit
= Qwindow_size
;
6780 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6781 doc
: /* Alist of persistent window parameters.
6782 This alist specifies which window parameters shall get saved by
6783 `current-window-configuration' and `window-state-get' and subsequently
6784 restored to their previous values by `set-window-configuration' and
6787 The car of each entry of this alist is the symbol specifying the
6788 parameter. The cdr is one of the following:
6790 nil means the parameter is neither saved by `window-state-get' nor by
6791 `current-window-configuration'.
6793 t means the parameter is saved by `current-window-configuration' and,
6794 provided its WRITABLE argument is nil, by `window-state-get'.
6796 The symbol `writable' means the parameter is saved unconditionally by
6797 both `current-window-configuration' and `window-state-get'. Do not use
6798 this value for parameters without read syntax (like windows or frames).
6800 Parameters not saved by `current-window-configuration' or
6801 `window-state-get' are left alone by `set-window-configuration'
6802 respectively are not installed by `window-state-put'. */);
6803 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6805 defsubr (&Sselected_window
);
6806 defsubr (&Sminibuffer_window
);
6807 defsubr (&Swindow_minibuffer_p
);
6808 defsubr (&Swindowp
);
6809 defsubr (&Swindow_valid_p
);
6810 defsubr (&Swindow_live_p
);
6811 defsubr (&Swindow_frame
);
6812 defsubr (&Sframe_root_window
);
6813 defsubr (&Sframe_first_window
);
6814 defsubr (&Sframe_selected_window
);
6815 defsubr (&Sset_frame_selected_window
);
6816 defsubr (&Spos_visible_in_window_p
);
6817 defsubr (&Swindow_line_height
);
6818 defsubr (&Swindow_buffer
);
6819 defsubr (&Swindow_parent
);
6820 defsubr (&Swindow_top_child
);
6821 defsubr (&Swindow_left_child
);
6822 defsubr (&Swindow_next_sibling
);
6823 defsubr (&Swindow_prev_sibling
);
6824 defsubr (&Swindow_combination_limit
);
6825 defsubr (&Sset_window_combination_limit
);
6826 defsubr (&Swindow_use_time
);
6827 defsubr (&Swindow_top_line
);
6828 defsubr (&Swindow_left_column
);
6829 defsubr (&Swindow_total_height
);
6830 defsubr (&Swindow_total_width
);
6831 defsubr (&Swindow_normal_size
);
6832 defsubr (&Swindow_new_total
);
6833 defsubr (&Swindow_new_normal
);
6834 defsubr (&Sset_window_new_total
);
6835 defsubr (&Sset_window_new_normal
);
6836 defsubr (&Swindow_resize_apply
);
6837 defsubr (&Swindow_body_height
);
6838 defsubr (&Swindow_body_width
);
6839 defsubr (&Swindow_hscroll
);
6840 defsubr (&Sset_window_hscroll
);
6841 defsubr (&Swindow_redisplay_end_trigger
);
6842 defsubr (&Sset_window_redisplay_end_trigger
);
6843 defsubr (&Swindow_edges
);
6844 defsubr (&Swindow_pixel_edges
);
6845 defsubr (&Swindow_absolute_pixel_edges
);
6846 defsubr (&Swindow_inside_edges
);
6847 defsubr (&Swindow_inside_pixel_edges
);
6848 defsubr (&Swindow_inside_absolute_pixel_edges
);
6849 defsubr (&Scoordinates_in_window_p
);
6850 defsubr (&Swindow_at
);
6851 defsubr (&Swindow_point
);
6852 defsubr (&Swindow_start
);
6853 defsubr (&Swindow_end
);
6854 defsubr (&Sset_window_point
);
6855 defsubr (&Sset_window_start
);
6856 defsubr (&Swindow_dedicated_p
);
6857 defsubr (&Sset_window_dedicated_p
);
6858 defsubr (&Swindow_display_table
);
6859 defsubr (&Sset_window_display_table
);
6860 defsubr (&Snext_window
);
6861 defsubr (&Sprevious_window
);
6862 defsubr (&Sget_buffer_window
);
6863 defsubr (&Sdelete_other_windows_internal
);
6864 defsubr (&Sdelete_window_internal
);
6865 defsubr (&Sresize_mini_window_internal
);
6866 defsubr (&Sset_window_buffer
);
6867 defsubr (&Srun_window_configuration_change_hook
);
6868 defsubr (&Sselect_window
);
6869 defsubr (&Sforce_window_update
);
6870 defsubr (&Ssplit_window_internal
);
6871 defsubr (&Sscroll_up
);
6872 defsubr (&Sscroll_down
);
6873 defsubr (&Sscroll_left
);
6874 defsubr (&Sscroll_right
);
6875 defsubr (&Sother_window_for_scrolling
);
6876 defsubr (&Sscroll_other_window
);
6877 defsubr (&Sminibuffer_selected_window
);
6878 defsubr (&Srecenter
);
6879 defsubr (&Swindow_text_height
);
6880 defsubr (&Smove_to_window_line
);
6881 defsubr (&Swindow_configuration_p
);
6882 defsubr (&Swindow_configuration_frame
);
6883 defsubr (&Sset_window_configuration
);
6884 defsubr (&Scurrent_window_configuration
);
6885 defsubr (&Sset_window_margins
);
6886 defsubr (&Swindow_margins
);
6887 defsubr (&Sset_window_fringes
);
6888 defsubr (&Swindow_fringes
);
6889 defsubr (&Sset_window_scroll_bars
);
6890 defsubr (&Swindow_scroll_bars
);
6891 defsubr (&Swindow_vscroll
);
6892 defsubr (&Sset_window_vscroll
);
6893 defsubr (&Scompare_window_configurations
);
6894 defsubr (&Swindow_list
);
6895 defsubr (&Swindow_list_1
);
6896 defsubr (&Swindow_prev_buffers
);
6897 defsubr (&Sset_window_prev_buffers
);
6898 defsubr (&Swindow_next_buffers
);
6899 defsubr (&Sset_window_next_buffers
);
6900 defsubr (&Swindow_parameters
);
6901 defsubr (&Swindow_parameter
);
6902 defsubr (&Sset_window_parameter
);
6906 keys_of_window (void)
6908 initial_define_key (control_x_map
, '<', "scroll-left");
6909 initial_define_key (control_x_map
, '>', "scroll-right");
6911 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6912 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6913 initial_define_key (meta_map
, 'v', "scroll-down-command");