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 */
58 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_valid_p
;
59 static Lisp_Object Qwindow_configuration_p
, Qrecord_window_buffer
;
60 static Lisp_Object Qwindow_deletable_p
, Qdelete_window
, Qdisplay_buffer
;
61 static Lisp_Object Qreplace_buffer_in_windows
, Qget_mru_window
;
62 static Lisp_Object Qwindow_resize_root_window
, Qwindow_resize_root_window_vertically
;
63 static Lisp_Object Qscroll_up
, Qscroll_down
, Qscroll_command
;
64 static Lisp_Object Qsafe
, Qabove
, Qbelow
, Qwindow_size
, Qclone_of
;
66 static int displayed_window_lines (struct window
*);
67 static int count_windows (struct window
*);
68 static int get_leaf_windows (struct window
*, struct window
**, int);
69 static void window_scroll (Lisp_Object
, EMACS_INT
, int, int);
70 static void window_scroll_pixel_based (Lisp_Object
, int, int, int);
71 static void window_scroll_line_based (Lisp_Object
, int, int, int);
72 static int freeze_window_start (struct window
*, void *);
73 static Lisp_Object
window_list (void);
74 static int add_window_to_list (struct window
*, void *);
75 static int candidate_window_p (Lisp_Object
, Lisp_Object
, Lisp_Object
,
77 static Lisp_Object
next_window (Lisp_Object
, Lisp_Object
,
79 static void decode_next_window_args (Lisp_Object
*, Lisp_Object
*,
81 static void foreach_window (struct frame
*,
82 int (* fn
) (struct window
*, void *),
84 static int foreach_window_1 (struct window
*,
85 int (* fn
) (struct window
*, void *),
87 static Lisp_Object
window_list_1 (Lisp_Object
, Lisp_Object
, Lisp_Object
);
88 static int window_resize_check (struct window
*, int);
89 static void window_resize_apply (struct window
*, int);
90 static Lisp_Object
select_window (Lisp_Object
, Lisp_Object
, int);
92 /* This is the window in which the terminal's cursor should
93 be left when nothing is being done with it. This must
94 always be a leaf window, and its buffer is selected by
95 the top level editing loop at the end of each command.
97 This value is always the same as
98 FRAME_SELECTED_WINDOW (selected_frame). */
99 Lisp_Object selected_window
;
101 /* A list of all windows for use by next_window and Fwindow_list.
102 Functions creating or deleting windows should invalidate this cache
103 by setting it to nil. */
104 Lisp_Object Vwindow_list
;
106 /* The mini-buffer window of the selected frame.
107 Note that you cannot test for mini-bufferness of an arbitrary window
108 by comparing against this; but you can test for mini-bufferness of
109 the selected window. */
110 Lisp_Object minibuf_window
;
112 /* Non-nil means it is the window whose mode line should be
113 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Hook run at end of temp_output_buffer_show. */
117 static Lisp_Object Qtemp_buffer_show_hook
;
119 /* Incremented for each window created. */
120 static int sequence_number
;
122 /* Nonzero after init_window_once has finished. */
123 static int window_initialized
;
125 /* Hook to run when window config changes. */
126 static Lisp_Object Qwindow_configuration_change_hook
;
128 /* Used by the function window_scroll_pixel_based */
129 static int window_scroll_pixel_based_preserve_x
;
130 static int window_scroll_pixel_based_preserve_y
;
132 /* Same for window_scroll_line_based. */
133 static EMACS_INT window_scroll_preserve_hpos
;
134 static EMACS_INT window_scroll_preserve_vpos
;
136 /* These setters are used only in this file, so they can be private. */
138 wset_combination_limit (struct window
*w
, Lisp_Object val
)
140 w
->combination_limit
= val
;
143 wset_dedicated (struct window
*w
, Lisp_Object val
)
148 wset_display_table (struct window
*w
, Lisp_Object val
)
150 w
->display_table
= val
;
153 wset_hchild (struct window
*w
, Lisp_Object val
)
158 wset_left_fringe_width (struct window
*w
, Lisp_Object val
)
160 w
->left_fringe_width
= val
;
163 wset_left_margin_cols (struct window
*w
, Lisp_Object val
)
165 w
->left_margin_cols
= val
;
168 wset_new_normal (struct window
*w
, Lisp_Object val
)
173 wset_new_total (struct window
*w
, Lisp_Object val
)
178 wset_normal_cols (struct window
*w
, Lisp_Object val
)
180 w
->normal_cols
= val
;
183 wset_normal_lines (struct window
*w
, Lisp_Object val
)
185 w
->normal_lines
= val
;
188 wset_parent (struct window
*w
, Lisp_Object val
)
193 wset_pointm (struct window
*w
, Lisp_Object val
)
198 wset_right_fringe_width (struct window
*w
, Lisp_Object val
)
200 w
->right_fringe_width
= val
;
203 wset_right_margin_cols (struct window
*w
, Lisp_Object val
)
205 w
->right_margin_cols
= val
;
208 wset_scroll_bar_width (struct window
*w
, Lisp_Object val
)
210 w
->scroll_bar_width
= val
;
213 wset_start (struct window
*w
, Lisp_Object val
)
218 wset_temslot (struct window
*w
, Lisp_Object val
)
223 wset_vchild (struct window
*w
, Lisp_Object val
)
228 wset_vertical_scroll_bar_type (struct window
*w
, Lisp_Object val
)
230 w
->vertical_scroll_bar_type
= val
;
233 wset_window_parameters (struct window
*w
, Lisp_Object val
)
235 w
->window_parameters
= val
;
239 decode_live_window (register Lisp_Object window
)
242 return XWINDOW (selected_window
);
244 CHECK_LIVE_WINDOW (window
);
245 return XWINDOW (window
);
249 decode_any_window (register Lisp_Object window
)
254 return XWINDOW (selected_window
);
256 CHECK_WINDOW (window
);
257 w
= XWINDOW (window
);
261 static struct window
*
262 decode_valid_window (register Lisp_Object window
)
267 return XWINDOW (selected_window
);
269 CHECK_VALID_WINDOW (window
);
270 w
= XWINDOW (window
);
274 /* Build a frequently used 4-integer (X Y W H) list. */
277 list4i (EMACS_INT x
, EMACS_INT y
, EMACS_INT w
, EMACS_INT h
)
279 return list4 (make_number (x
), make_number (y
),
280 make_number (w
), make_number (h
));
283 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
284 doc
: /* Return t if OBJECT is a window and nil otherwise. */)
287 return WINDOWP (object
) ? Qt
: Qnil
;
290 DEFUN ("window-valid-p", Fwindow_valid_p
, Swindow_valid_p
, 1, 1, 0,
291 doc
: /* Return t if OBJECT is a valid window and nil otherwise.
292 A valid window is either a window that displays a buffer or an internal
293 window. Deleted windows are not live. */)
296 return WINDOW_VALID_P (object
) ? Qt
: Qnil
;
299 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
300 doc
: /* Return t if OBJECT is a live window and nil otherwise.
301 A live window is a window that displays a buffer.
302 Internal windows and deleted windows are not live. */)
305 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
308 /* Frames and windows. */
309 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 0, 1, 0,
310 doc
: /* Return the frame that window WINDOW is on.
311 WINDOW must be a valid window and defaults to the selected one. */)
314 return decode_valid_window (window
)->frame
;
317 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
318 doc
: /* Return the root window of FRAME-OR-WINDOW.
319 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
320 With a frame argument, return that frame's root window.
321 With a window argument, return the root window of that window's frame. */)
322 (Lisp_Object frame_or_window
)
326 if (NILP (frame_or_window
))
327 window
= SELECTED_FRAME ()->root_window
;
328 else if (WINDOW_VALID_P (frame_or_window
))
329 window
= XFRAME (XWINDOW (frame_or_window
)->frame
)->root_window
;
332 CHECK_LIVE_FRAME (frame_or_window
);
333 window
= XFRAME (frame_or_window
)->root_window
;
339 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
340 doc
: /* Return the minibuffer window for frame FRAME.
341 If FRAME is omitted or nil, it defaults to the selected frame. */)
344 return FRAME_MINIBUF_WINDOW (decode_live_frame (frame
));
347 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
,
348 Swindow_minibuffer_p
, 0, 1, 0,
349 doc
: /* Return non-nil if WINDOW is a minibuffer window.
350 WINDOW must be a valid window and defaults to the selected one. */)
353 return MINI_WINDOW_P (decode_valid_window (window
)) ? Qt
: Qnil
;
356 /* Don't move this to window.el - this must be a safe routine. */
357 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
358 doc
: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
359 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
360 Else if FRAME-OR-WINDOW denotes a valid window, return the first window
361 of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
362 the first window of that frame. */)
363 (Lisp_Object frame_or_window
)
367 if (NILP (frame_or_window
))
368 window
= SELECTED_FRAME ()->root_window
;
369 else if (WINDOW_VALID_P (frame_or_window
))
370 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->root_window
;
373 CHECK_LIVE_FRAME (frame_or_window
);
374 window
= XFRAME (frame_or_window
)->root_window
;
377 while (NILP (XWINDOW (window
)->buffer
))
379 if (! NILP (XWINDOW (window
)->hchild
))
380 window
= XWINDOW (window
)->hchild
;
381 else if (! NILP (XWINDOW (window
)->vchild
))
382 window
= XWINDOW (window
)->vchild
;
390 DEFUN ("frame-selected-window", Fframe_selected_window
,
391 Sframe_selected_window
, 0, 1, 0,
392 doc
: /* Return the selected window of FRAME-OR-WINDOW.
393 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
394 Else if FRAME-OR-WINDOW denotes a valid window, return the selected
395 window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
396 return the selected window of that frame. */)
397 (Lisp_Object frame_or_window
)
401 if (NILP (frame_or_window
))
402 window
= SELECTED_FRAME ()->selected_window
;
403 else if (WINDOW_VALID_P (frame_or_window
))
404 window
= XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window
)))->selected_window
;
407 CHECK_LIVE_FRAME (frame_or_window
);
408 window
= XFRAME (frame_or_window
)->selected_window
;
414 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
415 Sset_frame_selected_window
, 2, 3, 0,
416 doc
: /* Set selected window of FRAME to WINDOW.
417 FRAME must be a live frame and defaults to the selected one. If FRAME
418 is the selected frame, this makes WINDOW the selected window. Optional
419 argument NORECORD non-nil means to neither change the order of recently
420 selected windows nor the buffer list. WINDOW must denote a live window.
422 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
425 frame
= selected_frame
;
427 CHECK_LIVE_FRAME (frame
);
428 CHECK_LIVE_WINDOW (window
);
430 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
431 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
433 if (EQ (frame
, selected_frame
))
434 return Fselect_window (window
, norecord
);
437 fset_selected_window (XFRAME (frame
), window
);
442 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
443 doc
: /* Return the selected window.
444 The selected window is the window in which the standard cursor for
445 selected windows appears and to which many commands apply. */)
448 return selected_window
;
451 int window_select_count
;
453 /* If select_window is called with inhibit_point_swap non-zero it will
454 not store point of the old selected window's buffer back into that
455 window's pointm slot. This is needed by Fset_window_configuration to
456 avoid that the display routine is called with selected_window set to
457 Qnil causing a subsequent crash. */
459 select_window (Lisp_Object window
, Lisp_Object norecord
, int inhibit_point_swap
)
461 register struct window
*w
;
462 register struct window
*ow
;
465 CHECK_LIVE_WINDOW (window
);
467 w
= XWINDOW (window
);
468 w
->frozen_window_start_p
= 0;
472 w
->use_time
= ++window_select_count
;
473 record_buffer (w
->buffer
);
476 /* Make the selected window's buffer current. */
477 Fset_buffer (w
->buffer
);
479 if (EQ (window
, selected_window
) && !inhibit_point_swap
)
482 sf
= SELECTED_FRAME ();
483 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
485 fset_selected_window (XFRAME (WINDOW_FRAME (w
)), window
);
486 /* Use this rather than Fhandle_switch_frame
487 so that FRAME_FOCUS_FRAME is moved appropriately as we
488 move around in the state where a minibuffer in a separate
490 Fselect_frame (WINDOW_FRAME (w
), norecord
);
491 /* Fselect_frame called us back so we've done all the work already. */
492 eassert (EQ (window
, selected_window
));
496 fset_selected_window (sf
, window
);
498 /* Store the old selected window's buffer's point in pointm of the old
499 selected window. It belongs to that window, and when the window is
500 not selected, must be in the window. */
501 if (!inhibit_point_swap
)
503 ow
= XWINDOW (selected_window
);
504 if (! NILP (ow
->buffer
))
505 set_marker_both (ow
->pointm
, ow
->buffer
,
506 BUF_PT (XBUFFER (ow
->buffer
)),
507 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
510 selected_window
= window
;
511 bset_last_selected_window (XBUFFER (w
->buffer
), window
);
513 /* Go to the point recorded in the window.
514 This is important when the buffer is in more
515 than one window. It also matters when
516 redisplay_window has altered point after scrolling,
517 because it makes the change only in the window. */
519 register ptrdiff_t new_point
= marker_position (w
->pointm
);
520 if (new_point
< BEGV
)
522 else if (new_point
> ZV
)
528 windows_or_buffers_changed
++;
532 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
533 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
534 Also make WINDOW's buffer current and make WINDOW the frame's selected
535 window. Return WINDOW.
537 Optional second arg NORECORD non-nil means do not put this buffer at the
538 front of the buffer list and do not make this window the most recently
541 Note that the main editor command loop sets the current buffer to the
542 buffer of the selected window before each command. */)
543 (register Lisp_Object window
, Lisp_Object norecord
)
545 return select_window (window
, norecord
, 0);
548 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
549 doc
: /* Return the buffer displayed in window WINDOW.
550 If WINDOW is omitted or nil, it defaults to the selected window.
551 Return nil for an internal window or a deleted window. */)
554 return decode_any_window (window
)->buffer
;
557 DEFUN ("window-parent", Fwindow_parent
, Swindow_parent
, 0, 1, 0,
558 doc
: /* Return the parent window of window WINDOW.
559 WINDOW must be a valid window and defaults to the selected one.
560 Return nil for a window with no parent (e.g. a root window). */)
563 return decode_valid_window (window
)->parent
;
566 DEFUN ("window-top-child", Fwindow_top_child
, Swindow_top_child
, 0, 1, 0,
567 doc
: /* Return the topmost child window of window WINDOW.
568 WINDOW must be a valid window and defaults to the selected one.
569 Return nil if WINDOW is a live window (live windows have no children).
570 Return nil if WINDOW is an internal window whose children form a
571 horizontal combination. */)
574 return decode_valid_window (window
)->vchild
;
577 DEFUN ("window-left-child", Fwindow_left_child
, Swindow_left_child
, 0, 1, 0,
578 doc
: /* Return the leftmost child window of window WINDOW.
579 WINDOW must be a valid window and defaults to the selected one.
580 Return nil if WINDOW is a live window (live windows have no children).
581 Return nil if WINDOW is an internal window whose children form a
582 vertical combination. */)
585 return decode_valid_window (window
)->hchild
;
588 DEFUN ("window-next-sibling", Fwindow_next_sibling
, Swindow_next_sibling
, 0, 1, 0,
589 doc
: /* Return the next sibling window of window WINDOW.
590 WINDOW must be a valid window and defaults to the selected one.
591 Return nil if WINDOW has no next sibling. */)
594 return decode_valid_window (window
)->next
;
597 DEFUN ("window-prev-sibling", Fwindow_prev_sibling
, Swindow_prev_sibling
, 0, 1, 0,
598 doc
: /* Return the previous sibling window of window WINDOW.
599 WINDOW must be a valid window and defaults to the selected one.
600 Return nil if WINDOW has no previous sibling. */)
603 return decode_valid_window (window
)->prev
;
606 DEFUN ("window-combination-limit", Fwindow_combination_limit
, Swindow_combination_limit
, 1, 1, 0,
607 doc
: /* Return combination limit of window WINDOW.
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.
612 WINDOW must be a valid window. The return value is meaningful for
613 internal windows only. */)
616 CHECK_VALID_WINDOW (window
);
617 return XWINDOW (window
)->combination_limit
;
620 DEFUN ("set-window-combination-limit", Fset_window_combination_limit
, Sset_window_combination_limit
, 2, 2, 0,
621 doc
: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
622 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
623 siblings. LIMIT t means that child windows of WINDOW are never
624 \(re-)combined with WINDOW's siblings. Other values are reserved for
627 WINDOW must be a valid window. Setting the combination limit is
628 meaningful for internal windows only. */)
629 (Lisp_Object window
, Lisp_Object limit
)
631 wset_combination_limit (decode_valid_window (window
), limit
);
635 DEFUN ("window-use-time", Fwindow_use_time
, Swindow_use_time
, 0, 1, 0,
636 doc
: /* Return the use time of window WINDOW.
637 WINDOW must be a live window and defaults to the selected one.
638 The window with the highest use time is the most recently selected
639 one. The window with the lowest use time is the least recently
643 return make_number (decode_live_window (window
)->use_time
);
646 DEFUN ("window-total-height", Fwindow_total_height
, Swindow_total_height
, 0, 1, 0,
647 doc
: /* Return the total height, in lines, of window WINDOW.
648 WINDOW must be a valid window and defaults to the selected one.
650 The return value includes the mode line and header line, if any.
651 If WINDOW is an internal window, the total height is the height
652 of the screen areas spanned by its children.
654 On a graphical display, this total height is reported as an
655 integer multiple of the default character height. */)
658 return decode_valid_window (window
)->total_lines
;
661 DEFUN ("window-total-width", Fwindow_total_width
, Swindow_total_width
, 0, 1, 0,
662 doc
: /* Return the total width, in columns, of window WINDOW.
663 WINDOW must be a valid window and defaults to the selected one.
665 The return value includes any vertical dividers or scroll bars
666 belonging to WINDOW. If WINDOW is an internal window, the total width
667 is the width of the screen areas spanned by its children.
669 On a graphical display, this total width is reported as an
670 integer multiple of the default character width. */)
673 return decode_valid_window (window
)->total_cols
;
676 DEFUN ("window-new-total", Fwindow_new_total
, Swindow_new_total
, 0, 1, 0,
677 doc
: /* Return the new total size of window WINDOW.
678 WINDOW must be a valid window and defaults to the selected one. */)
681 return decode_valid_window (window
)->new_total
;
684 DEFUN ("window-normal-size", Fwindow_normal_size
, Swindow_normal_size
, 0, 2, 0,
685 doc
: /* Return the normal height of window WINDOW.
686 WINDOW must be a valid window and defaults to the selected one.
687 If HORIZONTAL is non-nil, return the normal width of WINDOW. */)
688 (Lisp_Object window
, Lisp_Object horizontal
)
690 struct window
*w
= decode_valid_window (window
);
692 return NILP (horizontal
) ? w
->normal_lines
: w
->normal_cols
;
695 DEFUN ("window-new-normal", Fwindow_new_normal
, Swindow_new_normal
, 0, 1, 0,
696 doc
: /* Return new normal size of window WINDOW.
697 WINDOW must be a valid window and defaults to the selected one. */)
700 return decode_valid_window (window
)->new_normal
;
703 DEFUN ("window-left-column", Fwindow_left_column
, Swindow_left_column
, 0, 1, 0,
704 doc
: /* Return left column of window WINDOW.
705 This is the distance, in columns, between the left edge of WINDOW and
706 the left edge of the frame's window area. For instance, the return
707 value is 0 if there is no window to the left of WINDOW.
709 WINDOW must be a valid window and defaults to the selected one. */)
712 return decode_valid_window (window
)->left_col
;
715 DEFUN ("window-top-line", Fwindow_top_line
, Swindow_top_line
, 0, 1, 0,
716 doc
: /* Return top line of window WINDOW.
717 This is the distance, in lines, between the top of WINDOW and the top
718 of the frame's window area. For instance, the return value is 0 if
719 there is no window above WINDOW.
721 WINDOW must be a valid window and defaults to the selected one. */)
724 return decode_valid_window (window
)->top_line
;
727 /* Return the number of lines of W's body. Don't count any mode or
731 window_body_lines (struct window
*w
)
733 int height
= XFASTINT (w
->total_lines
);
735 if (!MINI_WINDOW_P (w
))
737 if (WINDOW_WANTS_MODELINE_P (w
))
739 if (WINDOW_WANTS_HEADER_LINE_P (w
))
746 /* Return the number of columns of W's body. Don't count columns
747 occupied by the scroll bar or the vertical bar separating W from its
748 right sibling. On window-systems don't count fringes or display
752 window_body_cols (struct window
*w
)
754 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
755 int width
= XINT (w
->total_cols
);
757 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
758 /* Scroll bars occupy a few columns. */
759 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
760 else if (!FRAME_WINDOW_P (f
)
761 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
762 /* The column of `|' characters separating side-by-side windows
763 occupies one column only. */
766 if (FRAME_WINDOW_P (f
))
767 /* On window-systems, fringes and display margins cannot be
768 used for normal text. */
769 width
-= (WINDOW_FRINGE_COLS (w
)
770 + WINDOW_LEFT_MARGIN_COLS (w
)
771 + WINDOW_RIGHT_MARGIN_COLS (w
));
776 DEFUN ("window-body-height", Fwindow_body_height
, Swindow_body_height
, 0, 1, 0,
777 doc
: /* Return the height, in lines, of WINDOW's text area.
778 WINDOW must be a live window and defaults to the selected one.
780 The returned height does not include the mode line or header line.
781 On a graphical display, the height is expressed as an integer multiple
782 of the default character height. If a line at the bottom of the text
783 area is only partially visible, that counts as a whole line; to
784 exclude partially-visible lines, use `window-text-height'. */)
787 return make_number (window_body_lines (decode_live_window (window
)));
790 DEFUN ("window-body-width", Fwindow_body_width
, Swindow_body_width
, 0, 1, 0,
791 doc
: /* Return the width, in columns, of WINDOW's text area.
792 WINDOW must be a live window and defaults to the selected one.
794 The return value does not include any vertical dividers, fringe or
795 marginal areas, or scroll bars. On a graphical display, the width is
796 expressed as an integer multiple of the default character width. */)
799 return make_number (window_body_cols (decode_live_window (window
)));
802 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
803 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
804 WINDOW must be a live window and defaults to the selected one. */)
807 return make_number (decode_live_window (window
)->hscroll
);
810 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
811 range, returning the new amount as a fixnum. */
813 set_window_hscroll (struct window
*w
, EMACS_INT hscroll
)
815 /* Horizontal scrolling has problems with large scroll amounts.
816 It's too slow with long lines, and even with small lines the
817 display can be messed up. For now, though, impose only the limits
818 required by the internal representation: horizontal scrolling must
819 fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
820 (since it's stored in a ptrdiff_t). */
821 ptrdiff_t hscroll_max
= min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
);
822 ptrdiff_t new_hscroll
= clip_to_bounds (0, hscroll
, hscroll_max
);
824 /* Prevent redisplay shortcuts when changing the hscroll. */
825 if (w
->hscroll
!= new_hscroll
)
826 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
828 w
->hscroll
= new_hscroll
;
829 return make_number (new_hscroll
);
832 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
833 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
834 WINDOW must be a live window and defaults to the selected one.
835 Clip the number to a reasonable value if out of range.
836 Return the new number. NCOL should be zero or positive.
838 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
839 window so that the location of point moves off-window. */)
840 (Lisp_Object window
, Lisp_Object ncol
)
843 return set_window_hscroll (decode_live_window (window
), XINT (ncol
));
846 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
847 Swindow_redisplay_end_trigger
, 0, 1, 0,
848 doc
: /* Return WINDOW's redisplay end trigger value.
849 WINDOW must be a live window and defaults to the selected one.
850 See `set-window-redisplay-end-trigger' for more information. */)
853 return decode_live_window (window
)->redisplay_end_trigger
;
856 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
857 Sset_window_redisplay_end_trigger
, 2, 2, 0,
858 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
859 WINDOW must be a live window and defaults to the selected one. VALUE
860 should be a buffer position (typically a marker) or nil. If it is a
861 buffer position, then if redisplay in WINDOW reaches a position beyond
862 VALUE, the functions in `redisplay-end-trigger-functions' are called
863 with two arguments: WINDOW, and the end trigger value. Afterwards the
864 end-trigger value is reset to nil. */)
865 (register Lisp_Object window
, Lisp_Object value
)
867 wset_redisplay_end_trigger (decode_live_window (window
), value
);
871 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
872 doc
: /* Return a list of the edge coordinates of WINDOW.
873 WINDOW must be a valid window and defaults to the selected one.
875 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
876 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
877 0 at top left corner of frame.
879 RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM
880 is one more than the bottommost row occupied by WINDOW. The edges
881 include the space used by WINDOW's scroll bar, display margins, fringes,
882 header line, and/or mode line. For the edges of just the text area, use
883 `window-inside-edges'. */)
886 register struct window
*w
= decode_valid_window (window
);
888 return list4i (WINDOW_LEFT_EDGE_COL (w
), WINDOW_TOP_EDGE_LINE (w
),
889 WINDOW_RIGHT_EDGE_COL (w
), WINDOW_BOTTOM_EDGE_LINE (w
));
892 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
893 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
894 WINDOW must be a valid window and defaults to the selected one.
896 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
897 0, 0 at the top left corner of the frame.
899 RIGHT is one more than the rightmost x position occupied by WINDOW.
900 BOTTOM is one more than the bottommost y position occupied by WINDOW.
901 The pixel edges include the space used by WINDOW's scroll bar, display
902 margins, fringes, header line, and/or mode line. For the pixel edges
903 of just the text area, use `window-inside-pixel-edges'. */)
906 register struct window
*w
= decode_valid_window (window
);
908 return list4i (WINDOW_LEFT_EDGE_X (w
), WINDOW_TOP_EDGE_Y (w
),
909 WINDOW_RIGHT_EDGE_X (w
), WINDOW_BOTTOM_EDGE_Y (w
));
913 calc_absolute_offset (struct window
*w
, int *add_x
, int *add_y
)
915 struct frame
*f
= XFRAME (w
->frame
);
917 #ifdef FRAME_MENUBAR_HEIGHT
918 *add_y
+= FRAME_MENUBAR_HEIGHT (f
);
920 #ifdef FRAME_TOOLBAR_TOP_HEIGHT
921 *add_y
+= FRAME_TOOLBAR_TOP_HEIGHT (f
);
922 #elif FRAME_TOOLBAR_HEIGHT
923 *add_y
+= FRAME_TOOLBAR_HEIGHT (f
);
925 #ifdef FRAME_NS_TITLEBAR_HEIGHT
926 *add_y
+= FRAME_NS_TITLEBAR_HEIGHT (f
);
928 *add_x
= f
->left_pos
;
929 #ifdef FRAME_TOOLBAR_LEFT_WIDTH
930 *add_x
+= FRAME_TOOLBAR_LEFT_WIDTH (f
);
934 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges
,
935 Swindow_absolute_pixel_edges
, 0, 1, 0,
936 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
937 WINDOW must be a valid window and defaults to the selected one.
939 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
940 0, 0 at the top left corner of the display.
942 RIGHT is one more than the rightmost x position occupied by WINDOW.
943 BOTTOM is one more than the bottommost y position occupied by WINDOW.
944 The pixel edges include the space used by WINDOW's scroll bar, display
945 margins, fringes, header line, and/or mode line. For the pixel edges
946 of just the text area, use `window-inside-absolute-pixel-edges'. */)
949 register struct window
*w
= decode_valid_window (window
);
952 calc_absolute_offset (w
, &add_x
, &add_y
);
954 return list4i (WINDOW_LEFT_EDGE_X (w
) + add_x
,
955 WINDOW_TOP_EDGE_Y (w
) + add_y
,
956 WINDOW_RIGHT_EDGE_X (w
) + add_x
,
957 WINDOW_BOTTOM_EDGE_Y (w
) + add_y
);
960 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
961 doc
: /* Return a list of the edge coordinates of WINDOW.
962 WINDOW must be a live window and defaults to the selected one.
964 The returned list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM
965 count by lines, and LEFT and RIGHT count by columns, all relative to 0,
966 0 at top left corner of frame.
968 RIGHT is one more than the rightmost column of WINDOW's text area.
969 BOTTOM is one more than the bottommost row of WINDOW's text area. The
970 inside edges do not include the space used by the WINDOW's scroll bar,
971 display margins, fringes, header line, and/or mode line. */)
974 register struct window
*w
= decode_live_window (window
);
976 return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w
)
977 + WINDOW_LEFT_MARGIN_COLS (w
)
978 + WINDOW_LEFT_FRINGE_COLS (w
)),
979 (WINDOW_TOP_EDGE_LINE (w
)
980 + WINDOW_HEADER_LINE_LINES (w
)),
981 (WINDOW_BOX_RIGHT_EDGE_COL (w
)
982 - WINDOW_RIGHT_MARGIN_COLS (w
)
983 - WINDOW_RIGHT_FRINGE_COLS (w
)),
984 (WINDOW_BOTTOM_EDGE_LINE (w
)
985 - WINDOW_MODE_LINE_LINES (w
)));
988 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
989 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
990 WINDOW must be a live window and defaults to the selected one.
992 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
993 (0,0) at the top left corner of the frame's window area.
995 RIGHT is one more than the rightmost x position of WINDOW's text area.
996 BOTTOM is one more than the bottommost y position of WINDOW's text area.
997 The inside edges do not include the space used by WINDOW's scroll bar,
998 display margins, fringes, header line, and/or mode line. */)
1001 register struct window
*w
= decode_live_window (window
);
1003 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1004 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1005 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
1006 (WINDOW_TOP_EDGE_Y (w
)
1007 + WINDOW_HEADER_LINE_HEIGHT (w
)),
1008 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1009 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1010 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
1011 (WINDOW_BOTTOM_EDGE_Y (w
)
1012 - WINDOW_MODE_LINE_HEIGHT (w
)));
1015 DEFUN ("window-inside-absolute-pixel-edges",
1016 Fwindow_inside_absolute_pixel_edges
,
1017 Swindow_inside_absolute_pixel_edges
, 0, 1, 0,
1018 doc
: /* Return a list of the edge pixel coordinates of WINDOW's text area.
1019 WINDOW must be a live window and defaults to the selected one.
1021 The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
1022 (0,0) at the top left corner of the frame's window area.
1024 RIGHT is one more than the rightmost x position of WINDOW's text area.
1025 BOTTOM is one more than the bottommost y position of WINDOW's text area.
1026 The inside edges do not include the space used by WINDOW's scroll bar,
1027 display margins, fringes, header line, and/or mode line. */)
1028 (Lisp_Object window
)
1030 register struct window
*w
= decode_live_window (window
);
1033 calc_absolute_offset (w
, &add_x
, &add_y
);
1035 return list4i ((WINDOW_BOX_LEFT_EDGE_X (w
)
1036 + WINDOW_LEFT_MARGIN_WIDTH (w
)
1037 + WINDOW_LEFT_FRINGE_WIDTH (w
) + add_x
),
1038 (WINDOW_TOP_EDGE_Y (w
)
1039 + WINDOW_HEADER_LINE_HEIGHT (w
) + add_y
),
1040 (WINDOW_BOX_RIGHT_EDGE_X (w
)
1041 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
1042 - WINDOW_RIGHT_FRINGE_WIDTH (w
) + add_x
),
1043 (WINDOW_BOTTOM_EDGE_Y (w
)
1044 - WINDOW_MODE_LINE_HEIGHT (w
) + add_y
));
1047 /* Test if the character at column X, row Y is within window W.
1048 If it is not, return ON_NOTHING;
1049 if it is in the window's text area, return ON_TEXT;
1050 if it is on the window's modeline, return ON_MODE_LINE;
1051 if it is on the border between the window and its right sibling,
1052 return ON_VERTICAL_BORDER.
1053 if it is on a scroll bar, return ON_SCROLL_BAR.
1054 if it is on the window's top line, return ON_HEADER_LINE;
1055 if it is in left or right fringe of the window,
1056 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
1057 if it is in the marginal area to the left/right of the window,
1058 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
1060 X and Y are frame relative pixel coordinates. */
1062 static enum window_part
1063 coordinates_in_window (register struct window
*w
, int x
, int y
)
1065 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1066 enum window_part part
;
1067 int ux
= FRAME_COLUMN_WIDTH (f
);
1068 int left_x
= WINDOW_LEFT_EDGE_X (w
);
1069 int right_x
= WINDOW_RIGHT_EDGE_X (w
);
1070 int top_y
= WINDOW_TOP_EDGE_Y (w
);
1071 int bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
1072 /* The width of the area where the vertical line can be dragged.
1073 (Between mode lines for instance. */
1074 int grabbable_width
= ux
;
1075 int lmargin_width
, rmargin_width
, text_left
, text_right
;
1077 /* Outside any interesting row or column? */
1078 if (y
< top_y
|| y
>= bottom_y
|| x
< left_x
|| x
>= right_x
)
1081 /* On the mode line or header line? */
1082 if ((WINDOW_WANTS_MODELINE_P (w
)
1083 && y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
1084 && (part
= ON_MODE_LINE
))
1085 || (WINDOW_WANTS_HEADER_LINE_P (w
)
1086 && y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
1087 && (part
= ON_HEADER_LINE
)))
1089 /* If it's under/over the scroll bar portion of the mode/header
1090 line, say it's on the vertical line. That's to be able to
1091 resize windows horizontally in case we're using toolkit scroll
1092 bars. Note: If scrollbars are on the left, the window that
1093 must be eventually resized is that on the left of WINDOW. */
1094 if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1095 && !WINDOW_LEFTMOST_P (w
)
1096 && eabs (x
- left_x
) < grabbable_width
)
1097 || (!WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
1098 && !WINDOW_RIGHTMOST_P (w
)
1099 && eabs (x
- right_x
) < grabbable_width
))
1100 return ON_VERTICAL_BORDER
;
1105 /* In what's below, we subtract 1 when computing right_x because we
1106 want the rightmost pixel, which is given by left_pixel+width-1. */
1107 if (w
->pseudo_window_p
)
1110 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
1114 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
1115 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
1118 /* Outside any interesting column? */
1119 if (x
< left_x
|| x
> right_x
)
1120 return ON_SCROLL_BAR
;
1122 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
1123 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
1125 text_left
= window_box_left (w
, TEXT_AREA
);
1126 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
1128 if (FRAME_WINDOW_P (f
))
1130 if (!w
->pseudo_window_p
1131 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
1132 && !WINDOW_RIGHTMOST_P (w
)
1133 && (eabs (x
- right_x
) < grabbable_width
))
1134 return ON_VERTICAL_BORDER
;
1136 /* Need to say "x > right_x" rather than >=, since on character
1137 terminals, the vertical line's x coordinate is right_x. */
1138 else if (!w
->pseudo_window_p
1139 && !WINDOW_RIGHTMOST_P (w
)
1140 && x
> right_x
- ux
)
1141 return ON_VERTICAL_BORDER
;
1145 if (lmargin_width
> 0
1146 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1147 ? (x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
1148 : (x
< left_x
+ lmargin_width
)))
1149 return ON_LEFT_MARGIN
;
1151 return ON_LEFT_FRINGE
;
1154 if (x
>= text_right
)
1156 if (rmargin_width
> 0
1157 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1158 ? (x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
1159 : (x
>= right_x
- rmargin_width
)))
1160 return ON_RIGHT_MARGIN
;
1162 return ON_RIGHT_FRINGE
;
1165 /* Everything special ruled out - must be on text area */
1169 /* Take X is the frame-relative pixel x-coordinate, and return the
1170 x-coordinate relative to part PART of window W. */
1172 window_relative_x_coord (struct window
*w
, enum window_part part
, int x
)
1174 int left_x
= (w
->pseudo_window_p
) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w
);
1179 return x
- window_box_left (w
, TEXT_AREA
);
1181 case ON_LEFT_FRINGE
:
1184 case ON_RIGHT_FRINGE
:
1185 return x
- left_x
- WINDOW_LEFT_FRINGE_WIDTH (w
);
1187 case ON_LEFT_MARGIN
:
1189 - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1190 ? WINDOW_LEFT_FRINGE_WIDTH (w
) : 0));
1192 case ON_RIGHT_MARGIN
:
1194 - ((w
->pseudo_window_p
)
1195 ? WINDOW_TOTAL_WIDTH (w
)
1196 : WINDOW_BOX_RIGHT_EDGE_X (w
))
1197 + window_box_width (w
, RIGHT_MARGIN_AREA
)
1198 + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1199 ? WINDOW_RIGHT_FRINGE_WIDTH (w
) : 0));
1202 /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER: */
1207 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
1208 Scoordinates_in_window_p
, 2, 2, 0,
1209 doc
: /* Return non-nil if COORDINATES are in WINDOW.
1210 WINDOW must be a live window and defaults to the selected one.
1211 COORDINATES is a cons of the form (X . Y), X and Y being distances
1212 measured in characters from the upper-left corner of the frame.
1213 \(0 . 0) denotes the character in the upper left corner of the
1215 If COORDINATES are in the text portion of WINDOW,
1216 the coordinates relative to the window are returned.
1217 If they are in the mode line of WINDOW, `mode-line' is returned.
1218 If they are in the top mode line of WINDOW, `header-line' is returned.
1219 If they are in the left fringe of WINDOW, `left-fringe' is returned.
1220 If they are in the right fringe of WINDOW, `right-fringe' is returned.
1221 If they are on the border between WINDOW and its right sibling,
1222 `vertical-line' is returned.
1223 If they are in the windows's left or right marginal areas, `left-margin'\n\
1224 or `right-margin' is returned. */)
1225 (register Lisp_Object coordinates
, Lisp_Object window
)
1232 w
= decode_live_window (window
);
1233 f
= XFRAME (w
->frame
);
1234 CHECK_CONS (coordinates
);
1235 lx
= Fcar (coordinates
);
1236 ly
= Fcdr (coordinates
);
1237 CHECK_NUMBER_OR_FLOAT (lx
);
1238 CHECK_NUMBER_OR_FLOAT (ly
);
1239 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1240 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
1242 switch (coordinates_in_window (w
, x
, y
))
1248 /* Convert X and Y to window relative pixel coordinates, and
1249 return the canonical char units. */
1250 x
-= window_box_left (w
, TEXT_AREA
);
1251 y
-= WINDOW_TOP_EDGE_Y (w
);
1252 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
1253 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
1258 case ON_VERTICAL_BORDER
:
1259 return Qvertical_line
;
1261 case ON_HEADER_LINE
:
1262 return Qheader_line
;
1264 case ON_LEFT_FRINGE
:
1265 return Qleft_fringe
;
1267 case ON_RIGHT_FRINGE
:
1268 return Qright_fringe
;
1270 case ON_LEFT_MARGIN
:
1271 return Qleft_margin
;
1273 case ON_RIGHT_MARGIN
:
1274 return Qright_margin
;
1277 /* Historically we are supposed to return nil in this case. */
1286 /* Callback for foreach_window, used in window_from_coordinates.
1287 Check if window W contains coordinates specified by USER_DATA which
1288 is actually a pointer to a struct check_window_data CW.
1290 Check if window W contains coordinates *CW->x and *CW->y. If it
1291 does, return W in *CW->window, as Lisp_Object, and return in
1292 *CW->part the part of the window under coordinates *X,*Y. Return
1293 zero from this function to stop iterating over windows. */
1295 struct check_window_data
1297 Lisp_Object
*window
;
1299 enum window_part
*part
;
1303 check_window_containing (struct window
*w
, void *user_data
)
1305 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1306 enum window_part found
;
1309 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1310 if (found
!= ON_NOTHING
)
1313 XSETWINDOW (*cw
->window
, w
);
1321 /* Find the window containing frame-relative pixel position X/Y and
1322 return it as a Lisp_Object.
1324 If X, Y is on one of the window's special `window_part' elements,
1325 set *PART to the id of that element.
1327 If there is no window under X, Y return nil and leave *PART
1328 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1330 This function was previously implemented with a loop cycling over
1331 windows with Fnext_window, and starting with the frame's selected
1332 window. It turned out that this doesn't work with an
1333 implementation of next_window using Vwindow_list, because
1334 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1335 tree of F when this function is called asynchronously from
1336 note_mouse_highlight. The original loop didn't terminate in this
1340 window_from_coordinates (struct frame
*f
, int x
, int y
,
1341 enum window_part
*part
, int tool_bar_p
)
1344 struct check_window_data cw
;
1345 enum window_part dummy
;
1351 cw
.window
= &window
, cw
.x
= x
, cw
.y
= y
; cw
.part
= part
;
1352 foreach_window (f
, check_window_containing
, &cw
);
1354 /* If not found above, see if it's in the tool bar window, if a tool
1358 && WINDOWP (f
->tool_bar_window
)
1359 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1360 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), x
, y
)
1364 window
= f
->tool_bar_window
;
1370 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1371 doc
: /* Return window containing coordinates X and Y on FRAME.
1372 FRAME must be a live frame and defaults to the selected one.
1373 The top left corner of the frame is considered to be row 0,
1375 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1377 struct frame
*f
= decode_live_frame (frame
);
1379 /* Check that arguments are integers or floats. */
1380 CHECK_NUMBER_OR_FLOAT (x
);
1381 CHECK_NUMBER_OR_FLOAT (y
);
1383 return window_from_coordinates (f
,
1384 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1385 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1386 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1387 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1391 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1392 doc
: /* Return current value of point in WINDOW.
1393 WINDOW must be a live window and defaults to the selected one.
1395 For a nonselected window, this is the value point would have if that
1396 window were selected.
1398 Note that, when WINDOW is selected, the value returned is the same as
1399 that returned by `point' for WINDOW's buffer. It would be more strictly
1400 correct to return the `top-level' value of `point', outside of any
1401 `save-excursion' forms. But that is hard to define. */)
1402 (Lisp_Object window
)
1404 register struct window
*w
= decode_live_window (window
);
1406 if (w
== XWINDOW (selected_window
))
1407 return make_number (BUF_PT (XBUFFER (w
->buffer
)));
1409 return Fmarker_position (w
->pointm
);
1412 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1413 doc
: /* Return position at which display currently starts in WINDOW.
1414 WINDOW must be a live window and defaults to the selected one.
1415 This is updated by redisplay or by calling `set-window-start'. */)
1416 (Lisp_Object window
)
1418 return Fmarker_position (decode_live_window (window
)->start
);
1421 /* This is text temporarily removed from the doc string below.
1423 This function returns nil if the position is not currently known.
1424 That happens when redisplay is preempted and doesn't finish.
1425 If in that case you want to compute where the end of the window would
1426 have been if redisplay had finished, do this:
1428 (goto-char (window-start window))
1429 (vertical-motion (1- (window-height window)) window)
1432 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1433 doc
: /* Return position at which display currently ends in WINDOW.
1434 WINDOW must be a live window and defaults to the selected one.
1435 This is updated by redisplay, when it runs to completion.
1436 Simply changing the buffer text or setting `window-start'
1437 does not update this value.
1438 Return nil if there is no recorded value. (This can happen if the
1439 last redisplay of WINDOW was preempted, and did not finish.)
1440 If UPDATE is non-nil, compute the up-to-date position
1441 if it isn't already recorded. */)
1442 (Lisp_Object window
, Lisp_Object update
)
1445 struct window
*w
= decode_live_window (window
);
1453 #if 0 /* This change broke some things. We should make it later. */
1454 /* If we don't know the end position, return nil.
1455 The user can compute it with vertical-motion if he wants to.
1456 It would be nicer to do it automatically,
1457 but that's so slow that it would probably bother people. */
1458 if (NILP (w
->window_end_valid
))
1463 && (windows_or_buffers_changed
|| NILP (w
->window_end_valid
))
1466 struct text_pos startp
;
1468 struct buffer
*old_buffer
= NULL
;
1469 void *itdata
= NULL
;
1471 /* Cannot use Fvertical_motion because that function doesn't
1472 cope with variable-height lines. */
1473 if (b
!= current_buffer
)
1475 old_buffer
= current_buffer
;
1476 set_buffer_internal (b
);
1479 /* In case W->start is out of the range, use something
1480 reasonable. This situation occurred when loading a file with
1481 `-l' containing a call to `rmail' with subsequent other
1482 commands. At the end, W->start happened to be BEG, while
1483 rmail had already narrowed the buffer. */
1484 if (XMARKER (w
->start
)->charpos
< BEGV
)
1485 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1486 else if (XMARKER (w
->start
)->charpos
> ZV
)
1487 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1489 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1491 itdata
= bidi_shelve_cache ();
1492 start_display (&it
, w
, startp
);
1493 move_it_vertically (&it
, window_box_height (w
));
1494 if (it
.current_y
< it
.last_visible_y
)
1495 move_it_past_eol (&it
);
1496 value
= make_number (IT_CHARPOS (it
));
1497 bidi_unshelve_cache (itdata
, 0);
1500 set_buffer_internal (old_buffer
);
1503 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1508 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1509 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1510 WINDOW must be a live window and defaults to the selected one.
1512 (Lisp_Object window
, Lisp_Object pos
)
1514 register struct window
*w
= decode_live_window (window
);
1516 CHECK_NUMBER_COERCE_MARKER (pos
);
1518 if (w
== XWINDOW (selected_window
))
1520 if (XBUFFER (w
->buffer
) == current_buffer
)
1524 struct buffer
*old_buffer
= current_buffer
;
1526 set_buffer_internal (XBUFFER (w
->buffer
));
1528 set_buffer_internal (old_buffer
);
1533 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1534 /* We have to make sure that redisplay updates the window to show
1535 the new value of point. */
1536 ++windows_or_buffers_changed
;
1542 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1543 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1544 WINDOW must be a live window and defaults to the selected one. Return
1545 POS. Optional third arg NOFORCE non-nil inhibits next redisplay from
1546 overriding motion of point in order to display at this exact start. */)
1547 (Lisp_Object window
, Lisp_Object pos
, Lisp_Object noforce
)
1549 register struct window
*w
= decode_live_window (window
);
1551 CHECK_NUMBER_COERCE_MARKER (pos
);
1552 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1553 /* this is not right, but much easier than doing what is right. */
1554 w
->start_at_line_beg
= 0;
1557 w
->update_mode_line
= 1;
1558 w
->last_modified
= 0;
1559 w
->last_overlay_modified
= 0;
1560 if (!EQ (window
, selected_window
))
1561 windows_or_buffers_changed
++;
1566 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
1567 Spos_visible_in_window_p
, 0, 3, 0,
1568 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
1569 WINDOW must be a live window and defaults to the selected one.
1571 Return nil if that position is scrolled vertically out of view. If a
1572 character is only partially visible, nil is returned, unless the
1573 optional argument PARTIALLY is non-nil. If POS is only out of view
1574 because of horizontal scrolling, return non-nil. If POS is t, it
1575 specifies the position of the last visible glyph in WINDOW. POS
1576 defaults to point in WINDOW; WINDOW defaults to the selected window.
1578 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
1579 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
1580 where X and Y are the pixel coordinates relative to the top left corner
1581 of the window. The remaining elements are omitted if the character after
1582 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
1583 off-window at the top and bottom of the row, ROWH is the height of the
1584 display row, and VPOS is the row number (0-based) containing POS. */)
1585 (Lisp_Object pos
, Lisp_Object window
, Lisp_Object partially
)
1587 register struct window
*w
;
1588 register EMACS_INT posint
;
1589 register struct buffer
*buf
;
1590 struct text_pos top
;
1591 Lisp_Object in_window
= Qnil
;
1592 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
1595 w
= decode_live_window (window
);
1596 buf
= XBUFFER (w
->buffer
);
1597 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1601 else if (!NILP (pos
))
1603 CHECK_NUMBER_COERCE_MARKER (pos
);
1604 posint
= XINT (pos
);
1606 else if (w
== XWINDOW (selected_window
))
1609 posint
= XMARKER (w
->pointm
)->charpos
;
1611 /* If position is above window start or outside buffer boundaries,
1612 or if window start is out of range, position is not visible. */
1614 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
1615 && CHARPOS (top
) >= BUF_BEGV (buf
)
1616 && CHARPOS (top
) <= BUF_ZV (buf
)
1617 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
1618 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
1621 if (!NILP (in_window
) && !NILP (partially
))
1623 Lisp_Object part
= Qnil
;
1625 part
= list4i (rtop
, rbot
, rowh
, vpos
);
1626 in_window
= Fcons (make_number (x
),
1627 Fcons (make_number (y
), part
));
1633 DEFUN ("window-line-height", Fwindow_line_height
,
1634 Swindow_line_height
, 0, 2, 0,
1635 doc
: /* Return height in pixels of text line LINE in window WINDOW.
1636 WINDOW must be a live window and defaults to the selected one.
1638 Return height of current line if LINE is omitted or nil. Return height of
1639 header or mode line if LINE is `header-line' or `mode-line'.
1640 Otherwise, LINE is a text line number starting from 0. A negative number
1641 counts from the end of the window.
1643 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
1644 in pixels of the visible part of the line, VPOS and YPOS are the
1645 vertical position in lines and pixels of the line, relative to the top
1646 of the first text line, and OFFBOT is the number of off-window pixels at
1647 the bottom of the text line. If there are off-window pixels at the top
1648 of the (first) text line, YPOS is negative.
1650 Return nil if window display is not up-to-date. In that case, use
1651 `pos-visible-in-window-p' to obtain the information. */)
1652 (Lisp_Object line
, Lisp_Object window
)
1654 register struct window
*w
;
1655 register struct buffer
*b
;
1656 struct glyph_row
*row
, *end_row
;
1660 w
= decode_live_window (window
);
1662 if (noninteractive
|| w
->pseudo_window_p
)
1665 CHECK_BUFFER (w
->buffer
);
1666 b
= XBUFFER (w
->buffer
);
1668 /* Fail if current matrix is not up-to-date. */
1669 if (NILP (w
->window_end_valid
)
1670 || current_buffer
->clip_changed
1671 || current_buffer
->prevent_redisplay_optimizations_p
1672 || w
->last_modified
< BUF_MODIFF (b
)
1673 || w
->last_overlay_modified
< BUF_OVERLAY_MODIFF (b
))
1679 if (i
< 0 || i
>= w
->current_matrix
->nrows
1680 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
1682 max_y
= window_text_bottom_y (w
);
1686 if (EQ (line
, Qheader_line
))
1688 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
1690 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1691 return row
->enabled_p
? list4i (row
->height
, 0, 0, 0) : Qnil
;
1694 if (EQ (line
, Qmode_line
))
1696 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1697 return (row
->enabled_p
?
1698 list4i (row
->height
,
1699 0, /* not accurate */
1700 (WINDOW_HEADER_LINE_HEIGHT (w
)
1701 + window_text_bottom_y (w
)),
1706 CHECK_NUMBER (line
);
1709 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1710 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1711 max_y
= window_text_bottom_y (w
);
1714 while ((n
< 0 || i
< n
)
1715 && row
<= end_row
&& row
->enabled_p
1716 && row
->y
+ row
->height
< max_y
)
1719 if (row
> end_row
|| !row
->enabled_p
)
1731 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
1732 return list4i (row
->height
+ min (0, row
->y
) - crop
, i
, row
->y
, crop
);
1735 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1737 doc
: /* Return non-nil when WINDOW is dedicated to its buffer.
1738 More precisely, return the value assigned by the last call of
1739 `set-window-dedicated-p' for WINDOW. Return nil if that function was
1740 never called with WINDOW as its argument, or the value set by that
1741 function was internally reset since its last call. WINDOW must be a
1742 live window and defaults to the selected one.
1744 When a window is dedicated to its buffer, `display-buffer' will refrain
1745 from displaying another buffer in it. `get-lru-window' and
1746 `get-largest-window' treat dedicated windows specially.
1747 `delete-windows-on', `replace-buffer-in-windows', `quit-window' and
1748 `kill-buffer' can delete a dedicated window and the containing frame.
1750 Functions like `set-window-buffer' may change the buffer displayed by a
1751 window, unless that window is "strongly" dedicated to its buffer, that
1752 is the value returned by `window-dedicated-p' is t. */)
1753 (Lisp_Object window
)
1755 return decode_live_window (window
)->dedicated
;
1758 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1759 Sset_window_dedicated_p
, 2, 2, 0,
1760 doc
: /* Mark WINDOW as dedicated according to FLAG.
1761 WINDOW must be a live window and defaults to the selected one. FLAG
1762 non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means
1763 mark WINDOW as non-dedicated. Return FLAG.
1765 When a window is dedicated to its buffer, `display-buffer' will refrain
1766 from displaying another buffer in it. `get-lru-window' and
1767 `get-largest-window' treat dedicated windows specially.
1768 `delete-windows-on', `replace-buffer-in-windows', `quit-window',
1769 `quit-restore-window' and `kill-buffer' can delete a dedicated window
1770 and the containing frame.
1772 As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to
1773 its buffer. Functions like `set-window-buffer' may change the buffer
1774 displayed by a window, unless that window is strongly dedicated to its
1775 buffer. If and when `set-window-buffer' displays another buffer in a
1776 window, it also makes sure that the window is no more dedicated. */)
1777 (Lisp_Object window
, Lisp_Object flag
)
1779 wset_dedicated (decode_live_window (window
), flag
);
1783 DEFUN ("window-prev-buffers", Fwindow_prev_buffers
, Swindow_prev_buffers
,
1785 doc
: /* Return buffers previously shown in WINDOW.
1786 WINDOW must be a live window and defaults to the selected one.
1788 The return value is a list of elements (BUFFER WINDOW-START POS),
1789 where BUFFER is a buffer, WINDOW-START is the start position of the
1790 window for that buffer, and POS is a window-specific point value. */)
1791 (Lisp_Object window
)
1793 return decode_live_window (window
)->prev_buffers
;
1796 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers
,
1797 Sset_window_prev_buffers
, 2, 2, 0,
1798 doc
: /* Set WINDOW's previous buffers to PREV-BUFFERS.
1799 WINDOW must be a live window and defaults to the selected one.
1801 PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
1802 where BUFFER is a buffer, WINDOW-START is the start position of the
1803 window for that buffer, and POS is a window-specific point value. */)
1804 (Lisp_Object window
, Lisp_Object prev_buffers
)
1806 wset_prev_buffers (decode_live_window (window
), prev_buffers
);
1807 return prev_buffers
;
1810 DEFUN ("window-next-buffers", Fwindow_next_buffers
, Swindow_next_buffers
,
1812 doc
: /* Return list of buffers recently re-shown in WINDOW.
1813 WINDOW must be a live window and defaults to the selected one. */)
1814 (Lisp_Object window
)
1816 return decode_live_window (window
)->next_buffers
;
1819 DEFUN ("set-window-next-buffers", Fset_window_next_buffers
,
1820 Sset_window_next_buffers
, 2, 2, 0,
1821 doc
: /* Set WINDOW's next buffers to NEXT-BUFFERS.
1822 WINDOW must be a live window and defaults to the selected one.
1823 NEXT-BUFFERS should be a list of buffers. */)
1824 (Lisp_Object window
, Lisp_Object next_buffers
)
1826 wset_next_buffers (decode_live_window (window
), next_buffers
);
1827 return next_buffers
;
1830 DEFUN ("window-parameters", Fwindow_parameters
, Swindow_parameters
,
1832 doc
: /* Return the parameters of WINDOW and their values.
1833 WINDOW must be a valid window and defaults to the selected one. The
1834 return value is a list of elements of the form (PARAMETER . VALUE). */)
1835 (Lisp_Object window
)
1837 return Fcopy_alist (decode_valid_window (window
)->window_parameters
);
1840 DEFUN ("window-parameter", Fwindow_parameter
, Swindow_parameter
,
1842 doc
: /* Return WINDOW's value for PARAMETER.
1843 WINDOW can be any window and defaults to the selected one. */)
1844 (Lisp_Object window
, Lisp_Object parameter
)
1848 result
= Fassq (parameter
, decode_any_window (window
)->window_parameters
);
1849 return CDR_SAFE (result
);
1852 DEFUN ("set-window-parameter", Fset_window_parameter
,
1853 Sset_window_parameter
, 3, 3, 0,
1854 doc
: /* Set WINDOW's value of PARAMETER to VALUE.
1855 WINDOW can be any window and defaults to the selected one.
1857 (Lisp_Object window
, Lisp_Object parameter
, Lisp_Object value
)
1859 register struct window
*w
= decode_any_window (window
);
1860 Lisp_Object old_alist_elt
;
1862 old_alist_elt
= Fassq (parameter
, w
->window_parameters
);
1863 if (NILP (old_alist_elt
))
1864 wset_window_parameters
1865 (w
, Fcons (Fcons (parameter
, value
), w
->window_parameters
));
1867 Fsetcdr (old_alist_elt
, value
);
1871 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1873 doc
: /* Return the display-table that WINDOW is using.
1874 WINDOW must be a live window and defaults to the selected one. */)
1875 (Lisp_Object window
)
1877 return decode_live_window (window
)->display_table
;
1880 /* Get the display table for use on window W. This is either W's
1881 display table or W's buffer's display table. Ignore the specified
1882 tables if they are not valid; if no valid table is specified,
1885 struct Lisp_Char_Table
*
1886 window_display_table (struct window
*w
)
1888 struct Lisp_Char_Table
*dp
= NULL
;
1890 if (DISP_TABLE_P (w
->display_table
))
1891 dp
= XCHAR_TABLE (w
->display_table
);
1892 else if (BUFFERP (w
->buffer
))
1894 struct buffer
*b
= XBUFFER (w
->buffer
);
1896 if (DISP_TABLE_P (BVAR (b
, display_table
)))
1897 dp
= XCHAR_TABLE (BVAR (b
, display_table
));
1898 else if (DISP_TABLE_P (Vstandard_display_table
))
1899 dp
= XCHAR_TABLE (Vstandard_display_table
);
1905 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1906 doc
: /* Set WINDOW's display-table to TABLE.
1907 WINDOW must be a live window and defaults to the selected one. */)
1908 (register Lisp_Object window
, Lisp_Object table
)
1910 wset_display_table (decode_live_window (window
), table
);
1914 /* Record info on buffer window W is displaying
1915 when it is about to cease to display that buffer. */
1917 unshow_buffer (register struct window
*w
)
1924 if (b
!= XMARKER (w
->pointm
)->buffer
)
1928 if (w
== XWINDOW (selected_window
)
1929 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1930 /* Do this except when the selected window's buffer
1931 is being removed from some other window. */
1933 /* last_window_start records the start position that this buffer
1934 had in the last window to be disconnected from it.
1935 Now that this statement is unconditional,
1936 it is possible for the buffer to be displayed in the
1937 selected window, while last_window_start reflects another
1938 window which was recently showing the same buffer.
1939 Some people might say that might be a good thing. Let's see. */
1940 b
->last_window_start
= marker_position (w
->start
);
1942 /* Point in the selected window's buffer
1943 is actually stored in that buffer, and the window's pointm isn't used.
1944 So don't clobber point in that buffer. */
1945 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1946 /* Don't clobber point in current buffer either (this could be
1947 useful in connection with bug#12208).
1948 && XBUFFER (buf) != current_buffer */
1949 /* This line helps to fix Horsley's testbug.el bug. */
1950 && !(WINDOWP (BVAR (b
, last_selected_window
))
1951 && w
!= XWINDOW (BVAR (b
, last_selected_window
))
1952 && EQ (buf
, XWINDOW (BVAR (b
, last_selected_window
))->buffer
)))
1953 temp_set_point_both (b
,
1954 clip_to_bounds (BUF_BEGV (b
),
1955 XMARKER (w
->pointm
)->charpos
,
1957 clip_to_bounds (BUF_BEGV_BYTE (b
),
1958 marker_byte_position (w
->pointm
),
1961 if (WINDOWP (BVAR (b
, last_selected_window
))
1962 && w
== XWINDOW (BVAR (b
, last_selected_window
)))
1963 bset_last_selected_window (b
, Qnil
);
1966 /* Put NEW into the window structure in place of OLD. SETFLAG zero
1967 means change window structure only. Otherwise store geometry and
1968 other settings as well. */
1970 replace_window (Lisp_Object old
, Lisp_Object
new, int setflag
)
1972 register Lisp_Object tem
;
1973 register struct window
*o
= XWINDOW (old
), *n
= XWINDOW (new);
1975 /* If OLD is its frame's root window, then NEW is the new
1976 root window for that frame. */
1977 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1978 fset_root_window (XFRAME (o
->frame
), new);
1982 wset_left_col (n
, o
->left_col
);
1983 wset_top_line (n
, o
->top_line
);
1984 wset_total_cols (n
, o
->total_cols
);
1985 wset_total_lines (n
, o
->total_lines
);
1986 wset_normal_cols (n
, o
->normal_cols
);
1987 wset_normal_cols (o
, make_float (1.0));
1988 wset_normal_lines (n
, o
->normal_lines
);
1989 wset_normal_lines (o
, make_float (1.0));
1990 n
->desired_matrix
= n
->current_matrix
= 0;
1992 memset (&n
->cursor
, 0, sizeof (n
->cursor
));
1993 memset (&n
->last_cursor
, 0, sizeof (n
->last_cursor
));
1994 memset (&n
->phys_cursor
, 0, sizeof (n
->phys_cursor
));
1995 n
->phys_cursor_type
= -1;
1996 n
->phys_cursor_width
= -1;
1997 n
->must_be_updated_p
= 0;
1998 n
->pseudo_window_p
= 0;
1999 wset_window_end_vpos (n
, make_number (0));
2000 wset_window_end_pos (n
, make_number (0));
2001 wset_window_end_valid (n
, Qnil
);
2002 n
->frozen_window_start_p
= 0;
2008 wset_prev (XWINDOW (tem
), new);
2013 wset_next (XWINDOW (tem
), new);
2016 wset_parent (n
, tem
);
2019 if (EQ (XWINDOW (tem
)->vchild
, old
))
2020 wset_vchild (XWINDOW (tem
), new);
2021 if (EQ (XWINDOW (tem
)->hchild
, old
))
2022 wset_hchild (XWINDOW (tem
), new);
2026 /* If window WINDOW and its parent window are iso-combined, merge
2027 WINDOW's children into those of its parent window and mark WINDOW as
2031 recombine_windows (Lisp_Object window
)
2033 struct window
*w
, *p
, *c
;
2034 Lisp_Object parent
, child
;
2037 w
= XWINDOW (window
);
2039 if (!NILP (parent
) && NILP (w
->combination_limit
))
2041 p
= XWINDOW (parent
);
2042 if (((!NILP (p
->vchild
) && !NILP (w
->vchild
))
2043 || (!NILP (p
->hchild
) && !NILP (w
->hchild
))))
2044 /* WINDOW and PARENT are both either a vertical or a horizontal
2047 horflag
= NILP (w
->vchild
);
2048 child
= horflag
? w
->hchild
: w
->vchild
;
2049 c
= XWINDOW (child
);
2051 /* Splice WINDOW's children into its parent's children and
2052 assign new normal sizes. */
2055 wset_hchild (p
, child
);
2057 wset_vchild (p
, child
);
2060 wset_prev (c
, w
->prev
);
2061 wset_next (XWINDOW (w
->prev
), child
);
2066 wset_parent (c
, parent
);
2069 wset_normal_cols (c
,
2070 make_float (XFLOATINT (c
->total_cols
)
2071 / XFLOATINT (p
->total_cols
)));
2073 wset_normal_lines (c
,
2074 make_float (XFLOATINT (c
->total_lines
)
2075 / XFLOATINT (p
->total_lines
)));
2079 if (!NILP (w
->next
))
2081 wset_next (c
, w
->next
);
2082 wset_prev (XWINDOW (c
->next
), child
);
2090 c
= XWINDOW (child
);
2094 /* WINDOW can be deleted now. */
2095 wset_vchild (w
, Qnil
);
2096 wset_hchild (w
, Qnil
);
2101 /* If WINDOW can be deleted, delete it. */
2103 delete_deletable_window (Lisp_Object window
)
2105 if (!NILP (call1 (Qwindow_deletable_p
, window
)))
2106 call1 (Qdelete_window
, window
);
2109 /***********************************************************************
2111 ***********************************************************************/
2113 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
2114 pointer. This is a callback function for foreach_window, used in
2115 the window_list function. */
2118 add_window_to_list (struct window
*w
, void *user_data
)
2120 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
2122 XSETWINDOW (window
, w
);
2123 *list
= Fcons (window
, *list
);
2128 /* Return a list of all windows, for use by next_window. If
2129 Vwindow_list is a list, return that list. Otherwise, build a new
2130 list, cache it in Vwindow_list, and return that. */
2135 if (!CONSP (Vwindow_list
))
2137 Lisp_Object tail
, frame
;
2139 Vwindow_list
= Qnil
;
2140 FOR_EACH_FRAME (tail
, frame
)
2142 Lisp_Object args
[2];
2144 /* We are visiting windows in canonical order, and add
2145 new windows at the front of args[1], which means we
2146 have to reverse this list at the end. */
2148 foreach_window (XFRAME (frame
), add_window_to_list
, &args
[1]);
2149 args
[0] = Vwindow_list
;
2150 args
[1] = Fnreverse (args
[1]);
2151 Vwindow_list
= Fnconc (2, args
);
2155 return Vwindow_list
;
2159 /* Value is non-zero if WINDOW satisfies the constraints given by
2160 OWINDOW, MINIBUF and ALL_FRAMES.
2162 MINIBUF t means WINDOW may be minibuffer windows.
2163 `lambda' means WINDOW may not be a minibuffer window.
2164 a window means a specific minibuffer window
2166 ALL_FRAMES t means search all frames,
2167 nil means search just current frame,
2168 `visible' means search just visible frames on the
2170 0 means search visible and iconified frames on the
2172 a window means search the frame that window belongs to,
2173 a frame means consider windows on that frame, only. */
2176 candidate_window_p (Lisp_Object window
, Lisp_Object owindow
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2178 struct window
*w
= XWINDOW (window
);
2179 struct frame
*f
= XFRAME (w
->frame
);
2180 int candidate_p
= 1;
2182 if (!BUFFERP (w
->buffer
))
2184 else if (MINI_WINDOW_P (w
)
2185 && (EQ (minibuf
, Qlambda
)
2186 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
2188 /* If MINIBUF is `lambda' don't consider any mini-windows.
2189 If it is a window, consider only that one. */
2192 else if (EQ (all_frames
, Qt
))
2194 else if (NILP (all_frames
))
2196 eassert (WINDOWP (owindow
));
2197 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
2199 else if (EQ (all_frames
, Qvisible
))
2201 FRAME_SAMPLE_VISIBILITY (f
);
2202 candidate_p
= FRAME_VISIBLE_P (f
)
2203 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2204 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2207 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
2209 FRAME_SAMPLE_VISIBILITY (f
);
2210 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
2211 #ifdef HAVE_X_WINDOWS
2212 /* Yuck!! If we've just created the frame and the
2213 window-manager requested the user to place it
2214 manually, the window may still not be considered
2215 `visible'. I'd argue it should be at least
2216 something like `iconified', but don't know how to do
2218 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
2219 && !f
->output_data
.x
->has_been_visible
)
2222 && (FRAME_TERMINAL (XFRAME (w
->frame
))
2223 == FRAME_TERMINAL (XFRAME (selected_frame
)));
2225 else if (WINDOWP (all_frames
))
2226 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
2227 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
2228 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
2229 else if (FRAMEP (all_frames
))
2230 candidate_p
= EQ (all_frames
, w
->frame
);
2236 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
2237 Fwindow_list. See candidate_window_p for the meaning of WINDOW,
2238 MINIBUF, and ALL_FRAMES. */
2241 decode_next_window_args (Lisp_Object
*window
, Lisp_Object
*minibuf
, Lisp_Object
*all_frames
)
2243 struct window
*w
= decode_live_window (*window
);
2245 XSETWINDOW (*window
, w
);
2246 /* MINIBUF nil may or may not include minibuffers. Decide if it
2248 if (NILP (*minibuf
))
2249 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
2250 else if (!EQ (*minibuf
, Qt
))
2253 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
2254 => count none of them, or a specific minibuffer window (the
2255 active one) to count. */
2257 /* ALL_FRAMES nil doesn't specify which frames to include. */
2258 if (NILP (*all_frames
))
2260 = (!EQ (*minibuf
, Qlambda
)
2261 ? FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
))
2263 else if (EQ (*all_frames
, Qvisible
))
2265 else if (EQ (*all_frames
, make_number (0)))
2267 else if (FRAMEP (*all_frames
))
2269 else if (!EQ (*all_frames
, Qt
))
2274 /* Return the next or previous window of WINDOW in cyclic ordering
2275 of windows. NEXT_P non-zero means return the next window. See the
2276 documentation string of next-window for the meaning of MINIBUF and
2280 next_window (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
, int next_p
)
2282 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2284 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
2285 return the first window on the frame. */
2286 if (FRAMEP (all_frames
)
2287 && !EQ (all_frames
, XWINDOW (window
)->frame
))
2288 return Fframe_first_window (all_frames
);
2294 /* Find WINDOW in the list of all windows. */
2295 list
= Fmemq (window
, window_list ());
2297 /* Scan forward from WINDOW to the end of the window list. */
2299 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
2300 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2303 /* Scan from the start of the window list up to WINDOW. */
2305 for (list
= Vwindow_list
;
2306 CONSP (list
) && !EQ (XCAR (list
), window
);
2308 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
2312 window
= XCAR (list
);
2316 Lisp_Object candidate
, list
;
2318 /* Scan through the list of windows for candidates. If there are
2319 candidate windows in front of WINDOW, the last one of these
2320 is the one we want. If there are candidates following WINDOW
2321 in the list, again the last one of these is the one we want. */
2323 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
2325 if (EQ (XCAR (list
), window
))
2327 if (WINDOWP (candidate
))
2330 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
2332 candidate
= XCAR (list
);
2335 if (WINDOWP (candidate
))
2343 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
2344 doc
: /* Return live window after WINDOW in the cyclic ordering of windows.
2345 WINDOW must be a live window and defaults to the selected one. The
2346 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2349 MINIBUF nil or omitted means consider the minibuffer window only if the
2350 minibuffer is active. MINIBUF t means consider the minibuffer window
2351 even if the minibuffer is not active. Any other value means do not
2352 consider the minibuffer window even if the minibuffer is active.
2354 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2355 plus the minibuffer window if specified by the MINIBUF argument. If the
2356 minibuffer counts, consider all windows on all frames that share that
2357 minibuffer too. The following non-nil values of ALL-FRAMES have special
2360 - t means consider all windows on all existing frames.
2362 - `visible' means consider all windows on all visible frames.
2364 - 0 (the number zero) means consider all windows on all visible and
2367 - A frame means consider all windows on that frame only.
2369 Anything else means consider all windows on WINDOW's frame and no
2372 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2373 `next-window' to iterate through the entire cycle of acceptable
2374 windows, eventually ending up back at the window you started with.
2375 `previous-window' traverses the same cycle, in the reverse order. */)
2376 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2378 return next_window (window
, minibuf
, all_frames
, 1);
2382 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
2383 doc
: /* Return live window before WINDOW in the cyclic ordering of windows.
2384 WINDOW must be a live window and defaults to the selected one. The
2385 optional arguments MINIBUF and ALL-FRAMES specify the set of windows to
2388 MINIBUF nil or omitted means consider the minibuffer window only if the
2389 minibuffer is active. MINIBUF t means consider the minibuffer window
2390 even if the minibuffer is not active. Any other value means do not
2391 consider the minibuffer window even if the minibuffer is active.
2393 ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame,
2394 plus the minibuffer window if specified by the MINIBUF argument. If the
2395 minibuffer counts, consider all windows on all frames that share that
2396 minibuffer too. The following non-nil values of ALL-FRAMES have special
2399 - t means consider all windows on all existing frames.
2401 - `visible' means consider all windows on all visible frames.
2403 - 0 (the number zero) means consider all windows on all visible and
2406 - A frame means consider all windows on that frame only.
2408 Anything else means consider all windows on WINDOW's frame and no
2411 If you use consistent values for MINIBUF and ALL-FRAMES, you can
2412 use `previous-window' to iterate through the entire cycle of
2413 acceptable windows, eventually ending up back at the window you
2414 started with. `next-window' traverses the same cycle, in the
2416 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2418 return next_window (window
, minibuf
, all_frames
, 0);
2422 /* Return a list of windows in cyclic ordering. Arguments are like
2423 for `next-window'. */
2426 window_list_1 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2428 Lisp_Object tail
, list
, rest
;
2430 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2433 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2434 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2435 list
= Fcons (XCAR (tail
), list
);
2437 /* Rotate the list to start with WINDOW. */
2438 list
= Fnreverse (list
);
2439 rest
= Fmemq (window
, list
);
2440 if (!NILP (rest
) && !EQ (rest
, list
))
2442 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2444 XSETCDR (tail
, Qnil
);
2445 list
= nconc2 (rest
, list
);
2451 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2452 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2453 FRAME nil or omitted means use the selected frame.
2454 WINDOW nil or omitted means use the window selected within FRAME.
2455 MINIBUF t means include the minibuffer window, even if it isn't active.
2456 MINIBUF nil or omitted means include the minibuffer window only
2458 MINIBUF neither nil nor t means never include the minibuffer window. */)
2459 (Lisp_Object frame
, Lisp_Object minibuf
, Lisp_Object window
)
2462 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2463 CHECK_WINDOW (window
);
2465 frame
= selected_frame
;
2467 if (!EQ (frame
, XWINDOW (window
)->frame
))
2468 error ("Window is on a different frame");
2470 return window_list_1 (window
, minibuf
, frame
);
2474 DEFUN ("window-list-1", Fwindow_list_1
, Swindow_list_1
, 0, 3, 0,
2475 doc
: /* Return a list of all live windows.
2476 WINDOW specifies the first window to list and defaults to the selected
2479 Optional argument MINIBUF nil or omitted means consider the minibuffer
2480 window only if the minibuffer is active. MINIBUF t means consider the
2481 minibuffer window even if the minibuffer is not active. Any other value
2482 means do not consider the minibuffer window even if the minibuffer is
2485 Optional argument ALL-FRAMES nil or omitted means consider all windows
2486 on WINDOW's frame, plus the minibuffer window if specified by the
2487 MINIBUF argument. If the minibuffer counts, consider all windows on all
2488 frames that share that minibuffer too. The following non-nil values of
2489 ALL-FRAMES have special meanings:
2491 - t means consider all windows on all existing frames.
2493 - `visible' means consider all windows on all visible frames.
2495 - 0 (the number zero) means consider all windows on all visible and
2498 - A frame means consider all windows on that frame only.
2500 Anything else means consider all windows on WINDOW's frame and no
2503 If WINDOW is not on the list of windows returned, some other window will
2504 be listed first but no error is signaled. */)
2505 (Lisp_Object window
, Lisp_Object minibuf
, Lisp_Object all_frames
)
2507 return window_list_1 (window
, minibuf
, all_frames
);
2510 /* Look at all windows, performing an operation specified by TYPE
2512 If FRAMES is Qt, look at all frames;
2513 Qnil, look at just the selected frame;
2514 Qvisible, look at visible frames;
2515 a frame, just look at windows on that frame.
2516 If MINI is non-zero, perform the operation on minibuffer windows too. */
2521 GET_BUFFER_WINDOW
, /* Arg is buffer */
2522 REPLACE_BUFFER_IN_WINDOWS_SAFELY
, /* Arg is buffer */
2523 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2528 window_loop (enum window_loop type
, Lisp_Object obj
, int mini
, Lisp_Object frames
)
2530 Lisp_Object window
, windows
, best_window
, frame_arg
;
2531 int frame_best_window_flag
= 0;
2533 struct gcpro gcpro1
;
2535 /* If we're only looping through windows on a particular frame,
2536 frame points to that frame. If we're looping through windows
2537 on all frames, frame is 0. */
2538 if (FRAMEP (frames
))
2539 f
= XFRAME (frames
);
2540 else if (NILP (frames
))
2541 f
= SELECTED_FRAME ();
2546 frame_arg
= Qlambda
;
2547 else if (EQ (frames
, make_number (0)))
2549 else if (EQ (frames
, Qvisible
))
2554 /* frame_arg is Qlambda to stick to one frame,
2555 Qvisible to consider all visible frames,
2558 /* Pick a window to start with. */
2562 window
= FRAME_SELECTED_WINDOW (f
);
2564 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2566 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2570 for (; CONSP (windows
); windows
= XCDR (windows
))
2574 window
= XCAR (windows
);
2575 w
= XWINDOW (window
);
2577 /* Note that we do not pay attention here to whether the frame
2578 is visible, since Fwindow_list skips non-visible frames if
2579 that is desired, under the control of frame_arg. */
2580 if (!MINI_WINDOW_P (w
)
2581 /* For REPLACE_BUFFER_IN_WINDOWS_SAFELY, we must always
2582 consider all windows. */
2583 || type
== REPLACE_BUFFER_IN_WINDOWS_SAFELY
2584 || (mini
&& minibuf_level
> 0))
2587 case GET_BUFFER_WINDOW
:
2588 if (EQ (w
->buffer
, obj
)
2589 /* Don't find any minibuffer window except the one that
2590 is currently in use. */
2591 && (MINI_WINDOW_P (w
) ? EQ (window
, minibuf_window
) : 1))
2593 if (EQ (window
, selected_window
))
2594 /* Preferably return the selected window. */
2595 RETURN_UNGCPRO (window
);
2596 else if (EQ (XWINDOW (window
)->frame
, selected_frame
)
2597 && !frame_best_window_flag
)
2598 /* Prefer windows on the current frame (but don't
2599 choose another one if we have one already). */
2601 best_window
= window
;
2602 frame_best_window_flag
= 1;
2604 else if (NILP (best_window
))
2605 best_window
= window
;
2609 case REPLACE_BUFFER_IN_WINDOWS_SAFELY
:
2610 /* We could simply check whether the buffer shown by window
2611 is live, and show another buffer in case it isn't. */
2612 if (EQ (w
->buffer
, obj
))
2614 /* Undedicate WINDOW. */
2615 wset_dedicated (w
, Qnil
);
2616 /* Make WINDOW show the buffer returned by
2617 other_buffer_safely, don't run any hooks. */
2619 (window
, other_buffer_safely (w
->buffer
), 0, 0);
2620 /* If WINDOW is the selected window, make its buffer
2621 current. But do so only if the window shows the
2622 current buffer (Bug#6454). */
2623 if (EQ (window
, selected_window
)
2624 && XBUFFER (w
->buffer
) == current_buffer
)
2625 Fset_buffer (w
->buffer
);
2629 case REDISPLAY_BUFFER_WINDOWS
:
2630 if (EQ (w
->buffer
, obj
))
2632 mark_window_display_accurate (window
, 0);
2633 w
->update_mode_line
= 1;
2634 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2635 ++update_mode_lines
;
2636 best_window
= window
;
2640 /* Check for a window that has a killed buffer. */
2641 case CHECK_ALL_WINDOWS
:
2642 if (! NILP (w
->buffer
)
2643 && !BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
2647 case WINDOW_LOOP_UNUSED
:
2656 /* Used for debugging. Abort if any window has a dead buffer. */
2658 extern void check_all_windows (void) EXTERNALLY_VISIBLE
;
2660 check_all_windows (void)
2662 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2665 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 0, 2, 0,
2666 doc
: /* Return a window currently displaying BUFFER-OR-NAME, or nil if none.
2667 BUFFER-OR-NAME may be a buffer or a buffer name and defaults to
2670 The optional argument ALL-FRAMES specifies the frames to consider:
2672 - t means consider all windows on all existing frames.
2674 - `visible' means consider all windows on all visible frames.
2676 - 0 (the number zero) means consider all windows on all visible
2677 and iconified frames.
2679 - A frame means consider all windows on that frame only.
2681 Any other value of ALL-FRAMES means consider all windows on the
2682 selected frame and no others. */)
2683 (Lisp_Object buffer_or_name
, Lisp_Object all_frames
)
2687 if (NILP (buffer_or_name
))
2688 buffer
= Fcurrent_buffer ();
2690 buffer
= Fget_buffer (buffer_or_name
);
2692 if (BUFFERP (buffer
))
2693 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, all_frames
);
2699 resize_root_window (Lisp_Object window
, Lisp_Object delta
, Lisp_Object horizontal
, Lisp_Object ignore
)
2701 return call4 (Qwindow_resize_root_window
, window
, delta
, horizontal
, ignore
);
2705 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal
,
2706 Sdelete_other_windows_internal
, 0, 2, "",
2707 doc
: /* Make WINDOW fill its frame.
2708 Only the frame WINDOW is on is affected. WINDOW must be a valid window
2709 and defaults to the selected one.
2711 Optional argument ROOT, if non-nil, must specify an internal window such
2712 that WINDOW is in its window subtree. If this is the case, replace ROOT
2713 by WINDOW and leave alone any windows not part of ROOT's subtree.
2715 When WINDOW is live try to reduce display jumps by keeping the text
2716 previously visible in WINDOW in the same place on the frame. Doing this
2717 depends on the value of (window-start WINDOW), so if calling this
2718 function in a program gives strange scrolling, make sure the
2719 window-start value is reasonable when this function is called. */)
2720 (Lisp_Object window
, Lisp_Object root
)
2722 struct window
*w
, *r
, *s
;
2724 Lisp_Object sibling
, pwindow
, swindow
IF_LINT (= Qnil
), delta
;
2725 ptrdiff_t startpos
IF_LINT (= 0);
2726 int top
IF_LINT (= 0), new_top
, resize_failed
;
2728 w
= decode_valid_window (window
);
2729 XSETWINDOW (window
, w
);
2730 f
= XFRAME (w
->frame
);
2733 /* ROOT is the frame's root window. */
2735 root
= FRAME_ROOT_WINDOW (f
);
2739 /* ROOT must be an ancestor of WINDOW. */
2741 r
= decode_valid_window (root
);
2742 pwindow
= XWINDOW (window
)->parent
;
2743 while (!NILP (pwindow
))
2744 if (EQ (pwindow
, root
))
2747 pwindow
= XWINDOW (pwindow
)->parent
;
2748 if (!EQ (pwindow
, root
))
2749 error ("Specified root is not an ancestor of specified window");
2752 if (EQ (window
, root
))
2755 /* I don't understand the "top > 0" part below. If we deal with a
2756 standalone minibuffer it would have been caught by the preceding
2758 else if (MINI_WINDOW_P (w
)) /* && top > 0) */
2759 error ("Can't expand minibuffer to full frame");
2761 if (!NILP (w
->buffer
))
2763 startpos
= marker_position (w
->start
);
2764 top
= WINDOW_TOP_EDGE_LINE (w
)
2765 - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2766 /* Make sure WINDOW is the frame's selected window. */
2767 if (!EQ (window
, FRAME_SELECTED_WINDOW (f
)))
2769 if (EQ (selected_frame
, w
->frame
))
2770 Fselect_window (window
, Qnil
);
2772 fset_selected_window (f
, window
);
2777 /* See if the frame's selected window is a part of the window
2778 subtree rooted at WINDOW, by finding all the selected window's
2779 parents and comparing each one with WINDOW. If it isn't we
2780 need a new selected window for this frame. */
2781 swindow
= FRAME_SELECTED_WINDOW (f
);
2785 while (!NILP (pwindow
) && !EQ (window
, pwindow
))
2786 pwindow
= XWINDOW (pwindow
)->parent
;
2788 if (EQ (window
, pwindow
))
2789 /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
2790 as the new selected window. */
2793 /* Else try the previous window of SWINDOW. */
2794 swindow
= Fprevious_window (swindow
, Qlambda
, Qnil
);
2797 if (!EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
2799 if (EQ (selected_frame
, w
->frame
))
2800 Fselect_window (swindow
, Qnil
);
2802 fset_selected_window (f
, swindow
);
2807 if (!FRAME_INITIAL_P (f
))
2809 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
2811 /* We are going to free the glyph matrices of WINDOW, and with
2812 that we might lose any information about glyph rows that have
2813 some of their glyphs highlighted in mouse face. (These rows
2814 are marked with a non-zero mouse_face_p flag.) If WINDOW
2815 indeed has some glyphs highlighted in mouse face, signal to
2816 frame's up-to-date hook that mouse highlight was overwritten,
2817 so that it will arrange for redisplaying the highlight. */
2818 if (EQ (hlinfo
->mouse_face_window
, window
))
2820 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
2821 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
2822 hlinfo
->mouse_face_window
= Qnil
;
2825 free_window_matrices (r
);
2827 windows_or_buffers_changed
++;
2828 Vwindow_list
= Qnil
;
2829 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
2832 if (NILP (w
->buffer
))
2834 /* Resize child windows vertically. */
2835 XSETINT (delta
, XINT (r
->total_lines
)
2836 - XINT (w
->total_lines
));
2837 wset_top_line (w
, r
->top_line
);
2838 resize_root_window (window
, delta
, Qnil
, Qnil
);
2839 if (window_resize_check (w
, 0))
2840 window_resize_apply (w
, 0);
2843 resize_root_window (window
, delta
, Qnil
, Qt
);
2844 if (window_resize_check (w
, 0))
2845 window_resize_apply (w
, 0);
2850 /* Resize child windows horizontally. */
2853 wset_left_col (w
, r
->left_col
);
2855 XINT (r
->total_cols
) - XINT (w
->total_cols
));
2856 wset_left_col (w
, r
->left_col
);
2857 resize_root_window (window
, delta
, Qt
, Qnil
);
2858 if (window_resize_check (w
, 1))
2859 window_resize_apply (w
, 1);
2862 resize_root_window (window
, delta
, Qt
, Qt
);
2863 if (window_resize_check (w
, 1))
2864 window_resize_apply (w
, 1);
2871 /* Play safe, if we still can ... */
2874 w
= XWINDOW (window
);
2878 /* Cleanly unlink WINDOW from window-tree. */
2879 if (!NILP (w
->prev
))
2880 /* Get SIBLING above (on the left of) WINDOW. */
2883 s
= XWINDOW (sibling
);
2884 wset_next (s
, w
->next
);
2885 if (!NILP (s
->next
))
2886 wset_prev (XWINDOW (s
->next
), sibling
);
2889 /* Get SIBLING below (on the right of) WINDOW. */
2892 s
= XWINDOW (sibling
);
2893 wset_prev (s
, Qnil
);
2894 if (!NILP (XWINDOW (w
->parent
)->vchild
))
2895 wset_vchild (XWINDOW (w
->parent
), sibling
);
2897 wset_hchild (XWINDOW (w
->parent
), sibling
);
2900 /* Delete ROOT and all child windows of ROOT. */
2901 if (!NILP (r
->vchild
))
2903 delete_all_child_windows (r
->vchild
);
2904 wset_vchild (r
, Qnil
);
2906 else if (!NILP (r
->hchild
))
2908 delete_all_child_windows (r
->hchild
);
2909 wset_hchild (r
, Qnil
);
2912 replace_window (root
, window
, 1);
2914 /* This must become SWINDOW anyway ....... */
2915 if (!NILP (w
->buffer
) && !resize_failed
)
2917 /* Try to minimize scrolling, by setting the window start to the
2918 point will cause the text at the old window start to be at the
2919 same place on the frame. But don't try to do this if the
2920 window start is outside the visible portion (as might happen
2921 when the display is not current, due to typeahead). */
2922 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2924 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2925 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2927 struct position pos
;
2928 struct buffer
*obuf
= current_buffer
;
2930 Fset_buffer (w
->buffer
);
2931 /* This computation used to temporarily move point, but that
2932 can have unwanted side effects due to text properties. */
2933 pos
= *vmotion (startpos
, -top
, w
);
2935 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2936 wset_window_end_valid (w
, Qnil
);
2937 w
->start_at_line_beg
= (pos
.bytepos
== BEGV_BYTE
2938 || FETCH_BYTE (pos
.bytepos
- 1) == '\n');
2939 /* We need to do this, so that the window-scroll-functions
2941 w
->optional_new_start
= 1;
2943 set_buffer_internal (obuf
);
2950 run_window_configuration_change_hook (f
);
2957 replace_buffer_in_windows (Lisp_Object buffer
)
2959 call1 (Qreplace_buffer_in_windows
, buffer
);
2963 /* Safely replace BUFFER with some other buffer in all windows of all
2964 frames, even those on other keyboards. */
2967 replace_buffer_in_windows_safely (Lisp_Object buffer
)
2969 Lisp_Object tail
, frame
;
2971 /* A single call to window_loop won't do the job because it only
2972 considers frames on the current keyboard. So loop manually over
2973 frames, and handle each one. */
2974 FOR_EACH_FRAME (tail
, frame
)
2975 window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY
, buffer
, 1, frame
);
2978 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2979 minimum allowable size. */
2982 check_frame_size (FRAME_PTR frame
, int *rows
, int *cols
)
2984 /* For height, we have to see:
2985 how many windows the frame has at minimum (one or two),
2986 and whether it has a menu bar or other special stuff at the top. */
2988 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2989 ? MIN_SAFE_WINDOW_HEIGHT
2990 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2992 if (FRAME_TOP_MARGIN (frame
) > 0)
2993 min_height
+= FRAME_TOP_MARGIN (frame
);
2995 if (*rows
< min_height
)
2997 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2998 *cols
= MIN_SAFE_WINDOW_WIDTH
;
3001 /* Adjust the margins of window W if text area is too small.
3002 Return 1 if window width is ok after adjustment; 0 if window
3003 is still too narrow. */
3006 adjust_window_margins (struct window
*w
)
3008 int box_cols
= (WINDOW_TOTAL_COLS (w
)
3009 - WINDOW_FRINGE_COLS (w
)
3010 - WINDOW_SCROLL_BAR_COLS (w
));
3011 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
3012 + WINDOW_RIGHT_MARGIN_COLS (w
));
3014 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
3017 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
3020 /* Window's text area is too narrow, but reducing the window
3021 margins will fix that. */
3022 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
3023 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
3025 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
3027 wset_left_margin_cols (w
, make_number (margin_cols
/ 2));
3028 wset_right_margin_cols (w
, make_number (margin_cols
/ 2));
3031 wset_right_margin_cols (w
, make_number (margin_cols
));
3034 wset_left_margin_cols (w
, make_number (margin_cols
));
3038 /* The following three routines are needed for running a window's
3039 configuration change hook. */
3041 run_funs (Lisp_Object funs
)
3043 for (; CONSP (funs
); funs
= XCDR (funs
))
3044 if (!EQ (XCAR (funs
), Qt
))
3045 call0 (XCAR (funs
));
3049 select_window_norecord (Lisp_Object window
)
3051 return WINDOW_LIVE_P (window
)
3052 ? Fselect_window (window
, Qt
) : selected_window
;
3056 select_frame_norecord (Lisp_Object frame
)
3058 return FRAME_LIVE_P (XFRAME (frame
))
3059 ? Fselect_frame (frame
, Qt
) : selected_frame
;
3063 run_window_configuration_change_hook (struct frame
*f
)
3065 ptrdiff_t count
= SPECPDL_INDEX ();
3066 Lisp_Object frame
, global_wcch
3067 = Fdefault_value (Qwindow_configuration_change_hook
);
3068 XSETFRAME (frame
, f
);
3070 if (NILP (Vrun_hooks
) || !NILP (inhibit_lisp_code
))
3073 /* Use the right buffer. Matters when running the local hooks. */
3074 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3076 record_unwind_current_buffer ();
3077 Fset_buffer (Fwindow_buffer (Qnil
));
3080 if (SELECTED_FRAME () != f
)
3082 record_unwind_protect (select_frame_norecord
, Fselected_frame ());
3083 select_frame_norecord (frame
);
3086 /* Look for buffer-local values. */
3088 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3089 for (; CONSP (windows
); windows
= XCDR (windows
))
3091 Lisp_Object window
= XCAR (windows
);
3092 Lisp_Object buffer
= Fwindow_buffer (window
);
3093 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3096 ptrdiff_t inner_count
= SPECPDL_INDEX ();
3097 record_unwind_protect (select_window_norecord
, Fselected_window ());
3098 select_window_norecord (window
);
3099 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3101 unbind_to (inner_count
, Qnil
);
3106 run_funs (global_wcch
);
3107 unbind_to (count
, Qnil
);
3110 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook
,
3111 Srun_window_configuration_change_hook
, 0, 1, 0,
3112 doc
: /* Run `window-configuration-change-hook' for FRAME.
3113 If FRAME is omitted or nil, it defaults to the selected frame. */)
3116 run_window_configuration_change_hook (decode_live_frame (frame
));
3120 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3121 means it's allowed to run hooks. See make_frame for a case where
3122 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3123 margins, fringes, and scroll-bar settings of the window are not
3124 reset from the buffer's local settings. */
3127 set_window_buffer (Lisp_Object window
, Lisp_Object buffer
, int run_hooks_p
, int keep_margins_p
)
3129 struct window
*w
= XWINDOW (window
);
3130 struct buffer
*b
= XBUFFER (buffer
);
3131 ptrdiff_t count
= SPECPDL_INDEX ();
3132 int samebuf
= EQ (buffer
, w
->buffer
);
3134 wset_buffer (w
, buffer
);
3136 if (EQ (window
, selected_window
))
3137 bset_last_selected_window (b
, window
);
3139 /* Let redisplay errors through. */
3140 b
->display_error_modiff
= 0;
3142 /* Update time stamps of buffer display. */
3143 if (INTEGERP (BVAR (b
, display_count
)))
3144 bset_display_count (b
, make_number (XINT (BVAR (b
, display_count
)) + 1));
3145 bset_display_time (b
, Fcurrent_time ());
3147 wset_window_end_pos (w
, make_number (0));
3148 wset_window_end_vpos (w
, make_number (0));
3149 memset (&w
->last_cursor
, 0, sizeof w
->last_cursor
);
3150 wset_window_end_valid (w
, Qnil
);
3151 if (!(keep_margins_p
&& samebuf
))
3152 { /* If we're not actually changing the buffer, don't reset hscroll and
3153 vscroll. This case happens for example when called from
3154 change_frame_size_1, where we use a dummy call to
3155 Fset_window_buffer on the frame's selected window (and no other)
3156 just in order to run window-configuration-change-hook.
3157 Resetting hscroll and vscroll here is problematic for things like
3158 image-mode and doc-view-mode since it resets the image's position
3159 whenever we resize the frame. */
3160 w
->hscroll
= w
->min_hscroll
= 0;
3162 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3163 set_marker_restricted (w
->start
,
3164 make_number (b
->last_window_start
),
3166 w
->start_at_line_beg
= 0;
3168 w
->last_modified
= 0;
3169 w
->last_overlay_modified
= 0;
3171 /* Maybe we could move this into the `if' but it's not obviously safe and
3172 I doubt it's worth the trouble. */
3173 windows_or_buffers_changed
++;
3175 /* We must select BUFFER for running the window-scroll-functions. */
3176 /* We can't check ! NILP (Vwindow_scroll_functions) here
3177 because that might itself be a local variable. */
3178 if (window_initialized
)
3180 record_unwind_current_buffer ();
3181 Fset_buffer (buffer
);
3184 XMARKER (w
->pointm
)->insertion_type
= !NILP (Vwindow_point_insertion_type
);
3186 if (!keep_margins_p
)
3188 /* Set left and right marginal area width etc. from buffer. */
3190 /* This may call adjust_window_margins three times, so
3191 temporarily disable window margins. */
3192 Lisp_Object save_left
= w
->left_margin_cols
;
3193 Lisp_Object save_right
= w
->right_margin_cols
;
3195 wset_left_margin_cols (w
, Qnil
);
3196 wset_right_margin_cols (w
, Qnil
);
3198 Fset_window_fringes (window
,
3199 BVAR (b
, left_fringe_width
), BVAR (b
, right_fringe_width
),
3200 BVAR (b
, fringes_outside_margins
));
3202 Fset_window_scroll_bars (window
,
3203 BVAR (b
, scroll_bar_width
),
3204 BVAR (b
, vertical_scroll_bar_type
), Qnil
);
3206 wset_left_margin_cols (w
, save_left
);
3207 wset_right_margin_cols (w
, save_right
);
3209 Fset_window_margins (window
,
3210 BVAR (b
, left_margin_cols
), BVAR (b
, right_margin_cols
));
3215 if (! NILP (Vwindow_scroll_functions
))
3216 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3217 Fmarker_position (w
->start
));
3218 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3221 unbind_to (count
, Qnil
);
3224 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3225 doc
: /* Make WINDOW display BUFFER-OR-NAME as its contents.
3226 WINDOW must be a live window and defaults to the selected one.
3227 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
3229 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
3230 display margins, fringe widths, and scroll bar settings are preserved;
3231 the default is to reset these from the local settings for BUFFER-OR-NAME
3232 or the frame defaults. Return nil.
3234 This function throws an error when WINDOW is strongly dedicated to its
3235 buffer (that is `window-dedicated-p' returns t for WINDOW) and does not
3236 already display BUFFER-OR-NAME.
3238 This function runs `window-scroll-functions' before running
3239 `window-configuration-change-hook'. */)
3240 (register Lisp_Object window
, Lisp_Object buffer_or_name
, Lisp_Object keep_margins
)
3242 register Lisp_Object tem
, buffer
;
3243 register struct window
*w
= decode_live_window (window
);
3245 XSETWINDOW (window
, w
);
3246 buffer
= Fget_buffer (buffer_or_name
);
3247 CHECK_BUFFER (buffer
);
3248 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
3249 error ("Attempt to display deleted buffer");
3253 error ("Window is deleted");
3254 else if (!EQ (tem
, Qt
))
3255 /* w->buffer is t when the window is first being set up. */
3257 if (!EQ (tem
, buffer
))
3259 if (EQ (w
->dedicated
, Qt
))
3260 /* WINDOW is strongly dedicated to its buffer, signal an
3262 error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem
), name
)));
3264 /* WINDOW is weakly dedicated to its buffer, reset
3266 wset_dedicated (w
, Qnil
);
3268 call1 (Qrecord_window_buffer
, window
);
3274 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3280 display_buffer (Lisp_Object buffer
, Lisp_Object not_this_window_p
, Lisp_Object override_frame
)
3282 return call3 (Qdisplay_buffer
, buffer
, not_this_window_p
, override_frame
);
3285 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3287 doc
: /* Force all windows to be updated on next redisplay.
3288 If optional arg OBJECT is a window, force redisplay of that window only.
3289 If OBJECT is a buffer or buffer name, force redisplay of all windows
3290 displaying that buffer. */)
3291 (Lisp_Object object
)
3295 windows_or_buffers_changed
++;
3296 update_mode_lines
++;
3300 if (WINDOWP (object
))
3302 struct window
*w
= XWINDOW (object
);
3303 mark_window_display_accurate (object
, 0);
3304 w
->update_mode_line
= 1;
3305 if (BUFFERP (w
->buffer
))
3306 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3307 ++update_mode_lines
;
3311 if (STRINGP (object
))
3312 object
= Fget_buffer (object
);
3313 if (BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
3315 /* Walk all windows looking for buffer, and force update
3316 of each of those windows. */
3318 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3319 return NILP (object
) ? Qnil
: Qt
;
3322 /* If nothing suitable was found, just return.
3323 We could signal an error, but this feature will typically be used
3324 asynchronously in timers or process sentinels, so we don't. */
3328 /* Obsolete since 24.3. */
3330 temp_output_buffer_show (register Lisp_Object buf
)
3332 register struct buffer
*old
= current_buffer
;
3333 register Lisp_Object window
;
3334 register struct window
*w
;
3336 bset_directory (XBUFFER (buf
), BVAR (current_buffer
, directory
));
3339 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3343 set_buffer_internal (old
);
3345 if (!NILP (Vtemp_buffer_show_function
))
3346 call1 (Vtemp_buffer_show_function
, buf
);
3349 window
= display_buffer (buf
, Qnil
, Qnil
);
3351 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3352 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3353 Vminibuf_scroll_window
= window
;
3354 w
= XWINDOW (window
);
3357 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3358 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3360 /* Run temp-buffer-show-hook, with the chosen window selected
3361 and its buffer current. */
3363 ptrdiff_t count
= SPECPDL_INDEX ();
3364 Lisp_Object prev_window
, prev_buffer
;
3365 prev_window
= selected_window
;
3366 XSETBUFFER (prev_buffer
, old
);
3368 /* Select the window that was chosen, for running the hook.
3369 Note: Both Fselect_window and select_window_norecord may
3370 set-buffer to the buffer displayed in the window,
3371 so we need to save the current buffer. --stef */
3372 record_unwind_protect (Fset_buffer
, prev_buffer
);
3373 record_unwind_protect (select_window_norecord
, prev_window
);
3374 Fselect_window (window
, Qt
);
3375 Fset_buffer (w
->buffer
);
3376 Frun_hooks (1, &Qtemp_buffer_show_hook
);
3377 unbind_to (count
, Qnil
);
3382 /* Make new window, have it replace WINDOW in window-tree, and make
3383 WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
3384 horizontal child). */
3386 make_parent_window (Lisp_Object window
, int horflag
)
3389 register struct window
*o
, *p
;
3391 o
= XWINDOW (window
);
3392 p
= allocate_window ();
3393 memcpy ((char *) p
+ sizeof (struct vectorlike_header
),
3394 (char *) o
+ sizeof (struct vectorlike_header
),
3395 word_size
* VECSIZE (struct window
));
3396 XSETWINDOW (parent
, p
);
3398 p
->sequence_number
= ++sequence_number
;
3400 replace_window (window
, parent
, 1);
3402 wset_next (o
, Qnil
);
3403 wset_prev (o
, Qnil
);
3404 wset_parent (o
, parent
);
3406 wset_hchild (p
, horflag
? window
: Qnil
);
3407 wset_vchild (p
, horflag
? Qnil
: window
);
3408 wset_start (p
, Qnil
);
3409 wset_pointm (p
, Qnil
);
3410 wset_buffer (p
, Qnil
);
3411 wset_combination_limit (p
, Qnil
);
3412 wset_window_parameters (p
, Qnil
);
3415 /* Make new window from scratch. */
3420 register struct window
*w
;
3422 w
= allocate_window ();
3423 /* Initialize Lisp data. Note that allocate_window initializes all
3424 Lisp data to nil, so do it only for slots which should not be nil. */
3425 wset_left_col (w
, make_number (0));
3426 wset_top_line (w
, make_number (0));
3427 wset_total_lines (w
, make_number (0));
3428 wset_total_cols (w
, make_number (0));
3429 wset_normal_lines (w
, make_float (1.0));
3430 wset_normal_cols (w
, make_float (1.0));
3431 wset_new_total (w
, make_number (0));
3432 wset_new_normal (w
, make_number (0));
3433 wset_start (w
, Fmake_marker ());
3434 wset_pointm (w
, Fmake_marker ());
3435 wset_vertical_scroll_bar_type (w
, Qt
);
3436 wset_window_end_pos (w
, make_number (0));
3437 wset_window_end_vpos (w
, make_number (0));
3438 /* These Lisp fields are marked specially so they're not set to nil by
3440 wset_prev_buffers (w
, Qnil
);
3441 wset_next_buffers (w
, Qnil
);
3443 /* Initialize non-Lisp data. Note that allocate_window zeroes out all
3444 non-Lisp data, so do it only for slots which should not be zero. */
3445 w
->nrows_scale_factor
= w
->ncols_scale_factor
= 1;
3446 w
->phys_cursor_type
= -1;
3447 w
->phys_cursor_width
= -1;
3448 w
->sequence_number
= ++sequence_number
;
3450 /* Reset window_list. */
3451 Vwindow_list
= Qnil
;
3452 /* Return window. */
3453 XSETWINDOW (window
, w
);
3457 DEFUN ("set-window-new-total", Fset_window_new_total
, Sset_window_new_total
, 2, 3, 0,
3458 doc
: /* Set new total size of WINDOW to SIZE.
3459 WINDOW must be a valid window and defaults to the selected one.
3462 Optional argument ADD non-nil means add SIZE to the new total size of
3463 WINDOW and return the sum.
3465 Note: This function does not operate on any child windows of WINDOW. */)
3466 (Lisp_Object window
, Lisp_Object size
, Lisp_Object add
)
3468 struct window
*w
= decode_valid_window (window
);
3470 CHECK_NUMBER (size
);
3472 wset_new_total (w
, size
);
3474 wset_new_total (w
, make_number (XINT (w
->new_total
) + XINT (size
)));
3476 return w
->new_total
;
3479 DEFUN ("set-window-new-normal", Fset_window_new_normal
, Sset_window_new_normal
, 1, 2, 0,
3480 doc
: /* Set new normal size of WINDOW to SIZE.
3481 WINDOW must be a valid window and defaults to the selected one.
3484 Note: This function does not operate on any child windows of WINDOW. */)
3485 (Lisp_Object window
, Lisp_Object size
)
3487 wset_new_normal (decode_valid_window (window
), size
);
3491 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
3492 non-zero) to w->new_total would result in correct heights (widths)
3493 for window W and recursively all child windows of W.
3495 Note: This function does not check any of `window-fixed-size-p',
3496 `window-min-height' or `window-min-width'. It does check that window
3497 sizes do not drop below one line (two columns). */
3499 window_resize_check (struct window
*w
, int horflag
)
3503 if (!NILP (w
->vchild
))
3504 /* W is a vertical combination. */
3506 c
= XWINDOW (w
->vchild
);
3508 /* All child windows of W must have the same width as W. */
3512 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3513 || !window_resize_check (c
, horflag
))
3515 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3520 /* The sum of the heights of the child windows of W must equal
3523 int sum_of_sizes
= 0;
3526 if (!window_resize_check (c
, horflag
))
3528 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3529 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3531 return (sum_of_sizes
== XINT (w
->new_total
));
3534 else if (!NILP (w
->hchild
))
3535 /* W is a horizontal combination. */
3537 c
= XWINDOW (w
->hchild
);
3539 /* The sum of the widths of the child windows of W must equal W's
3542 int sum_of_sizes
= 0;
3545 if (!window_resize_check (c
, horflag
))
3547 sum_of_sizes
= sum_of_sizes
+ XINT (c
->new_total
);
3548 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3550 return (sum_of_sizes
== XINT (w
->new_total
));
3553 /* All child windows of W must have the same height as W. */
3557 if ((XINT (c
->new_total
) != XINT (w
->new_total
))
3558 || !window_resize_check (c
, horflag
))
3560 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3566 /* A leaf window. Make sure it's not too small. The following
3567 hardcodes the values of `window-safe-min-width' (2) and
3568 `window-safe-min-height' (1) which are defined in window.el. */
3569 return XINT (w
->new_total
) >= (horflag
? 2 : 1);
3572 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
3573 w->new_total for window W and recursively all child windows of W.
3574 Also calculate and assign the new vertical (horizontal) start
3575 positions of each of these windows.
3577 This function does not perform any error checks. Make sure you have
3578 run window_resize_check on W before applying this function. */
3580 window_resize_apply (struct window
*w
, int horflag
)
3585 /* Note: Assigning new_normal requires that the new total size of the
3586 parent window has been set *before*. */
3589 wset_total_cols (w
, w
->new_total
);
3590 if (NUMBERP (w
->new_normal
))
3591 wset_normal_cols (w
, w
->new_normal
);
3593 pos
= XINT (w
->left_col
);
3597 wset_total_lines (w
, w
->new_total
);
3598 if (NUMBERP (w
->new_normal
))
3599 wset_normal_lines (w
, w
->new_normal
);
3601 pos
= XINT (w
->top_line
);
3604 if (!NILP (w
->vchild
))
3605 /* W is a vertical combination. */
3607 c
= XWINDOW (w
->vchild
);
3611 wset_left_col (c
, make_number (pos
));
3613 wset_top_line (c
, make_number (pos
));
3614 window_resize_apply (c
, horflag
);
3616 pos
= pos
+ XINT (c
->total_lines
);
3617 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3620 else if (!NILP (w
->hchild
))
3621 /* W is a horizontal combination. */
3623 c
= XWINDOW (w
->hchild
);
3627 wset_left_col (c
, make_number (pos
));
3629 wset_top_line (c
, make_number (pos
));
3630 window_resize_apply (c
, horflag
);
3632 pos
= pos
+ XINT (c
->total_cols
);
3633 c
= NILP (c
->next
) ? 0 : XWINDOW (c
->next
);
3637 /* Clear out some redisplay caches. */
3638 w
->last_modified
= 0;
3639 w
->last_overlay_modified
= 0;
3643 DEFUN ("window-resize-apply", Fwindow_resize_apply
, Swindow_resize_apply
, 0, 2, 0,
3644 doc
: /* Apply requested size values for window-tree of FRAME.
3645 If FRAME is omitted or nil, it defaults to the selected frame.
3647 Optional argument HORIZONTAL omitted or nil means apply requested
3648 height values. HORIZONTAL non-nil means apply requested width values.
3650 This function checks whether the requested values sum up to a valid
3651 window layout, recursively assigns the new sizes of all child windows
3652 and calculates and assigns the new start positions of these windows.
3654 Note: This function does not check any of `window-fixed-size-p',
3655 `window-min-height' or `window-min-width'. All these checks have to
3656 be applied on the Elisp level. */)
3657 (Lisp_Object frame
, Lisp_Object horizontal
)
3659 struct frame
*f
= decode_live_frame (frame
);
3660 struct window
*r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3661 int horflag
= !NILP (horizontal
);
3663 if (!window_resize_check (r
, horflag
)
3664 || ! EQ (r
->new_total
,
3665 (horflag
? r
->total_cols
: r
->total_lines
)))
3669 window_resize_apply (r
, horflag
);
3671 windows_or_buffers_changed
++;
3672 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3677 run_window_configuration_change_hook (f
);
3683 /* Resize frame F's windows when number of lines of F is set to SIZE.
3684 HORFLAG 1 means resize windows when number of columns of F is set to
3687 This function can delete all windows but the selected one in order to
3688 satisfy the request. The result will be meaningful if and only if
3689 F's windows have meaningful sizes when you call this. */
3691 resize_frame_windows (struct frame
*f
, int size
, int horflag
)
3693 Lisp_Object root
= f
->root_window
;
3694 struct window
*r
= XWINDOW (root
);
3695 Lisp_Object mini
= f
->minibuffer_window
;
3697 /* new_size is the new size of the frame's root window. */
3698 int new_size
= (horflag
3701 - FRAME_TOP_MARGIN (f
)
3702 - ((FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3705 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
3706 if (NILP (r
->vchild
) && NILP (r
->hchild
))
3707 /* For a leaf root window just set the size. */
3709 wset_total_cols (r
, make_number (new_size
));
3711 wset_total_lines (r
, make_number (new_size
));
3714 /* old_size is the old size of the frame's root window. */
3715 int old_size
= XFASTINT (horflag
? r
->total_cols
3719 XSETINT (delta
, new_size
- old_size
);
3720 /* Try a "normal" resize first. */
3721 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qnil
);
3722 if (window_resize_check (r
, horflag
)
3723 && new_size
== XINT (r
->new_total
))
3724 window_resize_apply (r
, horflag
);
3727 /* Try with "reasonable" minimum sizes next. */
3728 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qt
);
3729 if (window_resize_check (r
, horflag
)
3730 && new_size
== XINT (r
->new_total
))
3731 window_resize_apply (r
, horflag
);
3734 /* Finally, try with "safe" minimum sizes. */
3735 resize_root_window (root
, delta
, horflag
? Qt
: Qnil
, Qsafe
);
3736 if (window_resize_check (r
, horflag
)
3737 && new_size
== XINT (r
->new_total
))
3738 window_resize_apply (r
, horflag
);
3741 /* We lost. Delete all windows but the frame's
3743 root
= f
->selected_window
;
3744 Fdelete_other_windows_internal (root
, Qnil
);
3746 wset_total_cols (XWINDOW (root
), make_number (new_size
));
3748 wset_total_lines (XWINDOW (root
), make_number (new_size
));
3754 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
3758 wset_total_cols (m
, make_number (size
));
3761 /* Are we sure we always want 1 line here? */
3762 wset_total_lines (m
, make_number (1));
3764 (m
, make_number (XINT (r
->top_line
) + XINT (r
->total_lines
)));
3768 windows_or_buffers_changed
++;
3772 DEFUN ("split-window-internal", Fsplit_window_internal
, Ssplit_window_internal
, 4, 4, 0,
3773 doc
: /* Split window OLD.
3774 Second argument TOTAL-SIZE specifies the number of lines or columns of the
3775 new window. In any case TOTAL-SIZE must be a positive integer.
3777 Third argument SIDE nil (or `below') specifies that the new window shall
3778 be located below WINDOW. SIDE `above' means the new window shall be
3779 located above WINDOW. In both cases TOTAL-SIZE specifies the number of
3780 lines of the new window including space reserved for the mode and/or
3783 SIDE t (or `right') specifies that the new window shall be located on
3784 the right side of WINDOW. SIDE `left' means the new window shall be
3785 located on the left of WINDOW. In both cases TOTAL-SIZE specifies the
3786 number of columns of the new window including space reserved for fringes
3787 and the scrollbar or a divider column.
3789 Fourth argument NORMAL-SIZE specifies the normal size of the new window
3790 according to the SIDE argument.
3792 The new total and normal sizes of all involved windows must have been
3793 set correctly. See the code of `split-window' for how this is done. */)
3794 (Lisp_Object old
, Lisp_Object total_size
, Lisp_Object side
, Lisp_Object normal_size
)
3796 /* OLD (*o) is the window we have to split. (*p) is either OLD's
3797 parent window or an internal window we have to install as OLD's new
3798 parent. REFERENCE (*r) must denote a live window, or is set to OLD
3799 provided OLD is a leaf window, or to the frame's selected window.
3800 NEW (*n) is the new window created with some parameters taken from
3802 register Lisp_Object
new, frame
, reference
;
3803 register struct window
*o
, *p
, *n
, *r
;
3806 /* HORFLAG is 1 when we split side-by-side, 0 otherwise. */
3807 = EQ (side
, Qt
) || EQ (side
, Qleft
) || EQ (side
, Qright
);
3808 int combination_limit
= 0;
3812 frame
= WINDOW_FRAME (o
);
3815 CHECK_NUMBER (total_size
);
3817 /* Set combination_limit to 1 if we have to make a new parent window.
3818 We do that if either `window-combination-limit' is t, or OLD has no
3819 parent, or OLD is ortho-combined. */
3821 EQ (Vwindow_combination_limit
, Qt
)
3824 ? (XWINDOW (o
->parent
)->hchild
)
3825 : (XWINDOW (o
->parent
)->vchild
));
3827 /* We need a live reference window to initialize some parameters. */
3828 if (WINDOW_LIVE_P (old
))
3829 /* OLD is live, use it as reference window. */
3832 /* Use the frame's selected window as reference window. */
3833 reference
= FRAME_SELECTED_WINDOW (f
);
3834 r
= XWINDOW (reference
);
3836 /* The following bugs are caught by `split-window'. */
3837 if (MINI_WINDOW_P (o
))
3838 error ("Attempt to split minibuffer window");
3839 else if (XINT (total_size
) < (horflag
? 2 : 1))
3840 error ("Size of new window too small (after split)");
3841 else if (!combination_limit
&& !NILP (Vwindow_combination_resize
))
3842 /* `window-combination-resize' non-nil means try to resize OLD's siblings
3845 p
= XWINDOW (o
->parent
);
3846 /* Temporarily pretend we split the parent window. */
3848 (p
, make_number (XINT (horflag
? p
->total_cols
: p
->total_lines
)
3849 - XINT (total_size
)));
3850 if (!window_resize_check (p
, horflag
))
3851 error ("Window sizes don't fit");
3853 /* Undo the temporary pretension. */
3854 wset_new_total (p
, horflag
? p
->total_cols
: p
->total_lines
);
3858 if (!window_resize_check (o
, horflag
))
3859 error ("Resizing old window failed");
3860 else if (XINT (total_size
) + XINT (o
->new_total
)
3861 != XINT (horflag
? o
->total_cols
: o
->total_lines
))
3862 error ("Sum of sizes of old and new window don't fit");
3865 /* This is our point of no return. */
3866 if (combination_limit
)
3868 /* Save the old value of o->normal_cols/lines. It gets corrupted
3869 by make_parent_window and we need it below for assigning it to
3871 Lisp_Object new_normal
3872 = horflag
? o
->normal_cols
: o
->normal_lines
;
3874 make_parent_window (old
, horflag
);
3875 p
= XWINDOW (o
->parent
);
3876 if (EQ (Vwindow_combination_limit
, Qt
))
3877 /* Store t in the new parent's combination_limit slot to avoid
3878 that its children get merged into another window. */
3879 wset_combination_limit (p
, Qt
);
3880 /* These get applied below. */
3881 wset_new_total (p
, horflag
? o
->total_cols
: o
->total_lines
);
3882 wset_new_normal (p
, new_normal
);
3885 p
= XWINDOW (o
->parent
);
3887 windows_or_buffers_changed
++;
3888 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3889 new = make_window ();
3891 wset_frame (n
, frame
);
3892 wset_parent (n
, o
->parent
);
3893 wset_vchild (n
, Qnil
);
3894 wset_hchild (n
, Qnil
);
3896 if (EQ (side
, Qabove
) || EQ (side
, Qleft
))
3898 wset_prev (n
, o
->prev
);
3901 wset_hchild (p
, new);
3903 wset_vchild (p
, new);
3905 wset_next (XWINDOW (n
->prev
), new);
3911 wset_next (n
, o
->next
);
3912 if (!NILP (n
->next
))
3913 wset_prev (XWINDOW (n
->next
), new);
3918 wset_buffer (n
, Qt
);
3919 wset_window_end_valid (n
, Qnil
);
3920 memset (&n
->last_cursor
, 0, sizeof n
->last_cursor
);
3922 /* Get special geometry settings from reference window. */
3923 wset_left_margin_cols (n
, r
->left_margin_cols
);
3924 wset_right_margin_cols (n
, r
->right_margin_cols
);
3925 wset_left_fringe_width (n
, r
->left_fringe_width
);
3926 wset_right_fringe_width (n
, r
->right_fringe_width
);
3927 n
->fringes_outside_margins
= r
->fringes_outside_margins
;
3928 wset_scroll_bar_width (n
, r
->scroll_bar_width
);
3929 wset_vertical_scroll_bar_type (n
, r
->vertical_scroll_bar_type
);
3931 /* Directly assign orthogonal coordinates and sizes. */
3934 wset_top_line (n
, o
->top_line
);
3935 wset_total_lines (n
, o
->total_lines
);
3939 wset_left_col (n
, o
->left_col
);
3940 wset_total_cols (n
, o
->total_cols
);
3943 /* Iso-coordinates and sizes are assigned by window_resize_apply,
3944 get them ready here. */
3945 wset_new_total (n
, total_size
);
3946 wset_new_normal (n
, normal_size
);
3949 window_resize_apply (p
, horflag
);
3951 /* Set buffer of NEW to buffer of reference window. Don't run
3953 set_window_buffer (new, r
->buffer
, 0, 1);
3956 /* Maybe we should run the scroll functions in Elisp (which already
3957 runs the configuration change hook). */
3958 if (! NILP (Vwindow_scroll_functions
))
3959 run_hook_with_args_2 (Qwindow_scroll_functions
, new,
3960 Fmarker_position (n
->start
));
3966 DEFUN ("delete-window-internal", Fdelete_window_internal
, Sdelete_window_internal
, 1, 1, 0,
3967 doc
: /* Remove WINDOW from its frame.
3968 WINDOW defaults to the selected window. Return nil.
3969 Signal an error when WINDOW is the only window on its frame. */)
3970 (register Lisp_Object window
)
3972 register Lisp_Object parent
, sibling
, frame
, root
;
3973 struct window
*w
, *p
, *s
, *r
;
3976 int before_sibling
= 0;
3978 w
= decode_any_window (window
);
3979 XSETWINDOW (window
, w
);
3980 if (NILP (w
->buffer
)
3981 && NILP (w
->hchild
) && NILP (w
->vchild
))
3982 /* It's a no-op to delete an already deleted window. */
3987 /* Never delete a minibuffer or frame root window. */
3988 error ("Attempt to delete minibuffer or sole ordinary window");
3989 else if (NILP (w
->prev
) && NILP (w
->next
))
3990 /* Rather bow out here, this case should be handled on the Elisp
3992 error ("Attempt to delete sole window of parent");
3994 p
= XWINDOW (parent
);
3995 horflag
= NILP (p
->vchild
);
3997 frame
= WINDOW_FRAME (w
);
4000 root
= FRAME_ROOT_WINDOW (f
);
4003 /* Unlink WINDOW from window tree. */
4005 /* Get SIBLING below (on the right of) WINDOW. */
4007 /* before_sibling 1 means WINDOW is the first child of its
4008 parent and thus before the sibling. */
4011 s
= XWINDOW (sibling
);
4012 wset_prev (s
, Qnil
);
4014 wset_hchild (p
, sibling
);
4016 wset_vchild (p
, sibling
);
4019 /* Get SIBLING above (on the left of) WINDOW. */
4022 s
= XWINDOW (sibling
);
4023 wset_next (s
, w
->next
);
4024 if (!NILP (s
->next
))
4025 wset_prev (XWINDOW (s
->next
), sibling
);
4028 if (window_resize_check (r
, horflag
)
4029 && EQ (r
->new_total
,
4030 (horflag
? r
->total_cols
: r
->total_lines
)))
4031 /* We can delete WINDOW now. */
4036 #ifdef HAVE_XWIDGETS
4037 xwidget_view_delete_all_in_window(w
);
4039 window_resize_apply (p
, horflag
);
4041 /* If this window is referred to by the dpyinfo's mouse
4042 highlight, invalidate that slot to be safe (Bug#9904). */
4043 if (!FRAME_INITIAL_P (f
))
4045 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
4047 if (EQ (hlinfo
->mouse_face_window
, window
))
4048 hlinfo
->mouse_face_window
= Qnil
;
4051 windows_or_buffers_changed
++;
4052 Vwindow_list
= Qnil
;
4053 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4055 wset_next (w
, Qnil
); /* Don't delete w->next too. */
4056 free_window_matrices (w
);
4058 if (!NILP (w
->vchild
))
4060 delete_all_child_windows (w
->vchild
);
4061 wset_vchild (w
, Qnil
);
4063 else if (!NILP (w
->hchild
))
4065 delete_all_child_windows (w
->hchild
);
4066 wset_hchild (w
, Qnil
);
4068 else if (!NILP (w
->buffer
))
4071 unchain_marker (XMARKER (w
->pointm
));
4072 unchain_marker (XMARKER (w
->start
));
4073 wset_buffer (w
, Qnil
);
4076 if (NILP (s
->prev
) && NILP (s
->next
))
4077 /* A matrjoshka where SIBLING has become the only child of
4080 /* Put SIBLING into PARENT's place. */
4081 replace_window (parent
, sibling
, 0);
4082 /* Have SIBLING inherit the following three slot values from
4083 PARENT (the combination_limit slot is not inherited). */
4084 wset_normal_cols (s
, p
->normal_cols
);
4085 wset_normal_lines (s
, p
->normal_lines
);
4086 /* Mark PARENT as deleted. */
4087 wset_vchild (p
, Qnil
);
4088 wset_hchild (p
, Qnil
);
4089 /* Try to merge SIBLING into its new parent. */
4090 recombine_windows (sibling
);
4095 if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f
)))
4096 /* We deleted the frame's selected window. */
4098 /* Use the frame's first window as fallback ... */
4099 Lisp_Object new_selected_window
= Fframe_first_window (frame
);
4100 /* ... but preferably use its most recently used window. */
4101 Lisp_Object mru_window
;
4103 /* `get-mru-window' might fail for some reason so play it safe
4104 - promote the first window _without recording it_ first. */
4105 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4106 Fselect_window (new_selected_window
, Qt
);
4108 fset_selected_window (f
, new_selected_window
);
4112 /* Now look whether `get-mru-window' gets us something. */
4113 mru_window
= call1 (Qget_mru_window
, frame
);
4114 if (WINDOW_LIVE_P (mru_window
)
4115 && EQ (XWINDOW (mru_window
)->frame
, frame
))
4116 new_selected_window
= mru_window
;
4118 /* If all ended up well, we now promote the mru window. */
4119 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
4120 Fselect_window (new_selected_window
, Qnil
);
4122 fset_selected_window (f
, new_selected_window
);
4127 /* Must be run by the caller:
4128 run_window_configuration_change_hook (f); */
4131 /* We failed: Relink WINDOW into window tree. */
4135 wset_prev (s
, window
);
4137 wset_hchild (p
, window
);
4139 wset_vchild (p
, window
);
4143 wset_next (s
, window
);
4144 if (!NILP (w
->next
))
4145 wset_prev (XWINDOW (w
->next
), window
);
4147 error ("Deletion failed");
4153 /***********************************************************************
4154 Resizing Mini-Windows
4155 ***********************************************************************/
4157 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
4160 grow_mini_window (struct window
*w
, int delta
)
4162 struct frame
*f
= XFRAME (w
->frame
);
4164 Lisp_Object root
, value
;
4166 eassert (MINI_WINDOW_P (w
));
4167 eassert (delta
>= 0);
4169 root
= FRAME_ROOT_WINDOW (f
);
4171 value
= call2 (Qwindow_resize_root_window_vertically
,
4172 root
, make_number (- delta
));
4173 if (INTEGERP (value
) && window_resize_check (r
, 0))
4176 window_resize_apply (r
, 0);
4178 /* Grow the mini-window. */
4180 (w
, make_number (XFASTINT (r
->top_line
) + XFASTINT (r
->total_lines
)));
4182 (w
, make_number (XFASTINT (w
->total_lines
) - XINT (value
)));
4183 w
->last_modified
= 0;
4184 w
->last_overlay_modified
= 0;
4186 windows_or_buffers_changed
++;
4193 /* Shrink mini-window W. */
4195 shrink_mini_window (struct window
*w
)
4197 struct frame
*f
= XFRAME (w
->frame
);
4199 Lisp_Object root
, value
;
4202 eassert (MINI_WINDOW_P (w
));
4204 size
= XINT (w
->total_lines
);
4207 root
= FRAME_ROOT_WINDOW (f
);
4209 value
= call2 (Qwindow_resize_root_window_vertically
,
4210 root
, make_number (size
- 1));
4211 if (INTEGERP (value
) && window_resize_check (r
, 0))
4214 window_resize_apply (r
, 0);
4216 /* Shrink the mini-window. */
4217 wset_top_line (w
, make_number (XFASTINT (r
->top_line
)
4218 + XFASTINT (r
->total_lines
)));
4219 wset_total_lines (w
, make_number (1));
4221 w
->last_modified
= 0;
4222 w
->last_overlay_modified
= 0;
4224 windows_or_buffers_changed
++;
4228 /* If the above failed for whatever strange reason we must make a
4229 one window frame here. The same routine will be needed when
4230 shrinking the frame (and probably when making the initial
4231 *scratch* window). For the moment leave things as they are. */
4235 DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal
, Sresize_mini_window_internal
, 1, 1, 0,
4236 doc
: /* Resize minibuffer window WINDOW. */)
4237 (Lisp_Object window
)
4239 struct window
*w
= XWINDOW (window
);
4244 CHECK_WINDOW (window
);
4245 f
= XFRAME (w
->frame
);
4247 if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w
->frame
)), window
))
4248 error ("Not a valid minibuffer window");
4249 else if (FRAME_MINIBUF_ONLY_P (f
))
4250 error ("Cannot resize a minibuffer-only frame");
4252 r
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4253 height
= XINT (r
->total_lines
) + XINT (w
->total_lines
);
4254 if (window_resize_check (r
, 0)
4255 && XINT (w
->new_total
) > 0
4256 && height
== XINT (r
->new_total
) + XINT (w
->new_total
))
4259 window_resize_apply (r
, 0);
4261 wset_total_lines (w
, w
->new_total
);
4262 wset_top_line (w
, make_number (XINT (r
->top_line
)
4263 + XINT (r
->total_lines
)));
4265 windows_or_buffers_changed
++;
4266 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4270 run_window_configuration_change_hook (f
);
4273 else error ("Failed to resize minibuffer window");
4276 /* Mark window cursors off for all windows in the window tree rooted
4277 at W by setting their phys_cursor_on_p flag to zero. Called from
4278 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4279 the frame are cleared. */
4282 mark_window_cursors_off (struct window
*w
)
4286 if (!NILP (w
->hchild
))
4287 mark_window_cursors_off (XWINDOW (w
->hchild
));
4288 else if (!NILP (w
->vchild
))
4289 mark_window_cursors_off (XWINDOW (w
->vchild
));
4291 w
->phys_cursor_on_p
= 0;
4293 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4298 /* Return number of lines of text (not counting mode lines) in W. */
4301 window_internal_height (struct window
*w
)
4303 int ht
= XFASTINT (w
->total_lines
);
4305 if (!MINI_WINDOW_P (w
))
4307 if (!NILP (w
->parent
)
4308 || !NILP (w
->vchild
)
4309 || !NILP (w
->hchild
)
4312 || WINDOW_WANTS_MODELINE_P (w
))
4315 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4322 /************************************************************************
4324 ***********************************************************************/
4326 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4327 N screen-fulls, which is defined as the height of the window minus
4328 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4329 instead. Negative values of N mean scroll down. NOERROR non-zero
4330 means don't signal an error if we try to move over BEGV or ZV,
4334 window_scroll (Lisp_Object window
, EMACS_INT n
, int whole
, int noerror
)
4337 n
= clip_to_bounds (INT_MIN
, n
, INT_MAX
);
4339 /* If we must, use the pixel-based version which is much slower than
4340 the line-based one but can handle varying line heights. */
4341 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4342 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4344 window_scroll_line_based (window
, n
, whole
, noerror
);
4350 /* Implementation of window_scroll that works based on pixel line
4351 heights. See the comment of window_scroll for parameter
4355 window_scroll_pixel_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4358 struct window
*w
= XWINDOW (window
);
4359 struct text_pos start
;
4360 int this_scroll_margin
;
4361 /* True if we fiddled the window vscroll field without really scrolling. */
4363 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4364 void *itdata
= NULL
;
4366 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4367 /* Scrolling a minibuffer window via scroll bar when the echo area
4368 shows long text sometimes resets the minibuffer contents behind
4370 if (CHARPOS (start
) > ZV
)
4371 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4373 /* If PT is not visible in WINDOW, move back one half of
4374 the screen. Allow PT to be partially visible, otherwise
4375 something like (scroll-down 1) with PT in the line before
4376 the partially visible one would recenter. */
4378 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4380 itdata
= bidi_shelve_cache ();
4381 /* Move backward half the height of the window. Performance note:
4382 vmotion used here is about 10% faster, but would give wrong
4383 results for variable height lines. */
4384 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4385 it
.current_y
= it
.last_visible_y
;
4386 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4388 /* The function move_iterator_vertically may move over more than
4389 the specified y-distance. If it->w is small, e.g. a
4390 mini-buffer window, we may end up in front of the window's
4391 display area. This is the case when Start displaying at the
4392 start of the line containing PT in this case. */
4393 if (it
.current_y
<= 0)
4395 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4396 move_it_vertically_backward (&it
, 0);
4400 start
= it
.current
.pos
;
4401 bidi_unshelve_cache (itdata
, 0);
4403 else if (auto_window_vscroll_p
)
4405 if (rtop
|| rbot
) /* partially visible */
4408 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4410 dy
= max ((window_box_height (w
)
4411 - next_screen_context_lines
* dy
),
4417 /* Only vscroll backwards if already vscrolled forwards. */
4418 if (w
->vscroll
< 0 && rtop
> 0)
4420 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
4421 Fset_window_vscroll (window
, make_number (px
), Qt
);
4427 /* Do vscroll if already vscrolled or only display line. */
4428 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
4430 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
4431 Fset_window_vscroll (window
, make_number (px
), Qt
);
4435 /* Maybe modify window start instead of scrolling. */
4436 if (rbot
> 0 || w
->vscroll
< 0)
4440 Fset_window_vscroll (window
, make_number (0), Qt
);
4441 /* If there are other text lines above the current row,
4442 move window start to current row. Else to next row. */
4444 spos
= XINT (Fline_beginning_position (Qnil
));
4446 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
4447 set_marker_restricted (w
->start
, make_number (spos
),
4449 w
->start_at_line_beg
= 1;
4450 w
->update_mode_line
= 1;
4451 w
->last_modified
= 0;
4452 w
->last_overlay_modified
= 0;
4453 /* Set force_start so that redisplay_window will run the
4454 window-scroll-functions. */
4460 /* Cancel previous vscroll. */
4461 Fset_window_vscroll (window
, make_number (0), Qt
);
4464 itdata
= bidi_shelve_cache ();
4465 /* If scroll_preserve_screen_position is non-nil, we try to set
4466 point in the same window line as it is now, so get that line. */
4467 if (!NILP (Vscroll_preserve_screen_position
))
4469 /* We preserve the goal pixel coordinate across consecutive
4470 calls to scroll-up, scroll-down and other commands that
4471 have the `scroll-command' property. This avoids the
4472 possibility of point becoming "stuck" on a tall line when
4473 scrolling by one line. */
4474 if (window_scroll_pixel_based_preserve_y
< 0
4475 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4476 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4478 start_display (&it
, w
, start
);
4479 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4480 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4481 window_scroll_pixel_based_preserve_x
= it
.current_x
;
4485 window_scroll_pixel_based_preserve_y
4486 = window_scroll_pixel_based_preserve_x
= -1;
4488 /* Move iterator it from start the specified distance forward or
4489 backward. The result is the new window start. */
4490 start_display (&it
, w
, start
);
4493 ptrdiff_t start_pos
= IT_CHARPOS (it
);
4494 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4495 dy
= max ((window_box_height (w
)
4496 - next_screen_context_lines
* dy
),
4499 /* Note that move_it_vertically always moves the iterator to the
4500 start of a line. So, if the last line doesn't have a newline,
4501 we would end up at the start of the line ending at ZV. */
4504 move_it_vertically_backward (&it
, -dy
);
4505 /* Ensure we actually do move, e.g. in case we are currently
4506 looking at an image that is taller that the window height. */
4507 while (start_pos
== IT_CHARPOS (it
)
4508 && start_pos
> BEGV
)
4509 move_it_by_lines (&it
, -1);
4513 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4514 MOVE_TO_POS
| MOVE_TO_Y
);
4515 /* Ensure we actually do move, e.g. in case we are currently
4516 looking at an image that is taller that the window height. */
4517 while (start_pos
== IT_CHARPOS (it
)
4519 move_it_by_lines (&it
, 1);
4523 move_it_by_lines (&it
, n
);
4525 /* We failed if we find ZV is already on the screen (scrolling up,
4526 means there's nothing past the end), or if we can't start any
4527 earlier (scrolling down, means there's nothing past the top). */
4528 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4529 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4531 if (IT_CHARPOS (it
) == ZV
)
4533 if (it
.current_y
< it
.last_visible_y
4534 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4535 > it
.last_visible_y
))
4537 /* The last line was only partially visible, make it fully
4539 w
->vscroll
= (it
.last_visible_y
4540 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4541 adjust_glyphs (it
.f
);
4545 bidi_unshelve_cache (itdata
, 0);
4548 else if (n
< 0) /* could happen with empty buffers */
4549 xsignal0 (Qbeginning_of_buffer
);
4551 xsignal0 (Qend_of_buffer
);
4556 if (w
->vscroll
!= 0)
4557 /* The first line was only partially visible, make it fully
4562 bidi_unshelve_cache (itdata
, 0);
4566 xsignal0 (Qbeginning_of_buffer
);
4570 /* If control gets here, then we vscrolled. */
4572 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4574 /* Don't try to change the window start below. */
4580 ptrdiff_t pos
= IT_CHARPOS (it
);
4583 /* If in the middle of a multi-glyph character move forward to
4584 the next character. */
4585 if (in_display_vector_p (&it
))
4588 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4591 /* Set the window start, and set up the window for redisplay. */
4592 set_marker_restricted (w
->start
, make_number (pos
),
4594 bytepos
= XMARKER (w
->start
)->bytepos
;
4595 w
->start_at_line_beg
= (pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n');
4596 w
->update_mode_line
= 1;
4597 w
->last_modified
= 0;
4598 w
->last_overlay_modified
= 0;
4599 /* Set force_start so that redisplay_window will run the
4600 window-scroll-functions. */
4604 /* The rest of this function uses current_y in a nonstandard way,
4605 not including the height of the header line if any. */
4606 it
.current_y
= it
.vpos
= 0;
4608 /* Move PT out of scroll margins.
4609 This code wants current_y to be zero at the window start position
4610 even if there is a header line. */
4611 this_scroll_margin
= max (0, scroll_margin
);
4613 = min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4614 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4618 /* We moved the window start towards ZV, so PT may be now
4619 in the scroll margin at the top. */
4620 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4621 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4622 && (NILP (Vscroll_preserve_screen_position
)
4623 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4624 /* We found PT at a legitimate height. Leave it alone. */
4626 else if (window_scroll_pixel_based_preserve_y
>= 0)
4628 /* If we have a header line, take account of it.
4629 This is necessary because we set it.current_y to 0, above. */
4630 move_it_to (&it
, -1,
4631 window_scroll_pixel_based_preserve_x
,
4632 window_scroll_pixel_based_preserve_y
4633 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4634 -1, MOVE_TO_Y
| MOVE_TO_X
);
4635 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4639 while (it
.current_y
< this_scroll_margin
)
4641 int prev
= it
.current_y
;
4642 move_it_by_lines (&it
, 1);
4643 if (prev
== it
.current_y
)
4646 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4651 ptrdiff_t charpos
, bytepos
;
4654 /* Save our position, for the
4655 window_scroll_pixel_based_preserve_y case. */
4656 charpos
= IT_CHARPOS (it
);
4657 bytepos
= IT_BYTEPOS (it
);
4659 /* We moved the window start towards BEGV, so PT may be now
4660 in the scroll margin at the bottom. */
4661 move_it_to (&it
, PT
, -1,
4662 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4663 - this_scroll_margin
- 1),
4665 MOVE_TO_POS
| MOVE_TO_Y
);
4667 /* Save our position, in case it's correct. */
4668 charpos
= IT_CHARPOS (it
);
4669 bytepos
= IT_BYTEPOS (it
);
4671 /* See if point is on a partially visible line at the end. */
4672 if (it
.what
== IT_EOB
)
4673 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4676 move_it_by_lines (&it
, 1);
4677 partial_p
= it
.current_y
> it
.last_visible_y
;
4680 if (charpos
== PT
&& !partial_p
4681 && (NILP (Vscroll_preserve_screen_position
)
4682 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4683 /* We found PT before we found the display margin, so PT is ok. */
4685 else if (window_scroll_pixel_based_preserve_y
>= 0)
4687 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4688 start_display (&it
, w
, start
);
4689 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
4690 here because we called start_display again and did not
4691 alter it.current_y this time. */
4692 move_it_to (&it
, -1, window_scroll_pixel_based_preserve_x
,
4693 window_scroll_pixel_based_preserve_y
, -1,
4694 MOVE_TO_Y
| MOVE_TO_X
);
4695 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4700 /* The last line was only partially visible, so back up two
4701 lines to make sure we're on a fully visible line. */
4703 move_it_by_lines (&it
, -2);
4704 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4707 /* No, the position we saved is OK, so use it. */
4708 SET_PT_BOTH (charpos
, bytepos
);
4711 bidi_unshelve_cache (itdata
, 0);
4715 /* Implementation of window_scroll that works based on screen lines.
4716 See the comment of window_scroll for parameter descriptions. */
4719 window_scroll_line_based (Lisp_Object window
, int n
, int whole
, int noerror
)
4721 register struct window
*w
= XWINDOW (window
);
4722 /* Fvertical_motion enters redisplay, which can trigger
4723 fontification, which in turn can modify buffer text (e.g., if the
4724 fontification functions replace escape sequences with faces, as
4725 in `grep-mode-font-lock-keywords'). So we use a marker to record
4726 the old point position, to prevent crashes in SET_PT_BOTH. */
4727 Lisp_Object opoint_marker
= Fpoint_marker ();
4728 register ptrdiff_t pos
, pos_byte
;
4729 register int ht
= window_internal_height (w
);
4730 register Lisp_Object tem
;
4734 Lisp_Object original_pos
= Qnil
;
4736 /* If scrolling screen-fulls, compute the number of lines to
4737 scroll from the window's height. */
4739 n
*= max (1, ht
- next_screen_context_lines
);
4741 startpos
= marker_position (w
->start
);
4743 if (!NILP (Vscroll_preserve_screen_position
))
4745 if (window_scroll_preserve_vpos
<= 0
4746 || !SYMBOLP (KVAR (current_kboard
, Vlast_command
))
4747 || NILP (Fget (KVAR (current_kboard
, Vlast_command
), Qscroll_command
)))
4749 struct position posit
4750 = *compute_motion (startpos
, 0, 0, 0,
4754 window_scroll_preserve_vpos
= posit
.vpos
;
4755 window_scroll_preserve_hpos
= posit
.hpos
+ w
->hscroll
;
4758 original_pos
= Fcons (make_number (window_scroll_preserve_hpos
),
4759 make_number (window_scroll_preserve_vpos
));
4762 XSETFASTINT (tem
, PT
);
4763 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4767 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4772 lose
= n
< 0 && PT
== BEGV
;
4773 Fvertical_motion (make_number (n
), window
);
4777 SET_PT_BOTH (marker_position (opoint_marker
),
4778 marker_byte_position (opoint_marker
));
4785 xsignal0 (Qbeginning_of_buffer
);
4790 /* Don't use a scroll margin that is negative or too large. */
4791 int this_scroll_margin
=
4792 max (0, min (scroll_margin
, XINT (w
->total_lines
) / 4));
4794 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4795 w
->start_at_line_beg
= !NILP (bolp
);
4796 w
->update_mode_line
= 1;
4797 w
->last_modified
= 0;
4798 w
->last_overlay_modified
= 0;
4799 /* Set force_start so that redisplay_window will run
4800 the window-scroll-functions. */
4803 if (!NILP (Vscroll_preserve_screen_position
)
4804 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4806 SET_PT_BOTH (pos
, pos_byte
);
4807 Fvertical_motion (original_pos
, window
);
4809 /* If we scrolled forward, put point enough lines down
4810 that it is outside the scroll margin. */
4815 if (this_scroll_margin
> 0)
4817 SET_PT_BOTH (pos
, pos_byte
);
4818 Fvertical_motion (make_number (this_scroll_margin
), window
);
4824 if (top_margin
<= marker_position (opoint_marker
))
4825 SET_PT_BOTH (marker_position (opoint_marker
),
4826 marker_byte_position (opoint_marker
));
4827 else if (!NILP (Vscroll_preserve_screen_position
))
4829 SET_PT_BOTH (pos
, pos_byte
);
4830 Fvertical_motion (original_pos
, window
);
4833 SET_PT (top_margin
);
4839 /* If we scrolled backward, put point near the end of the window
4840 but not within the scroll margin. */
4841 SET_PT_BOTH (pos
, pos_byte
);
4842 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4843 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4846 bottom_margin
= PT
+ 1;
4848 if (bottom_margin
> marker_position (opoint_marker
))
4849 SET_PT_BOTH (marker_position (opoint_marker
),
4850 marker_byte_position (opoint_marker
));
4853 if (!NILP (Vscroll_preserve_screen_position
))
4855 SET_PT_BOTH (pos
, pos_byte
);
4856 Fvertical_motion (original_pos
, window
);
4859 Fvertical_motion (make_number (-1), window
);
4868 xsignal0 (Qend_of_buffer
);
4873 /* Scroll selected_window up or down. If N is nil, scroll a
4874 screen-full which is defined as the height of the window minus
4875 next_screen_context_lines. If N is the symbol `-', scroll.
4876 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4877 up. This is the guts of Fscroll_up and Fscroll_down. */
4880 scroll_command (Lisp_Object n
, int direction
)
4882 ptrdiff_t count
= SPECPDL_INDEX ();
4884 eassert (eabs (direction
) == 1);
4886 /* If selected window's buffer isn't current, make it current for
4887 the moment. But don't screw up if window_scroll gets an error. */
4888 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4890 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4891 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4893 /* Make redisplay consider other windows than just selected_window. */
4894 ++windows_or_buffers_changed
;
4898 window_scroll (selected_window
, direction
, 1, 0);
4899 else if (EQ (n
, Qminus
))
4900 window_scroll (selected_window
, -direction
, 1, 0);
4903 n
= Fprefix_numeric_value (n
);
4904 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4907 unbind_to (count
, Qnil
);
4910 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "^P",
4911 doc
: /* Scroll text of selected window upward ARG lines.
4912 If ARG is omitted or nil, scroll upward by a near full screen.
4913 A near full screen is `next-screen-context-lines' less than a full screen.
4914 Negative ARG means scroll downward.
4915 If ARG is the atom `-', scroll downward by nearly full screen.
4916 When calling from a program, supply as argument a number, nil, or `-'. */)
4919 scroll_command (arg
, 1);
4923 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "^P",
4924 doc
: /* Scroll text of selected window down ARG lines.
4925 If ARG is omitted or nil, scroll down by a near full screen.
4926 A near full screen is `next-screen-context-lines' less than a full screen.
4927 Negative ARG means scroll upward.
4928 If ARG is the atom `-', scroll upward by nearly full screen.
4929 When calling from a program, supply as argument a number, nil, or `-'. */)
4932 scroll_command (arg
, -1);
4936 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4937 doc
: /* Return the other window for \"other window scroll\" commands.
4938 If `other-window-scroll-buffer' is non-nil, a window
4939 showing that buffer is used.
4940 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4941 specifies the window. This takes precedence over
4942 `other-window-scroll-buffer'. */)
4947 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4948 && !NILP (Vminibuf_scroll_window
))
4949 window
= Vminibuf_scroll_window
;
4950 /* If buffer is specified, scroll that buffer. */
4951 else if (!NILP (Vother_window_scroll_buffer
))
4953 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4955 window
= display_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4959 /* Nothing specified; look for a neighboring window on the same
4961 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4963 if (EQ (window
, selected_window
))
4964 /* That didn't get us anywhere; look for a window on another
4967 window
= Fnext_window (window
, Qnil
, Qt
);
4968 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4969 && ! EQ (window
, selected_window
));
4972 CHECK_LIVE_WINDOW (window
);
4974 if (EQ (window
, selected_window
))
4975 error ("There is no other window");
4980 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4981 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4982 A near full screen is `next-screen-context-lines' less than a full screen.
4983 The next window is the one below the current one; or the one at the top
4984 if the current one is at the bottom. Negative ARG means scroll downward.
4985 If ARG is the atom `-', scroll downward by nearly full screen.
4986 When calling from a program, supply as argument a number, nil, or `-'.
4988 If `other-window-scroll-buffer' is non-nil, scroll the window
4989 showing that buffer, popping the buffer up if necessary.
4990 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4991 specifies the window to scroll. This takes precedence over
4992 `other-window-scroll-buffer'. */)
4997 ptrdiff_t count
= SPECPDL_INDEX ();
4999 window
= Fother_window_for_scrolling ();
5000 w
= XWINDOW (window
);
5002 /* Don't screw up if window_scroll gets an error. */
5003 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5004 ++windows_or_buffers_changed
;
5006 Fset_buffer (w
->buffer
);
5007 SET_PT (marker_position (w
->pointm
));
5010 window_scroll (window
, 1, 1, 1);
5011 else if (EQ (arg
, Qminus
))
5012 window_scroll (window
, -1, 1, 1);
5018 window_scroll (window
, XINT (arg
), 0, 1);
5021 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5022 unbind_to (count
, Qnil
);
5027 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "^P\np",
5028 doc
: /* Scroll selected window display ARG columns left.
5029 Default for ARG is window width minus 2.
5030 Value is the total amount of leftward horizontal scrolling in
5031 effect after the change.
5032 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5033 lower bound for automatic scrolling, i.e. automatic scrolling
5034 will not scroll a window to a column less than the value returned
5035 by this function. This happens in an interactive call. */)
5036 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5038 struct window
*w
= XWINDOW (selected_window
);
5039 EMACS_INT requested_arg
= (NILP (arg
)
5040 ? window_body_cols (w
) - 2
5041 : XINT (Fprefix_numeric_value (arg
)));
5042 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
+ requested_arg
);
5044 if (!NILP (set_minimum
))
5045 w
->min_hscroll
= w
->hscroll
;
5050 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "^P\np",
5051 doc
: /* Scroll selected window display ARG columns right.
5052 Default for ARG is window width minus 2.
5053 Value is the total amount of leftward horizontal scrolling in
5054 effect after the change.
5055 If SET-MINIMUM is non-nil, the new scroll amount becomes the
5056 lower bound for automatic scrolling, i.e. automatic scrolling
5057 will not scroll a window to a column less than the value returned
5058 by this function. This happens in an interactive call. */)
5059 (register Lisp_Object arg
, Lisp_Object set_minimum
)
5061 struct window
*w
= XWINDOW (selected_window
);
5062 EMACS_INT requested_arg
= (NILP (arg
)
5063 ? window_body_cols (w
) - 2
5064 : XINT (Fprefix_numeric_value (arg
)));
5065 Lisp_Object result
= set_window_hscroll (w
, w
->hscroll
- requested_arg
);
5067 if (!NILP (set_minimum
))
5068 w
->min_hscroll
= w
->hscroll
;
5073 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5074 doc
: /* Return the window which was selected when entering the minibuffer.
5075 Returns nil, if selected window is not a minibuffer window. */)
5078 if (minibuf_level
> 0
5079 && MINI_WINDOW_P (XWINDOW (selected_window
))
5080 && WINDOW_LIVE_P (minibuf_selected_window
))
5081 return minibuf_selected_window
;
5086 /* Value is the number of lines actually displayed in window W,
5087 as opposed to its height. */
5090 displayed_window_lines (struct window
*w
)
5093 struct text_pos start
;
5094 int height
= window_box_height (w
);
5095 struct buffer
*old_buffer
;
5097 void *itdata
= NULL
;
5099 if (XBUFFER (w
->buffer
) != current_buffer
)
5101 old_buffer
= current_buffer
;
5102 set_buffer_internal (XBUFFER (w
->buffer
));
5107 /* In case W->start is out of the accessible range, do something
5108 reasonable. This happens in Info mode when Info-scroll-down
5109 calls (recenter -1) while W->start is 1. */
5110 if (XMARKER (w
->start
)->charpos
< BEGV
)
5111 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5112 else if (XMARKER (w
->start
)->charpos
> ZV
)
5113 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5115 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5117 itdata
= bidi_shelve_cache ();
5118 start_display (&it
, w
, start
);
5119 move_it_vertically (&it
, height
);
5120 bottom_y
= line_bottom_y (&it
);
5121 bidi_unshelve_cache (itdata
, 0);
5123 /* rms: On a non-window display,
5124 the value of it.vpos at the bottom of the screen
5125 seems to be 1 larger than window_box_height (w).
5126 This kludge fixes a bug whereby (move-to-window-line -1)
5127 when ZV is on the last screen line
5128 moves to the previous screen line instead of the last one. */
5129 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5132 /* Add in empty lines at the bottom of the window. */
5133 if (bottom_y
< height
)
5135 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5136 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5140 set_buffer_internal (old_buffer
);
5146 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5147 doc
: /* Center point in selected window and maybe redisplay frame.
5148 With prefix argument ARG, recenter putting point on screen line ARG
5149 relative to the selected window. If ARG is negative, it counts up from the
5150 bottom of the window. (ARG should be less than the height of the window.)
5152 If ARG is omitted or nil, then recenter with point on the middle line of
5153 the selected window; if the variable `recenter-redisplay' is non-nil,
5154 also erase the entire frame and redraw it (when `auto-resize-tool-bars'
5155 is set to `grow-only', this resets the tool-bar's height to the minimum
5156 height needed); if `recenter-redisplay' has the special value `tty',
5157 then only tty frames are redrawn.
5159 Just C-u as prefix means put point in the center of the window
5160 and redisplay normally--don't erase and redraw the frame. */)
5161 (register Lisp_Object arg
)
5163 struct window
*w
= XWINDOW (selected_window
);
5164 struct buffer
*buf
= XBUFFER (w
->buffer
);
5165 struct buffer
*obuf
= current_buffer
;
5167 ptrdiff_t charpos
, bytepos
;
5168 EMACS_INT iarg
IF_LINT (= 0);
5169 int this_scroll_margin
;
5171 /* If redisplay is suppressed due to an error, try again. */
5172 obuf
->display_error_modiff
= 0;
5176 if (!NILP (Vrecenter_redisplay
)
5177 && (!EQ (Vrecenter_redisplay
, Qtty
)
5178 || !NILP (Ftty_type (selected_frame
))))
5182 /* Invalidate pixel data calculated for all compositions. */
5183 for (i
= 0; i
< n_compositions
; i
++)
5184 composition_table
[i
]->font
= NULL
;
5186 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5188 Fredraw_frame (WINDOW_FRAME (w
));
5189 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5194 else if (CONSP (arg
)) /* Just C-u. */
5198 arg
= Fprefix_numeric_value (arg
);
5203 set_buffer_internal (buf
);
5205 /* Do this after making BUF current
5206 in case scroll_margin is buffer-local. */
5207 this_scroll_margin
=
5208 max (0, min (scroll_margin
, XFASTINT (w
->total_lines
) / 4));
5210 /* Handle centering on a graphical frame specially. Such frames can
5211 have variable-height lines and centering point on the basis of
5212 line counts would lead to strange effects. */
5213 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5219 void *itdata
= bidi_shelve_cache ();
5221 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5222 start_display (&it
, w
, pt
);
5223 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5224 charpos
= IT_CHARPOS (it
);
5225 bytepos
= IT_BYTEPOS (it
);
5226 bidi_unshelve_cache (itdata
, 0);
5232 ptrdiff_t nlines
= min (PTRDIFF_MAX
, -iarg
);
5233 int extra_line_spacing
;
5234 int h
= window_box_height (w
);
5235 void *itdata
= bidi_shelve_cache ();
5237 iarg
= - max (-iarg
, this_scroll_margin
);
5239 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5240 start_display (&it
, w
, pt
);
5242 /* Be sure we have the exact height of the full line containing PT. */
5243 move_it_by_lines (&it
, 0);
5245 /* The amount of pixels we have to move back is the window
5246 height minus what's displayed in the line containing PT,
5247 and the lines below. */
5250 move_it_by_lines (&it
, nlines
);
5252 if (it
.vpos
== nlines
)
5256 /* Last line has no newline */
5257 h
-= line_bottom_y (&it
);
5261 /* Don't reserve space for extra line spacing of last line. */
5262 extra_line_spacing
= it
.max_extra_line_spacing
;
5264 /* If we can't move down NLINES lines because we hit
5265 the end of the buffer, count in some empty lines. */
5266 if (it
.vpos
< nlines
)
5269 extra_line_spacing
= it
.extra_line_spacing
;
5270 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5274 bidi_unshelve_cache (itdata
, 0);
5278 /* Now find the new top line (starting position) of the window. */
5279 start_display (&it
, w
, pt
);
5281 move_it_vertically_backward (&it
, h
);
5283 /* If extra line spacing is present, we may move too far
5284 back. This causes the last line to be only partially
5285 visible (which triggers redisplay to recenter that line
5286 in the middle), so move forward.
5287 But ignore extra line spacing on last line, as it is not
5288 considered to be part of the visible height of the line.
5290 h
+= extra_line_spacing
;
5291 while (-it
.current_y
> h
)
5292 move_it_by_lines (&it
, 1);
5294 charpos
= IT_CHARPOS (it
);
5295 bytepos
= IT_BYTEPOS (it
);
5297 bidi_unshelve_cache (itdata
, 0);
5301 struct position pos
;
5303 iarg
= max (iarg
, this_scroll_margin
);
5305 pos
= *vmotion (PT
, -iarg
, w
);
5306 charpos
= pos
.bufpos
;
5307 bytepos
= pos
.bytepos
;
5312 struct position pos
;
5313 int ht
= window_internal_height (w
);
5320 /* Don't let it get into the margin at either top or bottom. */
5321 iarg
= max (iarg
, this_scroll_margin
);
5322 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5324 pos
= *vmotion (PT
, - iarg
, w
);
5325 charpos
= pos
.bufpos
;
5326 bytepos
= pos
.bytepos
;
5329 /* Set the new window start. */
5330 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5331 wset_window_end_valid (w
, Qnil
);
5333 w
->optional_new_start
= 1;
5335 w
->start_at_line_beg
= (bytepos
== BEGV_BYTE
||
5336 FETCH_BYTE (bytepos
- 1) == '\n');
5338 set_buffer_internal (obuf
);
5342 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5344 doc
: /* Return the height in lines of the text display area of WINDOW.
5345 WINDOW must be a live window and defaults to the selected one.
5347 The returned height does not include the mode line, any header line,
5348 nor any partial-height lines at the bottom of the text area. */)
5349 (Lisp_Object window
)
5351 struct window
*w
= decode_live_window (window
);
5352 int pixel_height
= window_box_height (w
);
5353 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5354 return make_number (line_height
);
5359 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5361 doc
: /* Position point relative to window.
5362 ARG nil means position point at center of window.
5363 Else, ARG specifies vertical position within the window;
5364 zero means top of window, negative means relative to bottom of window. */)
5367 struct window
*w
= XWINDOW (selected_window
);
5371 int this_scroll_margin
;
5374 if (!(BUFFERP (w
->buffer
)
5375 && XBUFFER (w
->buffer
) == current_buffer
))
5376 /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
5377 when passed below to set_marker_both. */
5378 error ("move-to-window-line called from unrelated buffer");
5380 window
= selected_window
;
5381 start
= marker_position (w
->start
);
5382 if (start
< BEGV
|| start
> ZV
)
5384 int height
= window_internal_height (w
);
5385 Fvertical_motion (make_number (- (height
/ 2)), window
);
5386 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5387 w
->start_at_line_beg
= !NILP (Fbolp ());
5391 Fgoto_char (w
->start
);
5393 lines
= displayed_window_lines (w
);
5396 this_scroll_margin
= max (0, min (scroll_margin
, lines
/ 4));
5400 XSETFASTINT (arg
, lines
/ 2);
5403 EMACS_INT iarg
= XINT (Fprefix_numeric_value (arg
));
5406 iarg
= iarg
+ lines
;
5408 #if 0 /* This code would prevent move-to-window-line from moving point
5409 to a place inside the scroll margins (which would cause the
5410 next redisplay to scroll). I wrote this code, but then concluded
5411 it is probably better not to install it. However, it is here
5412 inside #if 0 so as not to lose it. -- rms. */
5414 /* Don't let it get into the margin at either top or bottom. */
5415 iarg
= max (iarg
, this_scroll_margin
);
5416 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5419 arg
= make_number (iarg
);
5422 /* Skip past a partially visible first line. */
5424 XSETINT (arg
, XINT (arg
) + 1);
5426 return Fvertical_motion (arg
, window
);
5431 /***********************************************************************
5432 Window Configuration
5433 ***********************************************************************/
5435 struct save_window_data
5437 struct vectorlike_header header
;
5438 Lisp_Object selected_frame
;
5439 Lisp_Object current_window
;
5440 Lisp_Object current_buffer
;
5441 Lisp_Object minibuf_scroll_window
;
5442 Lisp_Object minibuf_selected_window
;
5443 Lisp_Object root_window
;
5444 Lisp_Object focus_frame
;
5445 /* A vector, each of whose elements is a struct saved_window
5447 Lisp_Object saved_windows
;
5449 /* All fields above are traced by the GC.
5450 From `fame-cols' down, the fields are ignored by the GC. */
5452 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
5453 int frame_tool_bar_lines
;
5456 /* This is saved as a Lisp_Vector */
5459 struct vectorlike_header header
;
5461 Lisp_Object window
, buffer
, start
, pointm
, mark
;
5462 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5463 Lisp_Object normal_cols
, normal_lines
;
5464 Lisp_Object hscroll
, min_hscroll
;
5465 Lisp_Object parent
, prev
;
5466 Lisp_Object start_at_line_beg
;
5467 Lisp_Object display_table
;
5468 Lisp_Object left_margin_cols
, right_margin_cols
;
5469 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5470 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
, dedicated
;
5471 Lisp_Object combination_limit
, window_parameters
;
5474 #define SAVED_WINDOW_N(swv,n) \
5475 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5477 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5478 doc
: /* Return t if OBJECT is a window-configuration object. */)
5479 (Lisp_Object object
)
5481 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5484 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5485 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5486 (Lisp_Object config
)
5488 register struct save_window_data
*data
;
5489 struct Lisp_Vector
*saved_windows
;
5491 CHECK_WINDOW_CONFIGURATION (config
);
5493 data
= (struct save_window_data
*) XVECTOR (config
);
5494 saved_windows
= XVECTOR (data
->saved_windows
);
5495 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5498 DEFUN ("set-window-configuration", Fset_window_configuration
,
5499 Sset_window_configuration
, 1, 1, 0,
5500 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5501 CONFIGURATION must be a value previously returned
5502 by `current-window-configuration' (which see).
5503 If CONFIGURATION was made from a frame that is now deleted,
5504 only frame-independent values can be restored. In this case,
5505 the return value is nil. Otherwise the value is t. */)
5506 (Lisp_Object configuration
)
5508 register struct save_window_data
*data
;
5509 struct Lisp_Vector
*saved_windows
;
5510 Lisp_Object new_current_buffer
;
5513 ptrdiff_t old_point
= -1;
5515 CHECK_WINDOW_CONFIGURATION (configuration
);
5517 data
= (struct save_window_data
*) XVECTOR (configuration
);
5518 saved_windows
= XVECTOR (data
->saved_windows
);
5520 new_current_buffer
= data
->current_buffer
;
5521 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer
)))
5522 new_current_buffer
= Qnil
;
5525 if (XBUFFER (new_current_buffer
) == current_buffer
)
5526 /* The code further down "preserves point" by saving here PT in
5527 old_point and then setting it later back into PT. When the
5528 current-selected-window and the final-selected-window both show
5529 the current buffer, this suffers from the problem that the
5530 current PT is the window-point of the current-selected-window,
5531 while the final PT is the point of the final-selected-window, so
5532 this copy from one PT to the other would end up moving the
5533 window-point of the final-selected-window to the window-point of
5534 the current-selected-window. So we have to be careful which
5535 point of the current-buffer we copy into old_point. */
5536 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5537 && WINDOWP (selected_window
)
5538 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5539 && !EQ (selected_window
, data
->current_window
))
5540 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5544 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5545 point in new_current_buffer as of the last time this buffer was
5546 used. This can be non-deterministic since it can be changed by
5547 things like jit-lock by mere temporary selection of some random
5548 window that happens to show this buffer.
5549 So if possible we want this arbitrary choice of "which point" to
5550 be the one from the to-be-selected-window so as to prevent this
5551 window's cursor from being copied from another window. */
5552 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5553 /* If current_window = selected_window, its point is in BUF_PT. */
5554 && !EQ (selected_window
, data
->current_window
))
5555 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5557 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5560 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5563 /* If f is a dead frame, don't bother rebuilding its window tree.
5564 However, there is other stuff we should still try to do below. */
5565 if (FRAME_LIVE_P (f
))
5568 Lisp_Object dead_windows
= Qnil
;
5569 register Lisp_Object tem
, par
, pers
;
5570 register struct window
*w
;
5571 register struct saved_window
*p
;
5572 struct window
*root_window
;
5573 struct window
**leaf_windows
;
5578 /* If the frame has been resized since this window configuration was
5579 made, we change the frame to the size specified in the
5580 configuration, restore the configuration, and then resize it
5581 back. We keep track of the prevailing height in these variables. */
5582 int previous_frame_lines
= FRAME_LINES (f
);
5583 int previous_frame_cols
= FRAME_COLS (f
);
5584 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5585 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5587 /* Don't do this within the main loop below: This may call Lisp
5588 code and is thus potentially unsafe while input is blocked. */
5589 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5591 p
= SAVED_WINDOW_N (saved_windows
, k
);
5593 w
= XWINDOW (window
);
5594 if (!NILP (w
->buffer
)
5595 && !EQ (w
->buffer
, p
->buffer
)
5596 && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5597 /* If a window we restore gets another buffer, record the
5598 window's old buffer. */
5599 call1 (Qrecord_window_buffer
, window
);
5602 /* The mouse highlighting code could get screwed up
5603 if it runs during this. */
5606 if (data
->frame_lines
!= previous_frame_lines
5607 || data
->frame_cols
!= previous_frame_cols
)
5608 change_frame_size (f
, data
->frame_lines
,
5609 data
->frame_cols
, 0, 0, 0);
5610 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5611 if (data
->frame_menu_bar_lines
5612 != previous_frame_menu_bar_lines
)
5613 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
5615 #ifdef HAVE_WINDOW_SYSTEM
5616 if (data
->frame_tool_bar_lines
5617 != previous_frame_tool_bar_lines
)
5618 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
5623 /* "Swap out" point from the selected window's buffer
5624 into the window itself. (Normally the pointm of the selected
5625 window holds garbage.) We do this now, before
5626 restoring the window contents, and prevent it from
5627 being done later on when we select a new window. */
5628 if (! NILP (XWINDOW (selected_window
)->buffer
))
5630 w
= XWINDOW (selected_window
);
5631 set_marker_both (w
->pointm
,
5633 BUF_PT (XBUFFER (w
->buffer
)),
5634 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5637 windows_or_buffers_changed
++;
5638 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5640 /* Problem: Freeing all matrices and later allocating them again
5641 is a serious redisplay flickering problem. What we would
5642 really like to do is to free only those matrices not reused
5644 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5645 leaf_windows
= alloca (count_windows (root_window
)
5646 * sizeof *leaf_windows
);
5647 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5650 Mark all windows now on frame as "deleted".
5651 Restoring the new configuration "undeletes" any that are in it.
5653 Save their current buffers in their height fields, since we may
5654 need it later, if a buffer saved in the configuration is now
5656 delete_all_child_windows (FRAME_ROOT_WINDOW (f
));
5658 for (k
= 0; k
< saved_windows
->header
.size
; k
++)
5660 p
= SAVED_WINDOW_N (saved_windows
, k
);
5662 w
= XWINDOW (window
);
5663 wset_next (w
, Qnil
);
5665 if (!NILP (p
->parent
))
5667 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->parent
))->window
);
5669 wset_parent (w
, Qnil
);
5671 if (!NILP (p
->prev
))
5674 (w
, SAVED_WINDOW_N (saved_windows
, XFASTINT (p
->prev
))->window
);
5675 wset_next (XWINDOW (w
->prev
), p
->window
);
5679 wset_prev (w
, Qnil
);
5680 if (!NILP (w
->parent
))
5682 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5684 wset_vchild (XWINDOW (w
->parent
), p
->window
);
5685 wset_hchild (XWINDOW (w
->parent
), Qnil
);
5689 wset_hchild (XWINDOW (w
->parent
), p
->window
);
5690 wset_vchild (XWINDOW (w
->parent
), Qnil
);
5695 /* If we squirreled away the buffer in the window's height,
5697 if (BUFFERP (w
->total_lines
))
5698 wset_buffer (w
, w
->total_lines
);
5699 wset_left_col (w
, p
->left_col
);
5700 wset_top_line (w
, p
->top_line
);
5701 wset_total_cols (w
, p
->total_cols
);
5702 wset_total_lines (w
, p
->total_lines
);
5703 wset_normal_cols (w
, p
->normal_cols
);
5704 wset_normal_lines (w
, p
->normal_lines
);
5705 w
->hscroll
= XFASTINT (p
->hscroll
);
5706 w
->min_hscroll
= XFASTINT (p
->min_hscroll
);
5707 wset_display_table (w
, p
->display_table
);
5708 wset_left_margin_cols (w
, p
->left_margin_cols
);
5709 wset_right_margin_cols (w
, p
->right_margin_cols
);
5710 wset_left_fringe_width (w
, p
->left_fringe_width
);
5711 wset_right_fringe_width (w
, p
->right_fringe_width
);
5712 w
->fringes_outside_margins
= !NILP (p
->fringes_outside_margins
);
5713 wset_scroll_bar_width (w
, p
->scroll_bar_width
);
5714 wset_vertical_scroll_bar_type (w
, p
->vertical_scroll_bar_type
);
5715 wset_dedicated (w
, p
->dedicated
);
5716 wset_combination_limit (w
, p
->combination_limit
);
5717 /* Restore any window parameters that have been saved.
5718 Parameters that have not been saved are left alone. */
5719 for (tem
= p
->window_parameters
; CONSP (tem
); tem
= XCDR (tem
))
5724 if (NILP (XCDR (pers
)))
5726 par
= Fassq (XCAR (pers
), w
->window_parameters
);
5727 if (CONSP (par
) && !NILP (XCDR (par
)))
5728 /* Reset a parameter to nil if and only if it
5729 has a non-nil association. Don't make new
5731 Fsetcdr (par
, Qnil
);
5734 /* Always restore a non-nil value. */
5735 Fset_window_parameter (window
, XCAR (pers
), XCDR (pers
));
5739 w
->last_modified
= 0;
5740 w
->last_overlay_modified
= 0;
5742 /* Reinstall the saved buffer and pointers into it. */
5743 if (NILP (p
->buffer
))
5744 /* An internal window. */
5745 wset_buffer (w
, p
->buffer
);
5746 else if (BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5747 /* If saved buffer is alive, install it. */
5749 wset_buffer (w
, p
->buffer
);
5750 w
->start_at_line_beg
= !NILP (p
->start_at_line_beg
);
5751 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5752 set_marker_restricted (w
->pointm
, p
->pointm
,
5754 Fset_marker (BVAR (XBUFFER (w
->buffer
), mark
),
5755 p
->mark
, w
->buffer
);
5757 /* As documented in Fcurrent_window_configuration, don't
5758 restore the location of point in the buffer which was
5759 current when the window configuration was recorded. */
5760 if (!EQ (p
->buffer
, new_current_buffer
)
5761 && XBUFFER (p
->buffer
) == current_buffer
)
5762 Fgoto_char (w
->pointm
);
5764 else if (!NILP (w
->buffer
)
5765 && BUFFER_LIVE_P (XBUFFER (w
->buffer
)))
5766 /* Keep window's old buffer; make sure the markers are
5769 /* Set window markers at start of visible range. */
5770 if (XMARKER (w
->start
)->buffer
== 0)
5771 set_marker_restricted (w
->start
, make_number (0),
5773 if (XMARKER (w
->pointm
)->buffer
== 0)
5774 set_marker_restricted_both
5775 (w
->pointm
, w
->buffer
,
5776 BUF_PT (XBUFFER (w
->buffer
)),
5777 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5778 w
->start_at_line_beg
= 1;
5781 /* Window has no live buffer, get one. */
5783 /* Get the buffer via other_buffer_safely in order to
5784 avoid showing an unimportant buffer and, if necessary, to
5785 recreate *scratch* in the course (part of Juanma's bs-show
5786 scenario from March 2011). */
5787 wset_buffer (w
, other_buffer_safely (Fcurrent_buffer ()));
5788 /* This will set the markers to beginning of visible
5790 set_marker_restricted (w
->start
,
5791 make_number (0), w
->buffer
);
5792 set_marker_restricted (w
->pointm
,
5793 make_number (0), w
->buffer
);
5794 w
->start_at_line_beg
= 1;
5795 if (!NILP (w
->dedicated
))
5796 /* Record this window as dead. */
5797 dead_windows
= Fcons (window
, dead_windows
);
5798 /* Make sure window is no more dedicated. */
5799 wset_dedicated (w
, Qnil
);
5803 fset_root_window (f
, data
->root_window
);
5804 /* Arrange *not* to restore point in the buffer that was
5805 current when the window configuration was saved. */
5806 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5807 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5808 make_number (old_point
),
5809 XWINDOW (data
->current_window
)->buffer
);
5811 /* In the following call to `select-window', prevent "swapping out
5812 point" in the old selected window using the buffer that has
5813 been restored into it. We already swapped out that point from
5814 that window's old buffer. */
5815 select_window (data
->current_window
, Qnil
, 1);
5816 BVAR (XBUFFER (XWINDOW (selected_window
)->buffer
), last_selected_window
)
5819 if (NILP (data
->focus_frame
)
5820 || (FRAMEP (data
->focus_frame
)
5821 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5822 Fredirect_frame_focus (frame
, data
->focus_frame
);
5824 /* Set the screen height to the value it had before this function. */
5825 if (previous_frame_lines
!= FRAME_LINES (f
)
5826 || previous_frame_cols
!= FRAME_COLS (f
))
5827 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5829 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5830 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5831 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5833 #ifdef HAVE_WINDOW_SYSTEM
5834 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5835 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5840 /* Now, free glyph matrices in windows that were not reused. */
5841 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5843 if (NILP (leaf_windows
[i
]->buffer
))
5845 /* Assert it's not reused as a combination. */
5846 eassert (NILP (leaf_windows
[i
]->hchild
)
5847 && NILP (leaf_windows
[i
]->vchild
));
5848 free_window_matrices (leaf_windows
[i
]);
5850 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5857 /* Scan dead buffer windows. */
5858 for (; CONSP (dead_windows
); dead_windows
= XCDR (dead_windows
))
5860 window
= XCAR (dead_windows
);
5861 if (WINDOW_LIVE_P (window
) && !EQ (window
, FRAME_ROOT_WINDOW (f
)))
5862 delete_deletable_window (window
);
5865 /* Fselect_window will have made f the selected frame, so we
5866 reselect the proper frame here. Fhandle_switch_frame will change the
5867 selected window too, but that doesn't make the call to
5868 Fselect_window above totally superfluous; it still sets f's
5870 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5871 do_switch_frame (data
->selected_frame
, 0, 0, Qnil
);
5873 run_window_configuration_change_hook (f
);
5876 if (!NILP (new_current_buffer
))
5878 Fset_buffer (new_current_buffer
);
5879 /* If the new current buffer doesn't appear in the selected
5880 window, go to its old point (see bug#12208). */
5881 if (!EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5882 Fgoto_char (make_number (old_point
));
5885 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5886 minibuf_selected_window
= data
->minibuf_selected_window
;
5888 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5892 /* Recursively delete all child windows reachable via the next, vchild,
5893 and hchild slots of WINDOW. */
5895 delete_all_child_windows (Lisp_Object window
)
5897 register struct window
*w
;
5899 w
= XWINDOW (window
);
5901 if (!NILP (w
->next
))
5902 /* Delete WINDOW's siblings (we traverse postorderly). */
5903 delete_all_child_windows (w
->next
);
5905 /* See Fset_window_configuration for excuse. */
5906 wset_total_lines (w
, w
->buffer
);
5908 if (!NILP (w
->vchild
))
5910 delete_all_child_windows (w
->vchild
);
5911 wset_vchild (w
, Qnil
);
5913 else if (!NILP (w
->hchild
))
5915 delete_all_child_windows (w
->hchild
);
5916 wset_hchild (w
, Qnil
);
5918 else if (!NILP (w
->buffer
))
5921 unchain_marker (XMARKER (w
->pointm
));
5922 unchain_marker (XMARKER (w
->start
));
5923 wset_buffer (w
, Qnil
);
5926 Vwindow_list
= Qnil
;
5930 count_windows (register struct window
*window
)
5932 register int count
= 1;
5933 if (!NILP (window
->next
))
5934 count
+= count_windows (XWINDOW (window
->next
));
5935 if (!NILP (window
->vchild
))
5936 count
+= count_windows (XWINDOW (window
->vchild
));
5937 if (!NILP (window
->hchild
))
5938 count
+= count_windows (XWINDOW (window
->hchild
));
5943 /* Fill vector FLAT with leaf windows under W, starting at index I.
5944 Value is last index + 1. */
5946 get_leaf_windows (struct window
*w
, struct window
**flat
, int i
)
5950 if (!NILP (w
->hchild
))
5951 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5952 else if (!NILP (w
->vchild
))
5953 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5957 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5964 /* Return a pointer to the glyph W's physical cursor is on. Value is
5965 null if W's current matrix is invalid, so that no meaningful glyph
5968 get_phys_cursor_glyph (struct window
*w
)
5970 struct glyph_row
*row
;
5971 struct glyph
*glyph
;
5972 int hpos
= w
->phys_cursor
.hpos
;
5974 if (!(w
->phys_cursor
.vpos
>= 0
5975 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
))
5978 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5979 if (!row
->enabled_p
)
5984 /* When the window is hscrolled, cursor hpos can legitimately be
5985 out of bounds, but we draw the cursor at the corresponding
5986 window margin in that case. */
5987 if (!row
->reversed_p
&& hpos
< 0)
5989 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
5990 hpos
= row
->used
[TEXT_AREA
] - 1;
5993 if (row
->used
[TEXT_AREA
] > hpos
5995 glyph
= row
->glyphs
[TEXT_AREA
] + hpos
;
6004 save_window_save (Lisp_Object window
, struct Lisp_Vector
*vector
, int i
)
6006 register struct saved_window
*p
;
6007 register struct window
*w
;
6008 register Lisp_Object tem
, pers
, par
;
6010 for (;!NILP (window
); window
= w
->next
)
6012 p
= SAVED_WINDOW_N (vector
, i
);
6013 w
= XWINDOW (window
);
6015 wset_temslot (w
, make_number (i
)); i
++;
6017 p
->buffer
= w
->buffer
;
6018 p
->left_col
= w
->left_col
;
6019 p
->top_line
= w
->top_line
;
6020 p
->total_cols
= w
->total_cols
;
6021 p
->total_lines
= w
->total_lines
;
6022 p
->normal_cols
= w
->normal_cols
;
6023 p
->normal_lines
= w
->normal_lines
;
6024 XSETFASTINT (p
->hscroll
, w
->hscroll
);
6025 XSETFASTINT (p
->min_hscroll
, w
->min_hscroll
);
6026 p
->display_table
= w
->display_table
;
6027 p
->left_margin_cols
= w
->left_margin_cols
;
6028 p
->right_margin_cols
= w
->right_margin_cols
;
6029 p
->left_fringe_width
= w
->left_fringe_width
;
6030 p
->right_fringe_width
= w
->right_fringe_width
;
6031 p
->fringes_outside_margins
= w
->fringes_outside_margins
? Qt
: Qnil
;
6032 p
->scroll_bar_width
= w
->scroll_bar_width
;
6033 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6034 p
->dedicated
= w
->dedicated
;
6035 p
->combination_limit
= w
->combination_limit
;
6036 p
->window_parameters
= Qnil
;
6038 if (!NILP (Vwindow_persistent_parameters
))
6040 /* Run cycle detection on Vwindow_persistent_parameters. */
6041 Lisp_Object tortoise
, hare
;
6043 hare
= tortoise
= Vwindow_persistent_parameters
;
6044 while (CONSP (hare
))
6051 tortoise
= XCDR (tortoise
);
6053 if (EQ (hare
, tortoise
))
6054 /* Reset Vwindow_persistent_parameters to Qnil. */
6056 Vwindow_persistent_parameters
= Qnil
;
6061 for (tem
= Vwindow_persistent_parameters
; CONSP (tem
);
6065 /* Save values for persistent window parameters. */
6066 if (CONSP (pers
) && !NILP (XCDR (pers
)))
6068 par
= Fassq (XCAR (pers
), w
->window_parameters
);
6070 /* If the window has no value for the parameter,
6072 p
->window_parameters
= Fcons (Fcons (XCAR (pers
), Qnil
),
6073 p
->window_parameters
);
6075 /* If the window has a value for the parameter,
6077 p
->window_parameters
= Fcons (Fcons (XCAR (par
),
6079 p
->window_parameters
);
6084 if (!NILP (w
->buffer
))
6086 /* Save w's value of point in the window configuration. If w
6087 is the selected window, then get the value of point from
6088 the buffer; pointm is garbage in the selected window. */
6089 if (EQ (window
, selected_window
))
6090 p
->pointm
= build_marker (XBUFFER (w
->buffer
),
6091 BUF_PT (XBUFFER (w
->buffer
)),
6092 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6094 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6095 XMARKER (p
->pointm
)->insertion_type
6096 = !NILP (Vwindow_point_insertion_type
);
6098 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6099 p
->start_at_line_beg
= w
->start_at_line_beg
? Qt
: Qnil
;
6101 tem
= BVAR (XBUFFER (w
->buffer
), mark
);
6102 p
->mark
= Fcopy_marker (tem
, Qnil
);
6109 p
->start_at_line_beg
= Qnil
;
6112 if (NILP (w
->parent
))
6115 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6120 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6122 if (!NILP (w
->vchild
))
6123 i
= save_window_save (w
->vchild
, vector
, i
);
6124 if (!NILP (w
->hchild
))
6125 i
= save_window_save (w
->hchild
, vector
, i
);
6131 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6132 Scurrent_window_configuration
, 0, 1, 0,
6133 doc
: /* Return an object representing the current window configuration of FRAME.
6134 If FRAME is nil or omitted, use the selected frame.
6135 This describes the number of windows, their sizes and current buffers,
6136 and for each displayed buffer, where display starts, and the positions of
6137 point and mark. An exception is made for point in the current buffer:
6138 its value is -not- saved.
6139 This also records the currently selected frame, and FRAME's focus
6140 redirection (see `redirect-frame-focus'). The variable
6141 `window-persistent-parameters' specifies which window parameters are
6142 saved by this function. */)
6145 register Lisp_Object tem
;
6146 register int n_windows
;
6147 register struct save_window_data
*data
;
6149 struct frame
*f
= decode_live_frame (frame
);
6151 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6152 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6153 PVEC_WINDOW_CONFIGURATION
);
6155 data
->frame_cols
= FRAME_COLS (f
);
6156 data
->frame_lines
= FRAME_LINES (f
);
6157 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6158 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6159 data
->selected_frame
= selected_frame
;
6160 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6161 XSETBUFFER (data
->current_buffer
, current_buffer
);
6162 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6163 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6164 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6165 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6166 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6167 data
->saved_windows
= tem
;
6168 for (i
= 0; i
< n_windows
; i
++)
6170 Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
));
6171 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6172 XSETWINDOW_CONFIGURATION (tem
, data
);
6176 /***********************************************************************
6178 ***********************************************************************/
6180 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6182 doc
: /* Set width of marginal areas of window WINDOW.
6183 WINDOW must be a live window and defaults to the selected one.
6185 Second arg LEFT-WIDTH specifies the number of character cells to
6186 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6187 does the same for the right marginal area. A nil width parameter
6188 means no margin. */)
6189 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
)
6191 struct window
*w
= decode_live_window (window
);
6193 /* Translate negative or zero widths to nil.
6194 Margins that are too wide have to be checked elsewhere. */
6196 if (!NILP (left_width
))
6198 CHECK_NUMBER (left_width
);
6199 if (XINT (left_width
) <= 0)
6203 if (!NILP (right_width
))
6205 CHECK_NUMBER (right_width
);
6206 if (XINT (right_width
) <= 0)
6210 if (!EQ (w
->left_margin_cols
, left_width
)
6211 || !EQ (w
->right_margin_cols
, right_width
))
6213 wset_left_margin_cols (w
, left_width
);
6214 wset_right_margin_cols (w
, right_width
);
6216 adjust_window_margins (w
);
6218 ++windows_or_buffers_changed
;
6219 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6226 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6228 doc
: /* Get width of marginal areas of window WINDOW.
6229 WINDOW must be a live window and defaults to the selected one.
6231 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6232 If a marginal area does not exist, its width will be returned
6234 (Lisp_Object window
)
6236 struct window
*w
= decode_live_window (window
);
6237 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6242 /***********************************************************************
6244 ***********************************************************************/
6246 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6248 doc
: /* Set the fringe widths of window WINDOW.
6249 WINDOW must be a live window and defaults to the selected one.
6251 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6252 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6253 fringe width. If a fringe width arg is nil, that means to use the
6254 frame's default fringe width. Default fringe widths can be set with
6255 the command `set-fringe-style'.
6256 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6257 outside of the display margins. By default, fringes are drawn between
6258 display marginal areas and the text area. */)
6259 (Lisp_Object window
, Lisp_Object left_width
, Lisp_Object right_width
, Lisp_Object outside_margins
)
6261 struct window
*w
= decode_live_window (window
);
6262 int outside
= !NILP (outside_margins
);
6264 if (!NILP (left_width
))
6265 CHECK_NATNUM (left_width
);
6266 if (!NILP (right_width
))
6267 CHECK_NATNUM (right_width
);
6269 /* Do nothing on a tty. */
6270 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6271 && (!EQ (w
->left_fringe_width
, left_width
)
6272 || !EQ (w
->right_fringe_width
, right_width
)
6273 || w
->fringes_outside_margins
!= outside
))
6275 wset_left_fringe_width (w
, left_width
);
6276 wset_right_fringe_width (w
, right_width
);
6277 w
->fringes_outside_margins
= outside
;
6279 adjust_window_margins (w
);
6281 clear_glyph_matrix (w
->current_matrix
);
6282 wset_window_end_valid (w
, Qnil
);
6284 ++windows_or_buffers_changed
;
6285 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6292 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6294 doc
: /* Get width of fringes of window WINDOW.
6295 WINDOW must be a live window and defaults to the selected one.
6297 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6298 (Lisp_Object window
)
6300 struct window
*w
= decode_live_window (window
);
6302 return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6303 make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6304 WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ? Qt
: Qnil
);
6309 /***********************************************************************
6311 ***********************************************************************/
6313 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
,
6314 Sset_window_scroll_bars
, 2, 4, 0,
6315 doc
: /* Set width and type of scroll bars of window WINDOW.
6316 WINDOW must be a live window and defaults to the selected one.
6318 Second parameter WIDTH specifies the pixel width for the scroll bar;
6319 this is automatically adjusted to a multiple of the frame column width.
6320 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6321 bar: left, right, or nil.
6322 If WIDTH is nil, use the frame's scroll-bar width.
6323 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6324 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6325 (Lisp_Object window
, Lisp_Object width
, Lisp_Object vertical_type
, Lisp_Object horizontal_type
)
6327 struct window
*w
= decode_live_window (window
);
6331 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
6333 if (XINT (width
) == 0)
6334 vertical_type
= Qnil
;
6337 if (!(NILP (vertical_type
)
6338 || EQ (vertical_type
, Qleft
)
6339 || EQ (vertical_type
, Qright
)
6340 || EQ (vertical_type
, Qt
)))
6341 error ("Invalid type of vertical scroll bar");
6343 if (!EQ (w
->scroll_bar_width
, width
)
6344 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6346 wset_scroll_bar_width (w
, width
);
6347 wset_vertical_scroll_bar_type (w
, vertical_type
);
6349 adjust_window_margins (w
);
6351 clear_glyph_matrix (w
->current_matrix
);
6352 wset_window_end_valid (w
, Qnil
);
6354 ++windows_or_buffers_changed
;
6355 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6362 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6364 doc
: /* Get width and type of scroll bars of window WINDOW.
6365 WINDOW must be a live window and defaults to the selected one.
6367 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6368 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6370 (Lisp_Object window
)
6372 struct window
*w
= decode_live_window (window
);
6374 return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6375 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6376 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6377 make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6378 w
->vertical_scroll_bar_type
, Qnil
);
6383 /***********************************************************************
6385 ***********************************************************************/
6387 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6388 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6389 If WINDOW is omitted or nil, it defaults to the selected window.
6390 Normally, value is a multiple of the canonical character height of WINDOW;
6391 optional second arg PIXELS-P means value is measured in pixels. */)
6392 (Lisp_Object window
, Lisp_Object pixels_p
)
6395 struct window
*w
= decode_live_window (window
);
6396 struct frame
*f
= XFRAME (w
->frame
);
6398 if (FRAME_WINDOW_P (f
))
6399 result
= (NILP (pixels_p
)
6400 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6401 : make_number (-w
->vscroll
));
6403 result
= make_number (0);
6408 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6410 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6411 WINDOW nil means use the selected window. Normally, VSCROLL is a
6412 non-negative multiple of the canonical character height of WINDOW;
6413 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6414 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6415 corresponds to an integral number of pixels. The return value is the
6416 result of this rounding.
6417 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6418 (Lisp_Object window
, Lisp_Object vscroll
, Lisp_Object pixels_p
)
6420 struct window
*w
= decode_live_window (window
);
6421 struct frame
*f
= XFRAME (w
->frame
);
6423 CHECK_NUMBER_OR_FLOAT (vscroll
);
6425 if (FRAME_WINDOW_P (f
))
6427 int old_dy
= w
->vscroll
;
6429 w
->vscroll
= - (NILP (pixels_p
)
6430 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6431 : XFLOATINT (vscroll
));
6432 w
->vscroll
= min (w
->vscroll
, 0);
6434 if (w
->vscroll
!= old_dy
)
6436 /* Adjust glyph matrix of the frame if the virtual display
6437 area becomes larger than before. */
6438 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6441 /* Prevent redisplay shortcuts. */
6442 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6446 return Fwindow_vscroll (window
, pixels_p
);
6450 /* Call FN for all leaf windows on frame F. FN is called with the
6451 first argument being a pointer to the leaf window, and with
6452 additional argument USER_DATA. Stops when FN returns 0. */
6455 foreach_window (struct frame
*f
, int (*fn
) (struct window
*, void *),
6458 /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6459 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6460 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6464 /* Helper function for foreach_window. Call FN for all leaf windows
6465 reachable from W. FN is called with the first argument being a
6466 pointer to the leaf window, and with additional argument USER_DATA.
6467 Stop when FN returns 0. Value is 0 if stopped by FN. */
6470 foreach_window_1 (struct window
*w
, int (*fn
) (struct window
*, void *), void *user_data
)
6474 for (cont
= 1; w
&& cont
;)
6476 if (!NILP (w
->hchild
))
6477 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6478 else if (!NILP (w
->vchild
))
6479 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6481 cont
= fn (w
, user_data
);
6483 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6490 /* Freeze or unfreeze the window start of W unless it is a
6491 mini-window or the selected window. FREEZE_P non-null means freeze
6492 the window start. */
6495 freeze_window_start (struct window
*w
, void *freeze_p
)
6497 if (MINI_WINDOW_P (w
)
6498 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
6499 && (w
== XWINDOW (selected_window
)
6500 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6501 && ! NILP (Vminibuf_scroll_window
)
6502 && w
== XWINDOW (Vminibuf_scroll_window
)))))
6505 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6510 /* Freeze or unfreeze the window starts of all leaf windows on frame
6511 F, except the selected window and a mini-window. FREEZE_P non-zero
6512 means freeze the window start. */
6515 freeze_window_starts (struct frame
*f
, int freeze_p
)
6517 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6521 /***********************************************************************
6523 ***********************************************************************/
6525 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
6526 describe the same state of affairs. This is used by Fequal.
6528 IGNORE_POSITIONS means ignore non-matching scroll positions
6531 This ignores a couple of things like the dedication status of
6532 window, combination_limit and the like. This might have to be
6536 compare_window_configurations (Lisp_Object configuration1
,
6537 Lisp_Object configuration2
,
6538 bool ignore_positions
)
6540 register struct save_window_data
*d1
, *d2
;
6541 struct Lisp_Vector
*sws1
, *sws2
;
6544 CHECK_WINDOW_CONFIGURATION (configuration1
);
6545 CHECK_WINDOW_CONFIGURATION (configuration2
);
6547 d1
= (struct save_window_data
*) XVECTOR (configuration1
);
6548 d2
= (struct save_window_data
*) XVECTOR (configuration2
);
6549 sws1
= XVECTOR (d1
->saved_windows
);
6550 sws2
= XVECTOR (d2
->saved_windows
);
6552 /* Frame settings must match. */
6553 if (d1
->frame_cols
!= d2
->frame_cols
6554 || d1
->frame_lines
!= d2
->frame_lines
6555 || d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
6556 || !EQ (d1
->selected_frame
, d2
->selected_frame
)
6557 || !EQ (d1
->current_buffer
, d2
->current_buffer
)
6558 || (!ignore_positions
6559 && (!EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
)
6560 || !EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
)))
6561 || !EQ (d1
->focus_frame
, d2
->focus_frame
)
6562 /* Verify that the two configurations have the same number of windows. */
6563 || sws1
->header
.size
!= sws2
->header
.size
)
6566 for (i
= 0; i
< sws1
->header
.size
; i
++)
6568 struct saved_window
*sw1
, *sw2
;
6570 sw1
= SAVED_WINDOW_N (sws1
, i
);
6571 sw2
= SAVED_WINDOW_N (sws2
, i
);
6574 /* The "current" windows in the two configurations must
6575 correspond to each other. */
6576 EQ (d1
->current_window
, sw1
->window
)
6577 != EQ (d2
->current_window
, sw2
->window
)
6578 /* Windows' buffers must match. */
6579 || !EQ (sw1
->buffer
, sw2
->buffer
)
6580 || !EQ (sw1
->left_col
, sw2
->left_col
)
6581 || !EQ (sw1
->top_line
, sw2
->top_line
)
6582 || !EQ (sw1
->total_cols
, sw2
->total_cols
)
6583 || !EQ (sw1
->total_lines
, sw2
->total_lines
)
6584 || !EQ (sw1
->display_table
, sw2
->display_table
)
6585 /* The next two disjuncts check the window structure for
6587 || !EQ (sw1
->parent
, sw2
->parent
)
6588 || !EQ (sw1
->prev
, sw2
->prev
)
6589 || (!ignore_positions
6590 && (!EQ (sw1
->hscroll
, sw2
->hscroll
)
6591 || !EQ (sw1
->min_hscroll
, sw2
->min_hscroll
)
6592 || !EQ (sw1
->start_at_line_beg
, sw2
->start_at_line_beg
)
6593 || NILP (Fequal (sw1
->start
, sw2
->start
))
6594 || NILP (Fequal (sw1
->pointm
, sw2
->pointm
))
6595 || NILP (Fequal (sw1
->mark
, sw2
->mark
))))
6596 || !EQ (sw1
->left_margin_cols
, sw2
->left_margin_cols
)
6597 || !EQ (sw1
->right_margin_cols
, sw2
->right_margin_cols
)
6598 || !EQ (sw1
->left_fringe_width
, sw2
->left_fringe_width
)
6599 || !EQ (sw1
->right_fringe_width
, sw2
->right_fringe_width
)
6600 || !EQ (sw1
->fringes_outside_margins
, sw2
->fringes_outside_margins
)
6601 || !EQ (sw1
->scroll_bar_width
, sw2
->scroll_bar_width
)
6602 || !EQ (sw1
->vertical_scroll_bar_type
, sw2
->vertical_scroll_bar_type
))
6609 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6610 Scompare_window_configurations
, 2, 2, 0,
6611 doc
: /* Compare two window configurations as regards the structure of windows.
6612 This function ignores details such as the values of point and mark
6613 and scrolling positions. */)
6614 (Lisp_Object x
, Lisp_Object y
)
6616 if (compare_window_configurations (x
, y
, 1))
6622 init_window_once (void)
6624 struct frame
*f
= make_initial_frame ();
6625 XSETFRAME (selected_frame
, f
);
6626 Vterminal_frame
= selected_frame
;
6627 minibuf_window
= f
->minibuffer_window
;
6628 selected_window
= f
->selected_window
;
6629 last_nonminibuf_frame
= f
;
6631 window_initialized
= 1;
6637 Vwindow_list
= Qnil
;
6641 syms_of_window (void)
6643 DEFSYM (Qscroll_up
, "scroll-up");
6644 DEFSYM (Qscroll_down
, "scroll-down");
6645 DEFSYM (Qscroll_command
, "scroll-command");
6647 Fput (Qscroll_up
, Qscroll_command
, Qt
);
6648 Fput (Qscroll_down
, Qscroll_command
, Qt
);
6650 DEFSYM (Qwindow_configuration_change_hook
, "window-configuration-change-hook");
6651 DEFSYM (Qwindowp
, "windowp");
6652 DEFSYM (Qwindow_configuration_p
, "window-configuration-p");
6653 DEFSYM (Qwindow_live_p
, "window-live-p");
6654 DEFSYM (Qwindow_valid_p
, "window-valid-p");
6655 DEFSYM (Qwindow_deletable_p
, "window-deletable-p");
6656 DEFSYM (Qdelete_window
, "delete-window");
6657 DEFSYM (Qwindow_resize_root_window
, "window--resize-root-window");
6658 DEFSYM (Qwindow_resize_root_window_vertically
, "window--resize-root-window-vertically");
6659 DEFSYM (Qsafe
, "safe");
6660 DEFSYM (Qdisplay_buffer
, "display-buffer");
6661 DEFSYM (Qreplace_buffer_in_windows
, "replace-buffer-in-windows");
6662 DEFSYM (Qrecord_window_buffer
, "record-window-buffer");
6663 DEFSYM (Qget_mru_window
, "get-mru-window");
6664 DEFSYM (Qwindow_size
, "window-size");
6665 DEFSYM (Qtemp_buffer_show_hook
, "temp-buffer-show-hook");
6666 DEFSYM (Qabove
, "above");
6667 DEFSYM (Qbelow
, "below");
6668 DEFSYM (Qclone_of
, "clone-of");
6670 staticpro (&Vwindow_list
);
6672 minibuf_selected_window
= Qnil
;
6673 staticpro (&minibuf_selected_window
);
6675 window_scroll_pixel_based_preserve_x
= -1;
6676 window_scroll_pixel_based_preserve_y
= -1;
6677 window_scroll_preserve_hpos
= -1;
6678 window_scroll_preserve_vpos
= -1;
6680 DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function
,
6681 doc
: /* Non-nil means call as function to display a help buffer.
6682 The function is called with one argument, the buffer to be displayed.
6683 Used by `with-output-to-temp-buffer'.
6684 If this function is used, then it must do the entire job of showing
6685 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6686 Vtemp_buffer_show_function
= Qnil
;
6688 DEFVAR_LISP ("minibuffer-scroll-window", Vminibuf_scroll_window
,
6689 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6690 Vminibuf_scroll_window
= Qnil
;
6692 DEFVAR_BOOL ("mode-line-in-non-selected-windows", mode_line_in_non_selected_windows
,
6693 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6694 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6695 is displayed in the `mode-line' face. */);
6696 mode_line_in_non_selected_windows
= 1;
6698 DEFVAR_LISP ("other-window-scroll-buffer", Vother_window_scroll_buffer
,
6699 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6700 Vother_window_scroll_buffer
= Qnil
;
6702 DEFVAR_BOOL ("auto-window-vscroll", auto_window_vscroll_p
,
6703 doc
: /* Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6704 auto_window_vscroll_p
= 1;
6706 DEFVAR_INT ("next-screen-context-lines", next_screen_context_lines
,
6707 doc
: /* Number of lines of continuity when scrolling by screenfuls. */);
6708 next_screen_context_lines
= 2;
6710 DEFVAR_LISP ("scroll-preserve-screen-position",
6711 Vscroll_preserve_screen_position
,
6712 doc
: /* Controls if scroll commands move point to keep its screen position unchanged.
6713 A value of nil means point does not keep its screen position except
6714 at the scroll margin or window boundary respectively.
6715 A value of t means point keeps its screen position if the scroll
6716 command moved it vertically out of the window, e.g. when scrolling
6718 Any other value means point always keeps its screen position.
6719 Scroll commands should have the `scroll-command' property
6720 on their symbols to be controlled by this variable. */);
6721 Vscroll_preserve_screen_position
= Qnil
;
6723 DEFVAR_LISP ("window-point-insertion-type", Vwindow_point_insertion_type
,
6724 doc
: /* Type of marker to use for `window-point'. */);
6725 Vwindow_point_insertion_type
= Qnil
;
6727 DEFVAR_LISP ("window-configuration-change-hook",
6728 Vwindow_configuration_change_hook
,
6729 doc
: /* Functions to call when window configuration changes.
6730 The buffer-local part is run once per window, with the relevant window
6731 selected; while the global part is run only once for the modified frame,
6732 with the relevant frame selected. */);
6733 Vwindow_configuration_change_hook
= Qnil
;
6735 DEFVAR_LISP ("recenter-redisplay", Vrecenter_redisplay
,
6736 doc
: /* Non-nil means `recenter' redraws entire frame.
6737 If this option is non-nil, then the `recenter' command with a nil
6738 argument will redraw the entire frame; the special value `tty' causes
6739 the frame to be redrawn only if it is a tty frame. */);
6740 Vrecenter_redisplay
= Qtty
;
6742 DEFVAR_LISP ("window-combination-resize", Vwindow_combination_resize
,
6743 doc
: /* If t, resize window combinations proportionally.
6744 If this variable is nil, splitting a window gets the entire screen space
6745 for displaying the new window from the window to split. Deleting and
6746 resizing a window preferably resizes one adjacent window only.
6748 If this variable is t, splitting a window tries to get the space
6749 proportionally from all windows in the same combination. This also
6750 allows to split a window that is otherwise too small or of fixed size.
6751 Resizing and deleting a window proportionally resize all windows in the
6754 Other values are reserved for future use.
6756 This variable takes no effect if `window-combination-limit' is non-nil. */);
6757 Vwindow_combination_resize
= Qnil
;
6759 DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit
,
6760 doc
: /* If non-nil, splitting a window makes a new parent window.
6761 The following values are recognized:
6763 nil means splitting a window will create a new parent window only if the
6764 window has no parent window or the window shall become part of a
6765 combination orthogonal to the one it is part of.
6767 `window-size' means that splitting a window for displaying a buffer
6768 makes a new parent window provided `display-buffer' is supposed to
6769 explicitly set the window's size due to the presence of a
6770 `window-height' or `window-width' entry in the alist used by
6771 `display-buffer'. Otherwise, this value is handled like nil.
6773 `temp-buffer' means that splitting a window for displaying a temporary
6774 buffer always makes a new parent window. Otherwise, this value is
6777 `display-buffer' means that splitting a window for displaying a buffer
6778 always makes a new parent window. Since temporary buffers are
6779 displayed by the function `display-buffer', this value is stronger
6780 than `temp-buffer'. Splitting a window for other purpose makes a
6781 new parent window only if needed.
6783 t means that splitting a window always creates a new parent window. If
6784 all splits behave this way, each frame's window tree is a binary
6785 tree and every window but the frame's root window has exactly one
6788 Other values are reserved for future use. */);
6789 Vwindow_combination_limit
= Qwindow_size
;
6791 DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters
,
6792 doc
: /* Alist of persistent window parameters.
6793 This alist specifies which window parameters shall get saved by
6794 `current-window-configuration' and `window-state-get' and subsequently
6795 restored to their previous values by `set-window-configuration' and
6798 The car of each entry of this alist is the symbol specifying the
6799 parameter. The cdr is one of the following:
6801 nil means the parameter is neither saved by `window-state-get' nor by
6802 `current-window-configuration'.
6804 t means the parameter is saved by `current-window-configuration' and,
6805 provided its WRITABLE argument is nil, by `window-state-get'.
6807 The symbol `writable' means the parameter is saved unconditionally by
6808 both `current-window-configuration' and `window-state-get'. Do not use
6809 this value for parameters without read syntax (like windows or frames).
6811 Parameters not saved by `current-window-configuration' or
6812 `window-state-get' are left alone by `set-window-configuration'
6813 respectively are not installed by `window-state-put'. */);
6814 Vwindow_persistent_parameters
= list1 (Fcons (Qclone_of
, Qt
));
6816 defsubr (&Sselected_window
);
6817 defsubr (&Sminibuffer_window
);
6818 defsubr (&Swindow_minibuffer_p
);
6819 defsubr (&Swindowp
);
6820 defsubr (&Swindow_valid_p
);
6821 defsubr (&Swindow_live_p
);
6822 defsubr (&Swindow_frame
);
6823 defsubr (&Sframe_root_window
);
6824 defsubr (&Sframe_first_window
);
6825 defsubr (&Sframe_selected_window
);
6826 defsubr (&Sset_frame_selected_window
);
6827 defsubr (&Spos_visible_in_window_p
);
6828 defsubr (&Swindow_line_height
);
6829 defsubr (&Swindow_buffer
);
6830 defsubr (&Swindow_parent
);
6831 defsubr (&Swindow_top_child
);
6832 defsubr (&Swindow_left_child
);
6833 defsubr (&Swindow_next_sibling
);
6834 defsubr (&Swindow_prev_sibling
);
6835 defsubr (&Swindow_combination_limit
);
6836 defsubr (&Sset_window_combination_limit
);
6837 defsubr (&Swindow_use_time
);
6838 defsubr (&Swindow_top_line
);
6839 defsubr (&Swindow_left_column
);
6840 defsubr (&Swindow_total_height
);
6841 defsubr (&Swindow_total_width
);
6842 defsubr (&Swindow_normal_size
);
6843 defsubr (&Swindow_new_total
);
6844 defsubr (&Swindow_new_normal
);
6845 defsubr (&Sset_window_new_total
);
6846 defsubr (&Sset_window_new_normal
);
6847 defsubr (&Swindow_resize_apply
);
6848 defsubr (&Swindow_body_height
);
6849 defsubr (&Swindow_body_width
);
6850 defsubr (&Swindow_hscroll
);
6851 defsubr (&Sset_window_hscroll
);
6852 defsubr (&Swindow_redisplay_end_trigger
);
6853 defsubr (&Sset_window_redisplay_end_trigger
);
6854 defsubr (&Swindow_edges
);
6855 defsubr (&Swindow_pixel_edges
);
6856 defsubr (&Swindow_absolute_pixel_edges
);
6857 defsubr (&Swindow_inside_edges
);
6858 defsubr (&Swindow_inside_pixel_edges
);
6859 defsubr (&Swindow_inside_absolute_pixel_edges
);
6860 defsubr (&Scoordinates_in_window_p
);
6861 defsubr (&Swindow_at
);
6862 defsubr (&Swindow_point
);
6863 defsubr (&Swindow_start
);
6864 defsubr (&Swindow_end
);
6865 defsubr (&Sset_window_point
);
6866 defsubr (&Sset_window_start
);
6867 defsubr (&Swindow_dedicated_p
);
6868 defsubr (&Sset_window_dedicated_p
);
6869 defsubr (&Swindow_display_table
);
6870 defsubr (&Sset_window_display_table
);
6871 defsubr (&Snext_window
);
6872 defsubr (&Sprevious_window
);
6873 defsubr (&Sget_buffer_window
);
6874 defsubr (&Sdelete_other_windows_internal
);
6875 defsubr (&Sdelete_window_internal
);
6876 defsubr (&Sresize_mini_window_internal
);
6877 defsubr (&Sset_window_buffer
);
6878 defsubr (&Srun_window_configuration_change_hook
);
6879 defsubr (&Sselect_window
);
6880 defsubr (&Sforce_window_update
);
6881 defsubr (&Ssplit_window_internal
);
6882 defsubr (&Sscroll_up
);
6883 defsubr (&Sscroll_down
);
6884 defsubr (&Sscroll_left
);
6885 defsubr (&Sscroll_right
);
6886 defsubr (&Sother_window_for_scrolling
);
6887 defsubr (&Sscroll_other_window
);
6888 defsubr (&Sminibuffer_selected_window
);
6889 defsubr (&Srecenter
);
6890 defsubr (&Swindow_text_height
);
6891 defsubr (&Smove_to_window_line
);
6892 defsubr (&Swindow_configuration_p
);
6893 defsubr (&Swindow_configuration_frame
);
6894 defsubr (&Sset_window_configuration
);
6895 defsubr (&Scurrent_window_configuration
);
6896 defsubr (&Sset_window_margins
);
6897 defsubr (&Swindow_margins
);
6898 defsubr (&Sset_window_fringes
);
6899 defsubr (&Swindow_fringes
);
6900 defsubr (&Sset_window_scroll_bars
);
6901 defsubr (&Swindow_scroll_bars
);
6902 defsubr (&Swindow_vscroll
);
6903 defsubr (&Sset_window_vscroll
);
6904 defsubr (&Scompare_window_configurations
);
6905 defsubr (&Swindow_list
);
6906 defsubr (&Swindow_list_1
);
6907 defsubr (&Swindow_prev_buffers
);
6908 defsubr (&Sset_window_prev_buffers
);
6909 defsubr (&Swindow_next_buffers
);
6910 defsubr (&Sset_window_next_buffers
);
6911 defsubr (&Swindow_parameters
);
6912 defsubr (&Swindow_parameter
);
6913 defsubr (&Sset_window_parameter
);
6917 keys_of_window (void)
6919 initial_define_key (control_x_map
, '<', "scroll-left");
6920 initial_define_key (control_x_map
, '>', "scroll-right");
6922 initial_define_key (global_map
, Ctl ('V'), "scroll-up-command");
6923 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6924 initial_define_key (meta_map
, 'v', "scroll-down-command");