1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006 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 2, or (at your option)
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; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
52 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
53 Lisp_Object Qscroll_up
, Qscroll_down
;
54 Lisp_Object Qwindow_size_fixed
;
55 extern Lisp_Object Qleft_margin
, Qright_margin
;
57 static int displayed_window_lines
P_ ((struct window
*));
58 static struct window
*decode_window
P_ ((Lisp_Object
));
59 static int count_windows
P_ ((struct window
*));
60 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
61 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
62 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
63 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
64 static int window_min_size_1
P_ ((struct window
*, int));
65 static int window_min_size
P_ ((struct window
*, int, int, int *));
66 static void size_window
P_ ((Lisp_Object
, int, int, int));
67 static int freeze_window_start
P_ ((struct window
*, void *));
68 static int window_fixed_size_p
P_ ((struct window
*, int, int));
69 static void enlarge_window
P_ ((Lisp_Object
, int, int));
70 static Lisp_Object window_list
P_ ((void));
71 static int add_window_to_list
P_ ((struct window
*, void *));
72 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
74 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
76 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
78 static int foreach_window_1
P_ ((struct window
*,
79 int (* fn
) (struct window
*, void *),
81 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
83 /* This is the window in which the terminal's cursor should
84 be left when nothing is being done with it. This must
85 always be a leaf window, and its buffer is selected by
86 the top level editing loop at the end of each command.
88 This value is always the same as
89 FRAME_SELECTED_WINDOW (selected_frame). */
91 Lisp_Object selected_window
;
93 /* A list of all windows for use by next_window and Fwindow_list.
94 Functions creating or deleting windows should invalidate this cache
95 by setting it to nil. */
97 Lisp_Object Vwindow_list
;
99 /* The mini-buffer window of the selected frame.
100 Note that you cannot test for mini-bufferness of an arbitrary window
101 by comparing against this; but you can test for mini-bufferness of
102 the selected window. */
104 Lisp_Object minibuf_window
;
106 /* Non-nil means it is the window whose mode line should be
107 shown as the selected window when the minibuffer is selected. */
109 Lisp_Object minibuf_selected_window
;
111 /* Non-nil means it is the window for C-M-v to scroll
112 when the mini-buffer is selected. */
114 Lisp_Object Vminibuf_scroll_window
;
116 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
118 Lisp_Object Vother_window_scroll_buffer
;
120 /* Non-nil means it's function to call to display temp buffers. */
122 Lisp_Object Vtemp_buffer_show_function
;
124 /* Non-zero means line and page scrolling on tall lines (with images)
125 does partial scrolling by modifying window-vscroll. */
127 int auto_window_vscroll_p
;
129 /* Non-zero means to use mode-line-inactive face in all windows but the
130 selected-window and the minibuffer-scroll-window when the
131 minibuffer is active. */
132 int mode_line_in_non_selected_windows
;
134 /* If a window gets smaller than either of these, it is removed. */
136 EMACS_INT window_min_height
;
137 EMACS_INT window_min_width
;
139 /* Nonzero implies Fdisplay_buffer should create windows. */
143 /* Nonzero implies make new frames for Fdisplay_buffer. */
147 /* Nonzero means reuse existing frames for displaying buffers. */
149 int display_buffer_reuse_frames
;
151 /* Non-nil means use this function instead of default */
153 Lisp_Object Vpop_up_frame_function
;
155 /* Function to call to handle Fdisplay_buffer. */
157 Lisp_Object Vdisplay_buffer_function
;
159 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
161 Lisp_Object Veven_window_heights
;
163 /* List of buffer *names* for buffers that should have their own frames. */
165 Lisp_Object Vspecial_display_buffer_names
;
167 /* List of regexps for buffer names that should have their own frames. */
169 Lisp_Object Vspecial_display_regexps
;
171 /* Function to pop up a special frame. */
173 Lisp_Object Vspecial_display_function
;
175 /* List of buffer *names* for buffers to appear in selected window. */
177 Lisp_Object Vsame_window_buffer_names
;
179 /* List of regexps for buffer names to appear in selected window. */
181 Lisp_Object Vsame_window_regexps
;
183 /* Hook run at end of temp_output_buffer_show. */
185 Lisp_Object Qtemp_buffer_show_hook
;
187 /* Fdisplay_buffer always splits the largest window
188 if that window is more than this high. */
190 EMACS_INT split_height_threshold
;
192 /* Number of lines of continuity in scrolling by screenfuls. */
194 EMACS_INT next_screen_context_lines
;
196 /* Incremented for each window created. */
198 static int sequence_number
;
200 /* Nonzero after init_window_once has finished. */
202 static int window_initialized
;
204 /* Hook to run when window config changes. */
206 Lisp_Object Qwindow_configuration_change_hook
;
207 Lisp_Object Vwindow_configuration_change_hook
;
209 /* Non-nil means scroll commands try to put point
210 at the same screen height as previously. */
212 Lisp_Object Vscroll_preserve_screen_position
;
214 /* Incremented by 1 whenever a window is deleted. */
216 int window_deletion_count
;
218 /* Used by the function window_scroll_pixel_based */
220 static int window_scroll_pixel_based_preserve_y
;
222 #if 0 /* This isn't used anywhere. */
223 /* Nonzero means we can split a frame even if it is "unsplittable". */
224 static int inhibit_frame_unsplittable
;
227 extern EMACS_INT scroll_margin
;
229 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
231 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
232 doc
: /* Returns t if OBJECT is a window. */)
236 return WINDOWP (object
) ? Qt
: Qnil
;
239 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
240 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
244 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
251 register struct window
*p
;
253 p
= allocate_window ();
255 XSETFASTINT (p
->sequence_number
, sequence_number
);
256 XSETFASTINT (p
->left_col
, 0);
257 XSETFASTINT (p
->top_line
, 0);
258 XSETFASTINT (p
->total_lines
, 0);
259 XSETFASTINT (p
->total_cols
, 0);
260 XSETFASTINT (p
->hscroll
, 0);
261 XSETFASTINT (p
->min_hscroll
, 0);
262 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
263 p
->start
= Fmake_marker ();
264 p
->pointm
= Fmake_marker ();
265 XSETFASTINT (p
->use_time
, 0);
267 p
->display_table
= Qnil
;
269 p
->pseudo_window_p
= 0;
270 bzero (&p
->cursor
, sizeof (p
->cursor
));
271 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
272 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
273 p
->desired_matrix
= p
->current_matrix
= 0;
274 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
275 p
->phys_cursor_type
= -1;
276 p
->phys_cursor_width
= -1;
277 p
->must_be_updated_p
= 0;
278 XSETFASTINT (p
->window_end_vpos
, 0);
279 XSETFASTINT (p
->window_end_pos
, 0);
280 p
->window_end_valid
= Qnil
;
283 XSETFASTINT (p
->last_point
, 0);
284 p
->frozen_window_start_p
= 0;
285 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
286 p
->left_margin_cols
= Qnil
;
287 p
->right_margin_cols
= Qnil
;
288 p
->left_fringe_width
= Qnil
;
289 p
->right_fringe_width
= Qnil
;
290 p
->fringes_outside_margins
= Qnil
;
291 p
->scroll_bar_width
= Qnil
;
292 p
->vertical_scroll_bar_type
= Qt
;
298 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
299 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
302 return selected_window
;
305 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
306 doc
: /* Return the window used now for minibuffers.
307 If the optional argument FRAME is specified, return the minibuffer window
308 used by that frame. */)
313 frame
= selected_frame
;
314 CHECK_LIVE_FRAME (frame
);
315 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
318 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
319 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
320 WINDOW defaults to the selected window. */)
324 struct window
*w
= decode_window (window
);
325 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
329 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
330 Spos_visible_in_window_p
, 0, 3, 0,
331 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
332 Return nil if that position is scrolled vertically out of view.
333 If a character is only partially visible, nil is returned, unless the
334 optional argument PARTIALLY is non-nil.
335 If POS is only out of view because of horizontal scrolling, return non-nil.
336 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
338 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
339 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
340 relative to the top left corner of the window. PARTIAL is nil if the character
341 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
342 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
343 (pos
, window
, partially
)
344 Lisp_Object pos
, window
, partially
;
346 register struct window
*w
;
348 register struct buffer
*buf
;
350 Lisp_Object in_window
= Qnil
;
351 int rtop
, rbot
, fully_p
= 1;
354 w
= decode_window (window
);
355 buf
= XBUFFER (w
->buffer
);
356 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
360 CHECK_NUMBER_COERCE_MARKER (pos
);
363 else if (w
== XWINDOW (selected_window
))
366 posint
= XMARKER (w
->pointm
)->charpos
;
368 /* If position is above window start or outside buffer boundaries,
369 or if window start is out of range, position is not visible. */
370 if (posint
>= CHARPOS (top
)
371 && posint
<= BUF_ZV (buf
)
372 && CHARPOS (top
) >= BUF_BEGV (buf
)
373 && CHARPOS (top
) <= BUF_ZV (buf
)
374 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
375 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
378 if (!NILP (in_window
) && !NILP (partially
))
379 in_window
= Fcons (make_number (x
),
380 Fcons (make_number (y
),
381 Fcons ((fully_p
? Qnil
382 : Fcons (make_number (rtop
),
383 make_number (rbot
))),
389 static struct window
*
390 decode_window (window
)
391 register Lisp_Object window
;
394 return XWINDOW (selected_window
);
396 CHECK_LIVE_WINDOW (window
);
397 return XWINDOW (window
);
400 static struct window
*
401 decode_any_window (window
)
402 register Lisp_Object window
;
405 return XWINDOW (selected_window
);
407 CHECK_WINDOW (window
);
408 return XWINDOW (window
);
411 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
412 doc
: /* Return the buffer that WINDOW is displaying.
413 WINDOW defaults to the selected window. */)
417 return decode_window (window
)->buffer
;
420 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
421 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
425 return decode_any_window (window
)->total_lines
;
428 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
429 doc
: /* Return the number of display columns in WINDOW.
430 This is the width that is usable columns available for text in WINDOW.
431 If you want to find out how many columns WINDOW takes up,
432 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
436 return make_number (window_box_text_cols (decode_any_window (window
)));
439 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
440 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
444 return decode_window (window
)->hscroll
;
447 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
448 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
449 Return NCOL. NCOL should be zero or positive.
451 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
452 window so that the location of point becomes invisible. */)
454 Lisp_Object window
, ncol
;
456 struct window
*w
= decode_window (window
);
460 hscroll
= max (0, XINT (ncol
));
462 /* Prevent redisplay shortcuts when changing the hscroll. */
463 if (XINT (w
->hscroll
) != hscroll
)
464 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
466 w
->hscroll
= make_number (hscroll
);
470 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
471 Swindow_redisplay_end_trigger
, 0, 1, 0,
472 doc
: /* Return WINDOW's redisplay end trigger value.
473 See `set-window-redisplay-end-trigger' for more information. */)
477 return decode_window (window
)->redisplay_end_trigger
;
480 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
481 Sset_window_redisplay_end_trigger
, 2, 2, 0,
482 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
483 VALUE should be a buffer position (typically a marker) or nil.
484 If it is a buffer position, then if redisplay in WINDOW reaches a position
485 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
486 with two arguments: WINDOW, and the end trigger value.
487 Afterwards the end-trigger value is reset to nil. */)
489 register Lisp_Object window
, value
;
491 register struct window
*w
;
493 w
= decode_window (window
);
494 w
->redisplay_end_trigger
= value
;
498 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
499 doc
: /* Return a list of the edge coordinates of WINDOW.
500 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
501 RIGHT is one more than the rightmost column occupied by WINDOW,
502 and BOTTOM is one more than the bottommost row occupied by WINDOW.
503 The edges include the space used by the window's scroll bar,
504 display margins, fringes, header line, and mode line, if it has them.
505 To get the edges of the actual text area, use `window-inside-edges'. */)
509 register struct window
*w
= decode_any_window (window
);
511 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
512 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
513 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
514 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
518 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
519 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
520 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
521 RIGHT is one more than the rightmost x position occupied by WINDOW,
522 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
523 The pixel edges include the space used by the window's scroll bar,
524 display margins, fringes, header line, and mode line, if it has them.
525 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
529 register struct window
*w
= decode_any_window (window
);
531 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
532 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
533 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
534 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
538 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
539 doc
: /* Return a list of the edge coordinates of WINDOW.
540 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
541 RIGHT is one more than the rightmost column used by text in WINDOW,
542 and BOTTOM is one more than the bottommost row used by text in WINDOW.
543 The inside edges do not include the space used by the window's scroll bar,
544 display margins, fringes, header line, and/or mode line. */)
548 register struct window
*w
= decode_any_window (window
);
550 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
551 + WINDOW_LEFT_MARGIN_COLS (w
)
552 + WINDOW_LEFT_FRINGE_COLS (w
)),
553 make_number (WINDOW_TOP_EDGE_LINE (w
)
554 + WINDOW_HEADER_LINE_LINES (w
)),
555 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
556 - WINDOW_RIGHT_MARGIN_COLS (w
)
557 - WINDOW_RIGHT_FRINGE_COLS (w
)),
558 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
559 - WINDOW_MODE_LINE_LINES (w
)));
562 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
563 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
564 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
565 RIGHT is one more than the rightmost x position used by text in WINDOW,
566 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
567 The inside edges do not include the space used by the window's scroll bar,
568 display margins, fringes, header line, and/or mode line. */)
572 register struct window
*w
= decode_any_window (window
);
574 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
575 + WINDOW_LEFT_MARGIN_WIDTH (w
)
576 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
577 make_number (WINDOW_TOP_EDGE_Y (w
)
578 + WINDOW_HEADER_LINE_HEIGHT (w
)),
579 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
580 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
581 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
582 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
583 - WINDOW_MODE_LINE_HEIGHT (w
)));
586 /* Test if the character at column *X, row *Y is within window W.
587 If it is not, return ON_NOTHING;
588 if it is in the window's text area,
589 set *x and *y to its location relative to the upper left corner
592 if it is on the window's modeline, return ON_MODE_LINE;
593 if it is on the border between the window and its right sibling,
594 return ON_VERTICAL_BORDER.
595 if it is on a scroll bar,
596 return ON_SCROLL_BAR.
597 if it is on the window's top line, return ON_HEADER_LINE;
598 if it is in left or right fringe of the window,
599 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
600 to window-relative coordinates;
601 if it is in the marginal area to the left/right of the window,
602 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
603 to window-relative coordinates.
605 X and Y are frame relative pixel coordinates. */
607 static enum window_part
608 coordinates_in_window (w
, x
, y
)
609 register struct window
*w
;
612 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
613 int left_x
, right_x
, top_y
, bottom_y
;
614 enum window_part part
;
615 int ux
= FRAME_COLUMN_WIDTH (f
);
616 int x0
= WINDOW_LEFT_EDGE_X (w
);
617 int x1
= WINDOW_RIGHT_EDGE_X (w
);
618 /* The width of the area where the vertical line can be dragged.
619 (Between mode lines for instance. */
620 int grabbable_width
= ux
;
621 int lmargin_width
, rmargin_width
, text_left
, text_right
;
623 /* In what's below, we subtract 1 when computing right_x because we
624 want the rightmost pixel, which is given by left_pixel+width-1. */
625 if (w
->pseudo_window_p
)
628 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
629 top_y
= WINDOW_TOP_EDGE_Y (w
);
630 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
634 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
635 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
636 top_y
= WINDOW_TOP_EDGE_Y (w
);
637 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
640 /* Outside any interesting row? */
641 if (*y
< top_y
|| *y
>= bottom_y
)
644 /* On the mode line or header line? If it's near the start of
645 the mode or header line of window that's has a horizontal
646 sibling, say it's on the vertical line. That's to be able
647 to resize windows horizontally in case we're using toolkit
650 if (WINDOW_WANTS_MODELINE_P (w
)
651 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
655 header_vertical_border_check
:
656 /* We're somewhere on the mode line. We consider the place
657 between mode lines of horizontally adjacent mode lines
658 as the vertical border. If scroll bars on the left,
659 return the right window. */
660 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
661 || WINDOW_RIGHTMOST_P (w
))
663 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
664 return ON_VERTICAL_BORDER
;
668 if (abs (*x
- x1
) < grabbable_width
)
669 return ON_VERTICAL_BORDER
;
672 if (*x
< x0
|| *x
>= x1
)
675 /* Convert X and Y to window relative coordinates.
676 Mode line starts at left edge of window. */
682 if (WINDOW_WANTS_HEADER_LINE_P (w
)
683 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
685 part
= ON_HEADER_LINE
;
686 goto header_vertical_border_check
;
689 if (*x
< x0
|| *x
>= x1
)
692 /* Outside any interesting column? */
693 if (*x
< left_x
|| *x
> right_x
)
696 return ON_SCROLL_BAR
;
699 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
700 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
702 text_left
= window_box_left (w
, TEXT_AREA
);
703 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
705 if (FRAME_WINDOW_P (f
))
707 if (!w
->pseudo_window_p
708 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
709 && !WINDOW_RIGHTMOST_P (w
)
710 && (abs (*x
- right_x
) < grabbable_width
))
711 return ON_VERTICAL_BORDER
;
715 /* Need to say "*x > right_x" rather than >=, since on character
716 terminals, the vertical line's x coordinate is right_x. */
717 if (!w
->pseudo_window_p
718 && !WINDOW_RIGHTMOST_P (w
)
719 && *x
> right_x
- ux
)
721 /* On the border on the right side of the window? Assume that
722 this area begins at RIGHT_X minus a canonical char width. */
723 return ON_VERTICAL_BORDER
;
729 if (lmargin_width
> 0
730 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
731 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
732 : (*x
< left_x
+ lmargin_width
)))
735 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
736 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
738 return ON_LEFT_MARGIN
;
741 /* Convert X and Y to window-relative pixel coordinates. */
744 return ON_LEFT_FRINGE
;
747 if (*x
>= text_right
)
749 if (rmargin_width
> 0
750 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
751 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
752 : (*x
>= right_x
- rmargin_width
)))
754 *x
-= right_x
- rmargin_width
;
755 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
756 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
758 return ON_RIGHT_MARGIN
;
761 /* Convert X and Y to window-relative pixel coordinates. */
762 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
764 return ON_RIGHT_FRINGE
;
767 /* Everything special ruled out - must be on text area */
774 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
775 Scoordinates_in_window_p
, 2, 2, 0,
776 doc
: /* Return non-nil if COORDINATES are in WINDOW.
777 COORDINATES is a cons of the form (X . Y), X and Y being distances
778 measured in characters from the upper-left corner of the frame.
779 \(0 . 0) denotes the character in the upper left corner of the
781 If COORDINATES are in the text portion of WINDOW,
782 the coordinates relative to the window are returned.
783 If they are in the mode line of WINDOW, `mode-line' is returned.
784 If they are in the top mode line of WINDOW, `header-line' is returned.
785 If they are in the left fringe of WINDOW, `left-fringe' is returned.
786 If they are in the right fringe of WINDOW, `right-fringe' is returned.
787 If they are on the border between WINDOW and its right sibling,
788 `vertical-line' is returned.
789 If they are in the windows's left or right marginal areas, `left-margin'\n\
790 or `right-margin' is returned. */)
791 (coordinates
, window
)
792 register Lisp_Object coordinates
, window
;
799 CHECK_WINDOW (window
);
800 w
= XWINDOW (window
);
801 f
= XFRAME (w
->frame
);
802 CHECK_CONS (coordinates
);
803 lx
= Fcar (coordinates
);
804 ly
= Fcdr (coordinates
);
805 CHECK_NUMBER_OR_FLOAT (lx
);
806 CHECK_NUMBER_OR_FLOAT (ly
);
807 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
808 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
810 switch (coordinates_in_window (w
, &x
, &y
))
816 /* X and Y are now window relative pixel coordinates. Convert
817 them to canonical char units before returning them. */
818 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
819 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
824 case ON_VERTICAL_BORDER
:
825 return Qvertical_line
;
833 case ON_RIGHT_FRINGE
:
834 return Qright_fringe
;
839 case ON_RIGHT_MARGIN
:
840 return Qright_margin
;
843 /* Historically we are supposed to return nil in this case. */
852 /* Callback for foreach_window, used in window_from_coordinates.
853 Check if window W contains coordinates specified by USER_DATA which
854 is actually a pointer to a struct check_window_data CW.
856 Check if window W contains coordinates *CW->x and *CW->y. If it
857 does, return W in *CW->window, as Lisp_Object, and return in
858 *CW->part the part of the window under coordinates *X,*Y. Return
859 zero from this function to stop iterating over windows. */
861 struct check_window_data
865 enum window_part
*part
;
869 check_window_containing (w
, user_data
)
873 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
874 enum window_part found
;
877 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
878 if (found
!= ON_NOTHING
)
881 XSETWINDOW (*cw
->window
, w
);
889 /* Find the window containing frame-relative pixel position X/Y and
890 return it as a Lisp_Object.
892 If X, Y is on one of the window's special `window_part' elements,
893 set *PART to the id of that element, and return X and Y converted
894 to window relative coordinates in WX and WY.
896 If there is no window under X, Y return nil and leave *PART
897 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
899 This function was previously implemented with a loop cycling over
900 windows with Fnext_window, and starting with the frame's selected
901 window. It turned out that this doesn't work with an
902 implementation of next_window using Vwindow_list, because
903 FRAME_SELECTED_WINDOW (F) is not always contained in the window
904 tree of F when this function is called asynchronously from
905 note_mouse_highlight. The original loop didn't terminate in this
909 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
912 enum window_part
*part
;
917 struct check_window_data cw
;
918 enum window_part dummy
;
924 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
925 foreach_window (f
, check_window_containing
, &cw
);
927 /* If not found above, see if it's in the tool bar window, if a tool
931 && WINDOWP (f
->tool_bar_window
)
932 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
933 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
937 window
= f
->tool_bar_window
;
946 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
947 doc
: /* Return window containing coordinates X and Y on FRAME.
948 If omitted, FRAME defaults to the currently selected frame.
949 The top left corner of the frame is considered to be row 0,
952 Lisp_Object x
, y
, frame
;
957 frame
= selected_frame
;
958 CHECK_LIVE_FRAME (frame
);
961 /* Check that arguments are integers or floats. */
962 CHECK_NUMBER_OR_FLOAT (x
);
963 CHECK_NUMBER_OR_FLOAT (y
);
965 return window_from_coordinates (f
,
966 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
967 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
968 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
969 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
973 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
974 doc
: /* Return current value of point in WINDOW.
975 For a nonselected window, this is the value point would have
976 if that window were selected.
978 Note that, when WINDOW is the selected window and its buffer
979 is also currently selected, the value returned is the same as (point).
980 It would be more strictly correct to return the `top-level' value
981 of point, outside of any save-excursion forms.
982 But that is hard to define. */)
986 register struct window
*w
= decode_window (window
);
988 if (w
== XWINDOW (selected_window
)
989 && current_buffer
== XBUFFER (w
->buffer
))
991 return Fmarker_position (w
->pointm
);
994 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
995 doc
: /* Return position at which display currently starts in WINDOW.
996 This is updated by redisplay or by calling `set-window-start'. */)
1000 return Fmarker_position (decode_window (window
)->start
);
1003 /* This is text temporarily removed from the doc string below.
1005 This function returns nil if the position is not currently known.
1006 That happens when redisplay is preempted and doesn't finish.
1007 If in that case you want to compute where the end of the window would
1008 have been if redisplay had finished, do this:
1010 (goto-char (window-start window))
1011 (vertical-motion (1- (window-height window)) window)
1014 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1015 doc
: /* Return position at which display currently ends in WINDOW.
1016 This is updated by redisplay, when it runs to completion.
1017 Simply changing the buffer text or setting `window-start'
1018 does not update this value.
1019 Return nil if there is no recorded value. \(This can happen if the
1020 last redisplay of WINDOW was preempted, and did not finish.)
1021 If UPDATE is non-nil, compute the up-to-date position
1022 if it isn't already recorded. */)
1024 Lisp_Object window
, update
;
1027 struct window
*w
= decode_window (window
);
1033 #if 0 /* This change broke some things. We should make it later. */
1034 /* If we don't know the end position, return nil.
1035 The user can compute it with vertical-motion if he wants to.
1036 It would be nicer to do it automatically,
1037 but that's so slow that it would probably bother people. */
1038 if (NILP (w
->window_end_valid
))
1043 && ! (! NILP (w
->window_end_valid
)
1044 && XFASTINT (w
->last_modified
) >= MODIFF
)
1047 struct text_pos startp
;
1049 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1051 /* In case W->start is out of the range, use something
1052 reasonable. This situation occurred when loading a file with
1053 `-l' containing a call to `rmail' with subsequent other
1054 commands. At the end, W->start happened to be BEG, while
1055 rmail had already narrowed the buffer. */
1056 if (XMARKER (w
->start
)->charpos
< BEGV
)
1057 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1058 else if (XMARKER (w
->start
)->charpos
> ZV
)
1059 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1061 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1063 /* Cannot use Fvertical_motion because that function doesn't
1064 cope with variable-height lines. */
1065 if (b
!= current_buffer
)
1067 old_buffer
= current_buffer
;
1068 set_buffer_internal (b
);
1071 start_display (&it
, w
, startp
);
1072 move_it_vertically (&it
, window_box_height (w
));
1073 if (it
.current_y
< it
.last_visible_y
)
1074 move_it_past_eol (&it
);
1075 value
= make_number (IT_CHARPOS (it
));
1078 set_buffer_internal (old_buffer
);
1081 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1086 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1087 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1090 Lisp_Object window
, pos
;
1092 register struct window
*w
= decode_window (window
);
1094 CHECK_NUMBER_COERCE_MARKER (pos
);
1095 if (w
== XWINDOW (selected_window
)
1096 && XBUFFER (w
->buffer
) == current_buffer
)
1099 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1101 /* We have to make sure that redisplay updates the window to show
1102 the new value of point. */
1103 if (!EQ (window
, selected_window
))
1104 ++windows_or_buffers_changed
;
1109 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1110 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1112 Optional third arg NOFORCE non-nil inhibits next redisplay
1113 from overriding motion of point in order to display at this exact start. */)
1114 (window
, pos
, noforce
)
1115 Lisp_Object window
, pos
, noforce
;
1117 register struct window
*w
= decode_window (window
);
1119 CHECK_NUMBER_COERCE_MARKER (pos
);
1120 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1121 /* this is not right, but much easier than doing what is right. */
1122 w
->start_at_line_beg
= Qnil
;
1124 w
->force_start
= Qt
;
1125 w
->update_mode_line
= Qt
;
1126 XSETFASTINT (w
->last_modified
, 0);
1127 XSETFASTINT (w
->last_overlay_modified
, 0);
1128 if (!EQ (window
, selected_window
))
1129 windows_or_buffers_changed
++;
1134 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1136 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1137 See also `set-window-dedicated-p'. */)
1141 return decode_window (window
)->dedicated
;
1144 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1145 Sset_window_dedicated_p
, 2, 2, 0,
1146 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1147 If it is dedicated, Emacs will not automatically change
1148 which buffer appears in it.
1149 The second argument is the new value for the dedication flag;
1150 non-nil means yes. */)
1152 Lisp_Object window
, arg
;
1154 register struct window
*w
= decode_window (window
);
1158 return w
->dedicated
;
1161 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1163 doc
: /* Return the display-table that WINDOW is using. */)
1167 return decode_window (window
)->display_table
;
1170 /* Get the display table for use on window W. This is either W's
1171 display table or W's buffer's display table. Ignore the specified
1172 tables if they are not valid; if no valid table is specified,
1175 struct Lisp_Char_Table
*
1176 window_display_table (w
)
1179 struct Lisp_Char_Table
*dp
= NULL
;
1181 if (DISP_TABLE_P (w
->display_table
))
1182 dp
= XCHAR_TABLE (w
->display_table
);
1183 else if (BUFFERP (w
->buffer
))
1185 struct buffer
*b
= XBUFFER (w
->buffer
);
1187 if (DISP_TABLE_P (b
->display_table
))
1188 dp
= XCHAR_TABLE (b
->display_table
);
1189 else if (DISP_TABLE_P (Vstandard_display_table
))
1190 dp
= XCHAR_TABLE (Vstandard_display_table
);
1196 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1197 doc
: /* Set WINDOW's display-table to TABLE. */)
1199 register Lisp_Object window
, table
;
1201 register struct window
*w
;
1203 w
= decode_window (window
);
1204 w
->display_table
= table
;
1208 /* Record info on buffer window w is displaying
1209 when it is about to cease to display that buffer. */
1212 register struct window
*w
;
1219 if (b
!= XMARKER (w
->pointm
)->buffer
)
1223 if (w
== XWINDOW (selected_window
)
1224 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1225 /* Do this except when the selected window's buffer
1226 is being removed from some other window. */
1228 /* last_window_start records the start position that this buffer
1229 had in the last window to be disconnected from it.
1230 Now that this statement is unconditional,
1231 it is possible for the buffer to be displayed in the
1232 selected window, while last_window_start reflects another
1233 window which was recently showing the same buffer.
1234 Some people might say that might be a good thing. Let's see. */
1235 b
->last_window_start
= marker_position (w
->start
);
1237 /* Point in the selected window's buffer
1238 is actually stored in that buffer, and the window's pointm isn't used.
1239 So don't clobber point in that buffer. */
1240 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1241 /* This line helps to fix Horsley's testbug.el bug. */
1242 && !(WINDOWP (b
->last_selected_window
)
1243 && w
!= XWINDOW (b
->last_selected_window
)
1244 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1245 temp_set_point_both (b
,
1246 clip_to_bounds (BUF_BEGV (b
),
1247 XMARKER (w
->pointm
)->charpos
,
1249 clip_to_bounds (BUF_BEGV_BYTE (b
),
1250 marker_byte_position (w
->pointm
),
1253 if (WINDOWP (b
->last_selected_window
)
1254 && w
== XWINDOW (b
->last_selected_window
))
1255 b
->last_selected_window
= Qnil
;
1258 /* Put replacement into the window structure in place of old. */
1260 replace_window (old
, replacement
)
1261 Lisp_Object old
, replacement
;
1263 register Lisp_Object tem
;
1264 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1266 /* If OLD is its frame's root_window, then replacement is the new
1267 root_window for that frame. */
1269 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1270 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1272 p
->left_col
= o
->left_col
;
1273 p
->top_line
= o
->top_line
;
1274 p
->total_cols
= o
->total_cols
;
1275 p
->total_lines
= o
->total_lines
;
1276 p
->desired_matrix
= p
->current_matrix
= 0;
1278 bzero (&p
->cursor
, sizeof (p
->cursor
));
1279 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1280 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1281 p
->phys_cursor_type
= -1;
1282 p
->phys_cursor_width
= -1;
1283 p
->must_be_updated_p
= 0;
1284 p
->pseudo_window_p
= 0;
1285 XSETFASTINT (p
->window_end_vpos
, 0);
1286 XSETFASTINT (p
->window_end_pos
, 0);
1287 p
->window_end_valid
= Qnil
;
1288 p
->frozen_window_start_p
= 0;
1289 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1291 p
->next
= tem
= o
->next
;
1293 XWINDOW (tem
)->prev
= replacement
;
1295 p
->prev
= tem
= o
->prev
;
1297 XWINDOW (tem
)->next
= replacement
;
1299 p
->parent
= tem
= o
->parent
;
1302 if (EQ (XWINDOW (tem
)->vchild
, old
))
1303 XWINDOW (tem
)->vchild
= replacement
;
1304 if (EQ (XWINDOW (tem
)->hchild
, old
))
1305 XWINDOW (tem
)->hchild
= replacement
;
1308 /*** Here, if replacement is a vertical combination
1309 and so is its new parent, we should make replacement's
1310 children be children of that parent instead. ***/
1313 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1314 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1316 register Lisp_Object window
;
1318 delete_window (window
);
1320 if (! NILP (Vwindow_configuration_change_hook
)
1321 && ! NILP (Vrun_hooks
))
1322 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1328 delete_window (window
)
1329 register Lisp_Object window
;
1331 register Lisp_Object tem
, parent
, sib
;
1332 register struct window
*p
;
1333 register struct window
*par
;
1336 /* Because this function is called by other C code on non-leaf
1337 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1338 so we can't decode_window here. */
1340 window
= selected_window
;
1342 CHECK_WINDOW (window
);
1343 p
= XWINDOW (window
);
1345 /* It's a no-op to delete an already-deleted window. */
1346 if (NILP (p
->buffer
)
1348 && NILP (p
->vchild
))
1353 error ("Attempt to delete minibuffer or sole ordinary window");
1354 par
= XWINDOW (parent
);
1356 windows_or_buffers_changed
++;
1357 Vwindow_list
= Qnil
;
1358 f
= XFRAME (WINDOW_FRAME (p
));
1359 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1361 /* Are we trying to delete any frame's selected window? */
1363 Lisp_Object swindow
, pwindow
;
1365 /* See if the frame's selected window is either WINDOW
1366 or any subwindow of it, by finding all that window's parents
1367 and comparing each one with WINDOW. */
1368 swindow
= FRAME_SELECTED_WINDOW (f
);
1373 while (!NILP (pwindow
))
1375 if (EQ (window
, pwindow
))
1377 pwindow
= XWINDOW (pwindow
)->parent
;
1380 /* If the window being deleted is not a parent of SWINDOW,
1381 then SWINDOW is ok as the new selected window. */
1382 if (!EQ (window
, pwindow
))
1384 /* Otherwise, try another window for SWINDOW. */
1385 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1387 /* If we get back to the frame's selected window,
1388 it means there was no acceptable alternative,
1389 so we cannot delete. */
1390 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1391 error ("Cannot delete window");
1394 /* If we need to change SWINDOW, do it. */
1395 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1397 /* If we're about to delete the selected window on the
1398 selected frame, then we should use Fselect_window to select
1399 the new window. On the other hand, if we're about to
1400 delete the selected window on any other frame, we shouldn't do
1401 anything but set the frame's selected_window slot. */
1402 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1403 Fselect_window (swindow
, Qnil
);
1405 FRAME_SELECTED_WINDOW (f
) = swindow
;
1409 /* Now we know we can delete this one. */
1410 window_deletion_count
++;
1413 /* tem is null for dummy parent windows
1414 (which have inferiors but not any contents themselves) */
1418 unchain_marker (XMARKER (p
->pointm
));
1419 unchain_marker (XMARKER (p
->start
));
1422 /* Free window glyph matrices. It is sure that they are allocated
1423 again when ADJUST_GLYPHS is called. Block input so that expose
1424 events and other events that access glyph matrices are not
1425 processed while we are changing them. */
1427 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1431 XWINDOW (tem
)->prev
= p
->prev
;
1435 XWINDOW (tem
)->next
= p
->next
;
1437 if (EQ (window
, par
->hchild
))
1438 par
->hchild
= p
->next
;
1439 if (EQ (window
, par
->vchild
))
1440 par
->vchild
= p
->next
;
1442 /* Find one of our siblings to give our space to. */
1446 /* If p gives its space to its next sibling, that sibling needs
1447 to have its top/left side pulled back to where p's is.
1448 set_window_{height,width} will re-position the sibling's
1451 XWINDOW (sib
)->top_line
= p
->top_line
;
1452 XWINDOW (sib
)->left_col
= p
->left_col
;
1455 /* Stretch that sibling. */
1456 if (!NILP (par
->vchild
))
1457 set_window_height (sib
,
1458 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1460 if (!NILP (par
->hchild
))
1461 set_window_width (sib
,
1462 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1465 /* If parent now has only one child,
1466 put the child into the parent's place. */
1470 if (NILP (XWINDOW (tem
)->next
)) {
1471 replace_window (parent
, tem
);
1472 par
= XWINDOW (tem
);
1475 /* Since we may be deleting combination windows, we must make sure that
1476 not only p but all its children have been marked as deleted. */
1477 if (! NILP (p
->hchild
))
1478 delete_all_subwindows (XWINDOW (p
->hchild
));
1479 else if (! NILP (p
->vchild
))
1480 delete_all_subwindows (XWINDOW (p
->vchild
));
1482 /* Mark this window as deleted. */
1483 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1485 if (! NILP (par
->parent
))
1486 par
= XWINDOW (par
->parent
);
1488 /* Check if we have a v/hchild with a v/hchild. In that case remove
1491 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1493 p
= XWINDOW (par
->vchild
);
1494 par
->vchild
= p
->vchild
;
1497 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1499 p
= XWINDOW (par
->hchild
);
1500 par
->hchild
= p
->hchild
;
1508 while (! NILP (tem
)) {
1509 XWINDOW (tem
)->parent
= p
->parent
;
1510 if (NILP (XWINDOW (tem
)->next
))
1512 tem
= XWINDOW (tem
)->next
;
1515 /* The next of the v/hchild we are removing is now the next of the
1516 last child for the v/hchild:
1517 Before v/hchild -> v/hchild -> next1 -> next2
1520 After: v/hchild -> next1 -> next2 -> next3
1522 XWINDOW (tem
)->next
= p
->next
;
1523 if (! NILP (p
->next
))
1524 XWINDOW (p
->next
)->prev
= tem
;
1526 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1530 /* Adjust glyph matrices. */
1537 /***********************************************************************
1539 ***********************************************************************/
1541 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1542 pointer. This is a callback function for foreach_window, used in
1543 function window_list. */
1546 add_window_to_list (w
, user_data
)
1550 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1552 XSETWINDOW (window
, w
);
1553 *list
= Fcons (window
, *list
);
1558 /* Return a list of all windows, for use by next_window. If
1559 Vwindow_list is a list, return that list. Otherwise, build a new
1560 list, cache it in Vwindow_list, and return that. */
1565 if (!CONSP (Vwindow_list
))
1569 Vwindow_list
= Qnil
;
1570 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1572 Lisp_Object args
[2];
1574 /* We are visiting windows in canonical order, and add
1575 new windows at the front of args[1], which means we
1576 have to reverse this list at the end. */
1578 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1579 args
[0] = Vwindow_list
;
1580 args
[1] = Fnreverse (args
[1]);
1581 Vwindow_list
= Fnconc (2, args
);
1585 return Vwindow_list
;
1589 /* Value is non-zero if WINDOW satisfies the constraints given by
1590 OWINDOW, MINIBUF and ALL_FRAMES.
1592 MINIBUF t means WINDOW may be minibuffer windows.
1593 `lambda' means WINDOW may not be a minibuffer window.
1594 a window means a specific minibuffer window
1596 ALL_FRAMES t means search all frames,
1597 nil means search just current frame,
1598 `visible' means search just visible frames,
1599 0 means search visible and iconified frames,
1600 a window means search the frame that window belongs to,
1601 a frame means consider windows on that frame, only. */
1604 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1605 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1607 struct window
*w
= XWINDOW (window
);
1608 struct frame
*f
= XFRAME (w
->frame
);
1609 int candidate_p
= 1;
1611 if (!BUFFERP (w
->buffer
))
1613 else if (MINI_WINDOW_P (w
)
1614 && (EQ (minibuf
, Qlambda
)
1615 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1617 /* If MINIBUF is `lambda' don't consider any mini-windows.
1618 If it is a window, consider only that one. */
1621 else if (EQ (all_frames
, Qt
))
1623 else if (NILP (all_frames
))
1625 xassert (WINDOWP (owindow
));
1626 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1628 else if (EQ (all_frames
, Qvisible
))
1630 FRAME_SAMPLE_VISIBILITY (f
);
1631 candidate_p
= FRAME_VISIBLE_P (f
);
1633 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1635 FRAME_SAMPLE_VISIBILITY (f
);
1636 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1638 else if (WINDOWP (all_frames
))
1639 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1640 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1641 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1642 else if (FRAMEP (all_frames
))
1643 candidate_p
= EQ (all_frames
, w
->frame
);
1649 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1650 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1654 decode_next_window_args (window
, minibuf
, all_frames
)
1655 Lisp_Object
*window
, *minibuf
, *all_frames
;
1658 *window
= selected_window
;
1660 CHECK_LIVE_WINDOW (*window
);
1662 /* MINIBUF nil may or may not include minibuffers. Decide if it
1664 if (NILP (*minibuf
))
1665 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1666 else if (!EQ (*minibuf
, Qt
))
1669 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1670 => count none of them, or a specific minibuffer window (the
1671 active one) to count. */
1673 /* ALL_FRAMES nil doesn't specify which frames to include. */
1674 if (NILP (*all_frames
))
1675 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1676 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1678 else if (EQ (*all_frames
, Qvisible
))
1680 else if (EQ (*all_frames
, make_number (0)))
1682 else if (FRAMEP (*all_frames
))
1684 else if (!EQ (*all_frames
, Qt
))
1687 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1688 search just current frame, `visible' meaning search just visible
1689 frames, 0 meaning search visible and iconified frames, or a
1690 window, meaning search the frame that window belongs to, or a
1691 frame, meaning consider windows on that frame, only. */
1695 /* Return the next or previous window of WINDOW in canonical ordering
1696 of windows. NEXT_P non-zero means return the next window. See the
1697 documentation string of next-window for the meaning of MINIBUF and
1701 next_window (window
, minibuf
, all_frames
, next_p
)
1702 Lisp_Object window
, minibuf
, all_frames
;
1705 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1707 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1708 return the first window on the frame. */
1709 if (FRAMEP (all_frames
)
1710 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1711 return Fframe_first_window (all_frames
);
1717 /* Find WINDOW in the list of all windows. */
1718 list
= Fmemq (window
, window_list ());
1720 /* Scan forward from WINDOW to the end of the window list. */
1722 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1723 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1726 /* Scan from the start of the window list up to WINDOW. */
1728 for (list
= Vwindow_list
;
1729 CONSP (list
) && !EQ (XCAR (list
), window
);
1731 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1735 window
= XCAR (list
);
1739 Lisp_Object candidate
, list
;
1741 /* Scan through the list of windows for candidates. If there are
1742 candidate windows in front of WINDOW, the last one of these
1743 is the one we want. If there are candidates following WINDOW
1744 in the list, again the last one of these is the one we want. */
1746 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1748 if (EQ (XCAR (list
), window
))
1750 if (WINDOWP (candidate
))
1753 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1755 candidate
= XCAR (list
);
1758 if (WINDOWP (candidate
))
1766 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1767 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1768 If omitted, WINDOW defaults to the selected window.
1770 Optional second arg MINIBUF t means count the minibuffer window even
1771 if not active. MINIBUF nil or omitted means count the minibuffer iff
1772 it is active. MINIBUF neither t nor nil means not to count the
1773 minibuffer even if it is active.
1775 Several frames may share a single minibuffer; if the minibuffer
1776 counts, all windows on all frames that share that minibuffer count
1777 too. Therefore, `next-window' can be used to iterate through the
1778 set of windows even when the minibuffer is on another frame. If the
1779 minibuffer does not count, only windows from WINDOW's frame count.
1781 Optional third arg ALL-FRAMES t means include windows on all frames.
1782 ALL-FRAMES nil or omitted means cycle within the frames as specified
1783 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1784 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1785 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1786 Anything else means restrict to WINDOW's frame.
1788 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1789 `next-window' to iterate through the entire cycle of acceptable
1790 windows, eventually ending up back at the window you started with.
1791 `previous-window' traverses the same cycle, in the reverse order. */)
1792 (window
, minibuf
, all_frames
)
1793 Lisp_Object window
, minibuf
, all_frames
;
1795 return next_window (window
, minibuf
, all_frames
, 1);
1799 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1800 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1801 If omitted, WINDOW defaults to the selected window.
1803 Optional second arg MINIBUF t means count the minibuffer window even
1804 if not active. MINIBUF nil or omitted means count the minibuffer iff
1805 it is active. MINIBUF neither t nor nil means not to count the
1806 minibuffer even if it is active.
1808 Several frames may share a single minibuffer; if the minibuffer
1809 counts, all windows on all frames that share that minibuffer count
1810 too. Therefore, `previous-window' can be used to iterate through
1811 the set of windows even when the minibuffer is on another frame. If
1812 the minibuffer does not count, only windows from WINDOW's frame count
1814 Optional third arg ALL-FRAMES t means include windows on all frames.
1815 ALL-FRAMES nil or omitted means cycle within the frames as specified
1816 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1817 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1818 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1819 Anything else means restrict to WINDOW's frame.
1821 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1822 `previous-window' to iterate through the entire cycle of acceptable
1823 windows, eventually ending up back at the window you started with.
1824 `next-window' traverses the same cycle, in the reverse order. */)
1825 (window
, minibuf
, all_frames
)
1826 Lisp_Object window
, minibuf
, all_frames
;
1828 return next_window (window
, minibuf
, all_frames
, 0);
1832 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1833 doc
: /* Select the ARG'th different window on this frame.
1834 All windows on current frame are arranged in a cyclic order.
1835 This command selects the window ARG steps away in that order.
1836 A negative ARG moves in the opposite order. The optional second
1837 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1839 Lisp_Object arg
, all_frames
;
1845 window
= selected_window
;
1847 for (i
= XINT (arg
); i
> 0; --i
)
1848 window
= Fnext_window (window
, Qnil
, all_frames
);
1850 window
= Fprevious_window (window
, Qnil
, all_frames
);
1852 Fselect_window (window
, Qnil
);
1857 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1858 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1859 FRAME nil or omitted means use the selected frame.
1860 WINDOW nil or omitted means use the selected window.
1861 MINIBUF t means include the minibuffer window, even if it isn't active.
1862 MINIBUF nil or omitted means include the minibuffer window only
1864 MINIBUF neither nil nor t means never include the minibuffer window. */)
1865 (frame
, minibuf
, window
)
1866 Lisp_Object frame
, minibuf
, window
;
1869 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
1870 CHECK_WINDOW (window
);
1872 frame
= selected_frame
;
1874 if (!EQ (frame
, XWINDOW (window
)->frame
))
1875 error ("Window is on a different frame");
1877 return window_list_1 (window
, minibuf
, frame
);
1881 /* Return a list of windows in canonical ordering. Arguments are like
1882 for `next-window'. */
1885 window_list_1 (window
, minibuf
, all_frames
)
1886 Lisp_Object window
, minibuf
, all_frames
;
1888 Lisp_Object tail
, list
, rest
;
1890 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1893 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1894 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1895 list
= Fcons (XCAR (tail
), list
);
1897 /* Rotate the list to start with WINDOW. */
1898 list
= Fnreverse (list
);
1899 rest
= Fmemq (window
, list
);
1900 if (!NILP (rest
) && !EQ (rest
, list
))
1902 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1904 XSETCDR (tail
, Qnil
);
1905 list
= nconc2 (rest
, list
);
1912 /* Look at all windows, performing an operation specified by TYPE
1914 If FRAMES is Qt, look at all frames;
1915 Qnil, look at just the selected frame;
1916 Qvisible, look at visible frames;
1917 a frame, just look at windows on that frame.
1918 If MINI is non-zero, perform the operation on minibuffer windows too. */
1923 GET_BUFFER_WINDOW
, /* Arg is buffer */
1924 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1925 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1926 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1928 UNSHOW_BUFFER
, /* Arg is buffer */
1929 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1934 window_loop (type
, obj
, mini
, frames
)
1935 enum window_loop type
;
1936 Lisp_Object obj
, frames
;
1939 Lisp_Object window
, windows
, best_window
, frame_arg
;
1941 struct gcpro gcpro1
;
1943 /* If we're only looping through windows on a particular frame,
1944 frame points to that frame. If we're looping through windows
1945 on all frames, frame is 0. */
1946 if (FRAMEP (frames
))
1947 f
= XFRAME (frames
);
1948 else if (NILP (frames
))
1949 f
= SELECTED_FRAME ();
1954 frame_arg
= Qlambda
;
1955 else if (EQ (frames
, make_number (0)))
1957 else if (EQ (frames
, Qvisible
))
1962 /* frame_arg is Qlambda to stick to one frame,
1963 Qvisible to consider all visible frames,
1966 /* Pick a window to start with. */
1970 window
= FRAME_SELECTED_WINDOW (f
);
1972 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1974 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1978 for (; CONSP (windows
); windows
= XCDR (windows
))
1982 window
= XCAR (windows
);
1983 w
= XWINDOW (window
);
1985 /* Note that we do not pay attention here to whether the frame
1986 is visible, since Fwindow_list skips non-visible frames if
1987 that is desired, under the control of frame_arg. */
1988 if (!MINI_WINDOW_P (w
)
1989 /* For UNSHOW_BUFFER, we must always consider all windows. */
1990 || type
== UNSHOW_BUFFER
1991 || (mini
&& minibuf_level
> 0))
1994 case GET_BUFFER_WINDOW
:
1995 if (EQ (w
->buffer
, obj
)
1996 /* Don't find any minibuffer window
1997 except the one that is currently in use. */
1998 && (MINI_WINDOW_P (w
)
1999 ? EQ (window
, minibuf_window
)
2002 if (NILP (best_window
))
2003 best_window
= window
;
2004 else if (EQ (window
, selected_window
))
2005 /* For compatibility with 20.x, prefer to return
2007 best_window
= window
;
2011 case GET_LRU_WINDOW
:
2012 /* `obj' is an integer encoding a bitvector.
2013 `obj & 1' means consider only full-width windows.
2014 `obj & 2' means consider also dedicated windows. */
2015 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2016 || (!(XINT (obj
) & 2) && EQ (w
->dedicated
, Qt
))
2017 /* Minibuffer windows are always ignored. */
2018 || MINI_WINDOW_P (w
))
2020 if (NILP (best_window
)
2021 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2022 > XFASTINT (w
->use_time
)))
2023 best_window
= window
;
2026 case DELETE_OTHER_WINDOWS
:
2027 if (!EQ (window
, obj
))
2028 Fdelete_window (window
);
2031 case DELETE_BUFFER_WINDOWS
:
2032 if (EQ (w
->buffer
, obj
))
2034 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2036 /* If this window is dedicated, and in a frame of its own,
2038 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2039 && !NILP (w
->dedicated
)
2040 && other_visible_frames (f
))
2042 /* Skip the other windows on this frame.
2043 There might be one, the minibuffer! */
2044 while (CONSP (XCDR (windows
))
2045 && EQ (XWINDOW (XCAR (windows
))->frame
,
2046 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2047 windows
= XCDR (windows
);
2049 /* Now we can safely delete the frame. */
2050 Fdelete_frame (w
->frame
, Qnil
);
2052 else if (NILP (w
->parent
))
2054 /* If we're deleting the buffer displayed in the
2055 only window on the frame, find a new buffer to
2058 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2059 Fset_window_buffer (window
, buffer
, Qnil
);
2060 if (EQ (window
, selected_window
))
2061 Fset_buffer (w
->buffer
);
2064 Fdelete_window (window
);
2068 case GET_LARGEST_WINDOW
:
2069 { /* nil `obj' means to ignore dedicated windows. */
2070 /* Ignore dedicated windows and minibuffers. */
2071 if (MINI_WINDOW_P (w
) || (NILP (obj
) && EQ (w
->dedicated
, Qt
)))
2074 if (NILP (best_window
))
2075 best_window
= window
;
2078 struct window
*b
= XWINDOW (best_window
);
2079 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2080 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2081 best_window
= window
;
2087 if (EQ (w
->buffer
, obj
))
2090 struct frame
*f
= XFRAME (w
->frame
);
2092 /* Find another buffer to show in this window. */
2093 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2095 /* If this window is dedicated, and in a frame of its own,
2097 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2098 && !NILP (w
->dedicated
)
2099 && other_visible_frames (f
))
2101 /* Skip the other windows on this frame.
2102 There might be one, the minibuffer! */
2103 while (CONSP (XCDR (windows
))
2104 && EQ (XWINDOW (XCAR (windows
))->frame
,
2105 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2106 windows
= XCDR (windows
);
2108 /* Now we can safely delete the frame. */
2109 Fdelete_frame (w
->frame
, Qnil
);
2111 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2114 XSETWINDOW (window
, w
);
2115 /* If this window is dedicated and not the only window
2116 in its frame, then kill it. */
2117 Fdelete_window (window
);
2121 /* Otherwise show a different buffer in the window. */
2122 w
->dedicated
= Qnil
;
2123 Fset_window_buffer (window
, buffer
, Qnil
);
2124 if (EQ (window
, selected_window
))
2125 Fset_buffer (w
->buffer
);
2130 case REDISPLAY_BUFFER_WINDOWS
:
2131 if (EQ (w
->buffer
, obj
))
2133 mark_window_display_accurate (window
, 0);
2134 w
->update_mode_line
= Qt
;
2135 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2136 ++update_mode_lines
;
2137 best_window
= window
;
2141 /* Check for a window that has a killed buffer. */
2142 case CHECK_ALL_WINDOWS
:
2143 if (! NILP (w
->buffer
)
2144 && NILP (XBUFFER (w
->buffer
)->name
))
2148 case WINDOW_LOOP_UNUSED
:
2157 /* Used for debugging. Abort if any window has a dead buffer. */
2160 check_all_windows ()
2162 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2165 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2166 doc
: /* Return the window least recently selected or used for display.
2167 Return a full-width window if possible.
2168 A minibuffer window is never a candidate.
2169 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2170 so if all windows are dedicated, the value is nil.
2171 If optional argument FRAME is `visible', search all visible frames.
2172 If FRAME is 0, search all visible and iconified frames.
2173 If FRAME is t, search all frames.
2174 If FRAME is nil, search only the selected frame.
2175 If FRAME is a frame, search only that frame. */)
2177 Lisp_Object frame
, dedicated
;
2179 register Lisp_Object w
;
2180 /* First try for a window that is full-width */
2181 w
= window_loop (GET_LRU_WINDOW
,
2182 NILP (dedicated
) ? make_number (1) : make_number (3),
2184 if (!NILP (w
) && !EQ (w
, selected_window
))
2186 /* If none of them, try the rest */
2187 return window_loop (GET_LRU_WINDOW
,
2188 NILP (dedicated
) ? make_number (0) : make_number (2),
2192 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2193 doc
: /* Return the largest window in area.
2194 A minibuffer window is never a candidate.
2195 A dedicated window is never a candidate unless DEDICATED is non-nil,
2196 so if all windows are dedicated, the value is nil.
2197 If optional argument FRAME is `visible', search all visible frames.
2198 If FRAME is 0, search all visible and iconified frames.
2199 If FRAME is t, search all frames.
2200 If FRAME is nil, search only the selected frame.
2201 If FRAME is a frame, search only that frame. */)
2203 Lisp_Object frame
, dedicated
;
2205 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2209 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2210 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2211 BUFFER can be a buffer or a buffer name.
2212 If optional argument FRAME is `visible', search all visible frames.
2213 If optional argument FRAME is 0, search all visible and iconified frames.
2214 If FRAME is t, search all frames.
2215 If FRAME is nil, search only the selected frame.
2216 If FRAME is a frame, search only that frame. */)
2218 Lisp_Object buffer
, frame
;
2220 buffer
= Fget_buffer (buffer
);
2221 if (BUFFERP (buffer
))
2222 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2227 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2229 doc
: /* Make WINDOW (or the selected window) fill its frame.
2230 Only the frame WINDOW is on is affected.
2231 This function tries to reduce display jumps
2232 by keeping the text previously visible in WINDOW
2233 in the same place on the frame. Doing this depends on
2234 the value of (window-start WINDOW), so if calling this function
2235 in a program gives strange scrolling, make sure the window-start
2236 value is reasonable when this function is called. */)
2245 window
= selected_window
;
2247 CHECK_LIVE_WINDOW (window
);
2248 w
= XWINDOW (window
);
2250 startpos
= marker_position (w
->start
);
2251 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2253 if (MINI_WINDOW_P (w
) && top
> 0)
2254 error ("Can't expand minibuffer to full frame");
2256 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2258 /* Try to minimize scrolling, by setting the window start to the point
2259 will cause the text at the old window start to be at the same place
2260 on the frame. But don't try to do this if the window start is
2261 outside the visible portion (as might happen when the display is
2262 not current, due to typeahead). */
2263 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2265 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2266 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2268 struct position pos
;
2269 struct buffer
*obuf
= current_buffer
;
2271 Fset_buffer (w
->buffer
);
2272 /* This computation used to temporarily move point, but that can
2273 have unwanted side effects due to text properties. */
2274 pos
= *vmotion (startpos
, -top
, w
);
2276 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2277 w
->window_end_valid
= Qnil
;
2278 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2279 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2281 /* We need to do this, so that the window-scroll-functions
2283 w
->optional_new_start
= Qt
;
2285 set_buffer_internal (obuf
);
2291 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2292 1, 2, "bDelete windows on (buffer): ",
2293 doc
: /* Delete all windows showing BUFFER.
2294 BUFFER must be a buffer or the name of an existing buffer.
2295 Optional second argument FRAME controls which frames are affected.
2296 If optional argument FRAME is `visible', search all visible frames.
2297 If FRAME is 0, search all visible and iconified frames.
2298 If FRAME is nil, search all frames.
2299 If FRAME is t, search only the selected frame.
2300 If FRAME is a frame, search only that frame. */)
2302 Lisp_Object buffer
, frame
;
2304 /* FRAME uses t and nil to mean the opposite of what window_loop
2308 else if (EQ (frame
, Qt
))
2313 buffer
= Fget_buffer (buffer
);
2314 CHECK_BUFFER (buffer
);
2315 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2321 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2322 Sreplace_buffer_in_windows
,
2323 1, 1, "bReplace buffer in windows: ",
2324 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2325 BUFFER may be a buffer or the name of an existing buffer. */)
2331 buffer
= Fget_buffer (buffer
);
2332 CHECK_BUFFER (buffer
);
2333 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2338 /* Replace BUFFER with some other buffer in all windows
2339 of all frames, even those on other keyboards. */
2342 replace_buffer_in_all_windows (buffer
)
2346 Lisp_Object tail
, frame
;
2348 /* A single call to window_loop won't do the job
2349 because it only considers frames on the current keyboard.
2350 So loop manually over frames, and handle each one. */
2351 FOR_EACH_FRAME (tail
, frame
)
2352 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2354 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2358 /* Set the height of WINDOW and all its inferiors. */
2360 /* The smallest acceptable dimensions for a window. Anything smaller
2361 might crash Emacs. */
2363 #define MIN_SAFE_WINDOW_WIDTH (2)
2364 #define MIN_SAFE_WINDOW_HEIGHT (1)
2366 /* Make sure that window_min_height and window_min_width are
2367 not too small; if they are, set them to safe minima. */
2370 check_min_window_sizes ()
2372 /* Smaller values might permit a crash. */
2373 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2374 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2375 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2376 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2379 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2380 minimum allowable size. */
2383 check_frame_size (frame
, rows
, cols
)
2387 /* For height, we have to see:
2388 how many windows the frame has at minimum (one or two),
2389 and whether it has a menu bar or other special stuff at the top. */
2391 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2392 ? MIN_SAFE_WINDOW_HEIGHT
2393 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2395 if (FRAME_TOP_MARGIN (frame
) > 0)
2396 min_height
+= FRAME_TOP_MARGIN (frame
);
2398 if (*rows
< min_height
)
2400 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2401 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2405 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2406 check if W's width can be changed, otherwise check W's height.
2407 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2408 siblings, too. If none of the siblings is resizable, WINDOW isn't
2412 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2414 int width_p
, check_siblings_p
;
2419 if (!NILP (w
->hchild
))
2421 c
= XWINDOW (w
->hchild
);
2425 /* A horiz. combination is fixed-width if all of if its
2427 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2428 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2429 fixed_p
= c
== NULL
;
2433 /* A horiz. combination is fixed-height if one of if its
2435 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2436 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2437 fixed_p
= c
!= NULL
;
2440 else if (!NILP (w
->vchild
))
2442 c
= XWINDOW (w
->vchild
);
2446 /* A vert. combination is fixed-width if one of if its
2448 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2449 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2450 fixed_p
= c
!= NULL
;
2454 /* A vert. combination is fixed-height if all of if its
2456 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2457 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2458 fixed_p
= c
== NULL
;
2461 else if (BUFFERP (w
->buffer
))
2463 struct buffer
*old
= current_buffer
;
2466 current_buffer
= XBUFFER (w
->buffer
);
2467 val
= find_symbol_value (Qwindow_size_fixed
);
2468 current_buffer
= old
;
2471 if (!EQ (val
, Qunbound
))
2473 fixed_p
= !NILP (val
);
2476 && ((EQ (val
, Qheight
) && width_p
)
2477 || (EQ (val
, Qwidth
) && !width_p
)))
2481 /* Can't tell if this one is resizable without looking at
2482 siblings. If all siblings are fixed-size this one is too. */
2483 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2487 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2488 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2492 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2493 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2507 /* Return the minimum size of window W, not taking fixed-width windows
2508 into account. WIDTH_P non-zero means return the minimum width,
2509 otherwise return the minimum height. If W is a combination window,
2510 compute the minimum size from the minimum sizes of W's children. */
2513 window_min_size_1 (w
, width_p
)
2520 if (!NILP (w
->hchild
))
2522 c
= XWINDOW (w
->hchild
);
2527 /* The min width of a horizontal combination is
2528 the sum of the min widths of its children. */
2531 size
+= window_min_size_1 (c
, width_p
);
2532 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2537 /* The min height a horizontal combination equals
2538 the maximum of all min height of its children. */
2541 int min_size
= window_min_size_1 (c
, width_p
);
2542 size
= max (min_size
, size
);
2543 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2547 else if (!NILP (w
->vchild
))
2549 c
= XWINDOW (w
->vchild
);
2554 /* The min width of a vertical combination is
2555 the maximum of the min widths of its children. */
2558 int min_size
= window_min_size_1 (c
, width_p
);
2559 size
= max (min_size
, size
);
2560 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2565 /* The min height of a vertical combination equals
2566 the sum of the min height of its children. */
2569 size
+= window_min_size_1 (c
, width_p
);
2570 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2577 size
= max (window_min_width
,
2578 (MIN_SAFE_WINDOW_WIDTH
2579 + WINDOW_FRINGE_COLS (w
)
2580 + WINDOW_SCROLL_BAR_COLS (w
)));
2583 if (MINI_WINDOW_P (w
)
2584 || (!WINDOW_WANTS_MODELINE_P (w
)
2585 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2588 size
= window_min_height
;
2596 /* Return the minimum size of window W, taking fixed-size windows into
2597 account. WIDTH_P non-zero means return the minimum width,
2598 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2599 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2600 unless FIXED is null. */
2603 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2605 int width_p
, ignore_fixed_p
, *fixed
;
2612 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2618 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2620 size
= window_min_size_1 (w
, width_p
);
2626 /* Adjust the margins of window W if text area is too small.
2627 Return 1 if window width is ok after adjustment; 0 if window
2628 is still too narrow. */
2631 adjust_window_margins (w
)
2634 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2635 - WINDOW_FRINGE_COLS (w
)
2636 - WINDOW_SCROLL_BAR_COLS (w
));
2637 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2638 + WINDOW_RIGHT_MARGIN_COLS (w
));
2640 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2643 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2646 /* Window's text area is too narrow, but reducing the window
2647 margins will fix that. */
2648 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2649 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2651 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2652 w
->left_margin_cols
= w
->right_margin_cols
2653 = make_number (margin_cols
/2);
2655 w
->right_margin_cols
= make_number (margin_cols
);
2658 w
->left_margin_cols
= make_number (margin_cols
);
2662 /* Calculate new sizes for windows in the list FORWARD when the window size
2663 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2664 The number of windows in FORWARD is NCHILDREN, and the number that
2665 can shrink is SHRINKABLE.
2666 The minimum size a window can have is MIN_SIZE.
2667 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2668 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2671 This function returns an allocated array of new sizes that the caller
2672 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2673 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2674 the second, and so on.
2676 This function tries to keep windows at least at the minimum size
2677 and resize other windows before it resizes any window to zero (i.e.
2678 delete that window).
2680 Windows are resized proportional to their size, so bigger windows
2681 shrink more than smaller windows. */
2683 shrink_windows (total
, size
, nchildren
, shrinkable
,
2684 min_size
, resize_fixed_p
, forward
, width_p
)
2685 int total
, size
, nchildren
, shrinkable
, min_size
;
2686 int resize_fixed_p
, width_p
;
2687 Lisp_Object forward
;
2689 int available_resize
= 0;
2693 int smallest
= total
;
2694 int total_removed
= 0;
2695 int total_shrink
= total
- size
;
2698 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2700 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2704 c
= XWINDOW (child
);
2705 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2707 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2711 new_sizes
[i
] = child_size
;
2712 if (child_size
> min_size
)
2713 available_resize
+= child_size
- min_size
;
2716 /* We might need to shrink some windows to zero. Find the smallest
2717 windows and set them to 0 until we can fulfil the new size. */
2719 while (shrinkable
> 1 && size
+ available_resize
< total
)
2721 for (i
= 0; i
< nchildren
; ++i
)
2722 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2723 smallest
= new_sizes
[i
];
2725 for (i
= 0; i
< nchildren
; ++i
)
2726 if (new_sizes
[i
] == smallest
)
2728 /* Resize this window down to zero. */
2730 if (smallest
> min_size
)
2731 available_resize
-= smallest
- min_size
;
2732 available_resize
+= smallest
;
2734 total_removed
+= smallest
;
2736 /* We don't know what the smallest is now. */
2739 /* Out of for, just remove one window at the time and
2740 check again if we have enough space. */
2745 /* Now, calculate the new sizes. Try to shrink each window
2746 proportional to its size. */
2747 for (i
= 0; i
< nchildren
; ++i
)
2749 if (new_sizes
[i
] > min_size
)
2751 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2752 if (new_sizes
[i
] - to_shrink
< min_size
)
2753 to_shrink
= new_sizes
[i
] - min_size
;
2754 new_sizes
[i
] -= to_shrink
;
2755 total_removed
+= to_shrink
;
2759 /* Any reminder due to rounding, we just subtract from windows
2760 that are left and still can be shrunk. */
2761 while (total_shrink
> total_removed
)
2763 int nonzero_sizes
= 0;
2764 int nonzero_idx
= -1;
2766 for (i
= 0; i
< nchildren
; ++i
)
2767 if (new_sizes
[i
] > 0)
2773 for (i
= 0; i
< nchildren
; ++i
)
2774 if (new_sizes
[i
] > min_size
)
2779 /* Out of for, just shrink one window at the time and
2780 check again if we have enough space. */
2785 /* Special case, only one window left. */
2786 if (nonzero_sizes
== 1)
2790 /* Any surplus due to rounding, we add to windows that are left. */
2791 while (total_shrink
< total_removed
)
2793 for (i
= 0; i
< nchildren
; ++i
)
2795 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2807 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2808 WINDOW's width. Resize WINDOW's children, if any, so that they
2809 keep their proportionate size relative to WINDOW. Propagate
2810 WINDOW's top or left edge position to children. Delete windows
2811 that become too small unless NODELETE_P is non-zero.
2813 If NODELETE_P is 2, that means we do delete windows that are
2814 too small, even if they were too small before! */
2817 size_window (window
, size
, width_p
, nodelete_p
)
2819 int size
, width_p
, nodelete_p
;
2821 struct window
*w
= XWINDOW (window
);
2823 Lisp_Object child
, *forward
, *sideward
;
2824 int old_size
, min_size
, safe_min_size
;
2826 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2827 seems like it's too soon to do this here. ++KFS. */
2828 if (nodelete_p
== 2)
2831 check_min_window_sizes ();
2832 size
= max (0, size
);
2834 /* If the window has been "too small" at one point,
2835 don't delete it for being "too small" in the future.
2836 Preserve it as long as that is at all possible. */
2839 old_size
= WINDOW_TOTAL_COLS (w
);
2840 min_size
= window_min_width
;
2841 /* Ensure that there is room for the scroll bar and fringes!
2842 We may reduce display margins though. */
2843 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2844 + WINDOW_FRINGE_COLS (w
)
2845 + WINDOW_SCROLL_BAR_COLS (w
));
2849 old_size
= XINT (w
->total_lines
);
2850 min_size
= window_min_height
;
2851 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2854 if (old_size
< min_size
&& nodelete_p
!= 2)
2855 w
->too_small_ok
= Qt
;
2857 /* Maybe delete WINDOW if it's too small. */
2858 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2860 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2861 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2862 if (min_size
< safe_min_size
)
2863 min_size
= safe_min_size
;
2864 if (size
< min_size
)
2866 delete_window (window
);
2871 /* Set redisplay hints. */
2872 w
->last_modified
= make_number (0);
2873 w
->last_overlay_modified
= make_number (0);
2874 windows_or_buffers_changed
++;
2875 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2879 sideward
= &w
->vchild
;
2880 forward
= &w
->hchild
;
2881 w
->total_cols
= make_number (size
);
2882 adjust_window_margins (w
);
2886 sideward
= &w
->hchild
;
2887 forward
= &w
->vchild
;
2888 w
->total_lines
= make_number (size
);
2889 w
->orig_total_lines
= Qnil
;
2892 if (!NILP (*sideward
))
2894 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2896 c
= XWINDOW (child
);
2898 c
->left_col
= w
->left_col
;
2900 c
->top_line
= w
->top_line
;
2901 size_window (child
, size
, width_p
, nodelete_p
);
2904 else if (!NILP (*forward
))
2906 int fixed_size
, each
, extra
, n
;
2907 int resize_fixed_p
, nfixed
;
2908 int last_pos
, first_pos
, nchildren
, total
;
2909 int *new_sizes
= NULL
;
2911 /* Determine the fixed-size portion of the this window, and the
2912 number of child windows. */
2913 fixed_size
= nchildren
= nfixed
= total
= 0;
2914 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2918 c
= XWINDOW (child
);
2919 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2920 total
+= child_size
;
2922 if (window_fixed_size_p (c
, width_p
, 0))
2924 fixed_size
+= child_size
;
2929 /* If the new size is smaller than fixed_size, or if there
2930 aren't any resizable windows, allow resizing fixed-size
2932 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2934 /* Compute how many lines/columns to add/remove to each child. The
2935 value of extra takes care of rounding errors. */
2936 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2937 if (size
< total
&& n
> 1)
2938 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2939 resize_fixed_p
, *forward
, width_p
);
2942 each
= (size
- total
) / n
;
2943 extra
= (size
- total
) - n
* each
;
2946 /* Compute new children heights and edge positions. */
2947 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2948 last_pos
= first_pos
;
2949 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2951 int new_size
, old_size
;
2953 c
= XWINDOW (child
);
2954 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2955 new_size
= old_size
;
2957 /* The top or left edge position of this child equals the
2958 bottom or right edge of its predecessor. */
2960 c
->left_col
= make_number (last_pos
);
2962 c
->top_line
= make_number (last_pos
);
2964 /* If this child can be resized, do it. */
2965 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2967 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2971 /* Set new height. Note that size_window also propagates
2972 edge positions to children, so it's not a no-op if we
2973 didn't change the child's size. */
2974 size_window (child
, new_size
, width_p
, 1);
2976 /* Remember the bottom/right edge position of this child; it
2977 will be used to set the top/left edge of the next child. */
2978 last_pos
+= new_size
;
2981 if (new_sizes
) xfree (new_sizes
);
2983 /* We should have covered the parent exactly with child windows. */
2984 xassert (size
== last_pos
- first_pos
);
2986 /* Now delete any children that became too small. */
2988 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2991 c
= XWINDOW (child
);
2992 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2993 size_window (child
, child_size
, width_p
, 2);
2998 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2999 WINDOW's children. NODELETE non-zero means don't delete windows
3000 that become too small in the process. (The caller should check
3001 later and do so if appropriate.) */
3004 set_window_height (window
, height
, nodelete
)
3009 size_window (window
, height
, 0, nodelete
);
3013 /* Set WINDOW's width to WIDTH, and recursively change the width of
3014 WINDOW's children. NODELETE non-zero means don't delete windows
3015 that become too small in the process. (The caller should check
3016 later and do so if appropriate.) */
3019 set_window_width (window
, width
, nodelete
)
3024 size_window (window
, width
, 1, nodelete
);
3027 /* Change window heights in windows rooted in WINDOW by N lines. */
3030 change_window_heights (window
, n
)
3034 struct window
*w
= XWINDOW (window
);
3036 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3037 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3039 if (INTEGERP (w
->orig_top_line
))
3040 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3041 if (INTEGERP (w
->orig_total_lines
))
3042 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3044 /* Handle just the top child in a vertical split. */
3045 if (!NILP (w
->vchild
))
3046 change_window_heights (w
->vchild
, n
);
3048 /* Adjust all children in a horizontal split. */
3049 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3051 w
= XWINDOW (window
);
3052 change_window_heights (window
, n
);
3057 int window_select_count
;
3060 Fset_window_buffer_unwind (obuf
)
3067 EXFUN (Fset_window_fringes
, 4);
3068 EXFUN (Fset_window_scroll_bars
, 4);
3070 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3071 means it's allowed to run hooks. See make_frame for a case where
3072 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3073 margins, fringes, and scroll-bar settings of the window are not
3074 reset from the buffer's local settings. */
3077 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3078 Lisp_Object window
, buffer
;
3079 int run_hooks_p
, keep_margins_p
;
3081 struct window
*w
= XWINDOW (window
);
3082 struct buffer
*b
= XBUFFER (buffer
);
3083 int count
= SPECPDL_INDEX ();
3087 if (EQ (window
, selected_window
))
3088 b
->last_selected_window
= window
;
3090 /* Let redisplay errors through. */
3091 b
->display_error_modiff
= 0;
3093 /* Update time stamps of buffer display. */
3094 if (INTEGERP (b
->display_count
))
3095 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3096 b
->display_time
= Fcurrent_time ();
3098 XSETFASTINT (w
->window_end_pos
, 0);
3099 XSETFASTINT (w
->window_end_vpos
, 0);
3100 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3101 w
->window_end_valid
= Qnil
;
3102 w
->hscroll
= w
->min_hscroll
= make_number (0);
3104 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3105 set_marker_restricted (w
->start
,
3106 make_number (b
->last_window_start
),
3108 w
->start_at_line_beg
= Qnil
;
3109 w
->force_start
= Qnil
;
3110 XSETFASTINT (w
->last_modified
, 0);
3111 XSETFASTINT (w
->last_overlay_modified
, 0);
3112 windows_or_buffers_changed
++;
3114 /* We must select BUFFER for running the window-scroll-functions.
3115 If WINDOW is selected, switch permanently.
3116 Otherwise, switch but go back to the ambient buffer afterward. */
3117 if (EQ (window
, selected_window
))
3118 Fset_buffer (buffer
);
3119 /* We can't check ! NILP (Vwindow_scroll_functions) here
3120 because that might itself be a local variable. */
3121 else if (window_initialized
)
3123 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3124 Fset_buffer (buffer
);
3127 if (!keep_margins_p
)
3129 /* Set left and right marginal area width etc. from buffer. */
3131 /* This may call adjust_window_margins three times, so
3132 temporarily disable window margins. */
3133 Lisp_Object save_left
= w
->left_margin_cols
;
3134 Lisp_Object save_right
= w
->right_margin_cols
;
3136 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3138 Fset_window_fringes (window
,
3139 b
->left_fringe_width
, b
->right_fringe_width
,
3140 b
->fringes_outside_margins
);
3142 Fset_window_scroll_bars (window
,
3143 b
->scroll_bar_width
,
3144 b
->vertical_scroll_bar_type
, Qnil
);
3146 w
->left_margin_cols
= save_left
;
3147 w
->right_margin_cols
= save_right
;
3149 Fset_window_margins (window
,
3150 b
->left_margin_cols
, b
->right_margin_cols
);
3155 if (! NILP (Vwindow_scroll_functions
))
3156 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3157 Fmarker_position (w
->start
));
3159 if (! NILP (Vwindow_configuration_change_hook
)
3160 && ! NILP (Vrun_hooks
))
3161 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3164 unbind_to (count
, Qnil
);
3168 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3169 doc
: /* Make WINDOW display BUFFER as its contents.
3170 BUFFER can be a buffer or the name of an existing buffer.
3171 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3172 display margins, fringe widths, and scroll bar settings are maintained;
3173 the default is to reset these from BUFFER's local settings or the frame
3176 This function runs the hook `window-scroll-functions'. */)
3177 (window
, buffer
, keep_margins
)
3178 register Lisp_Object window
, buffer
, keep_margins
;
3180 register Lisp_Object tem
;
3181 register struct window
*w
= decode_window (window
);
3183 XSETWINDOW (window
, w
);
3184 buffer
= Fget_buffer (buffer
);
3185 CHECK_BUFFER (buffer
);
3187 if (NILP (XBUFFER (buffer
)->name
))
3188 error ("Attempt to display deleted buffer");
3192 error ("Window is deleted");
3193 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3194 is first being set up. */
3196 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3197 error ("Window is dedicated to `%s'",
3198 SDATA (XBUFFER (tem
)->name
));
3203 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3207 /* Note that selected_window can be nil
3208 when this is called from Fset_window_configuration. */
3210 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3211 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3212 If WINDOW is not already selected, make WINDOW's buffer current
3213 and make WINDOW the frame's selected window. Return WINDOW.
3214 Optional second arg NORECORD non-nil means
3215 do not put this buffer at the front of the list of recently selected ones.
3217 Note that the main editor command loop
3218 selects the buffer of the selected window before each command. */)
3220 register Lisp_Object window
, norecord
;
3222 register struct window
*w
;
3223 register struct window
*ow
;
3226 CHECK_LIVE_WINDOW (window
);
3228 w
= XWINDOW (window
);
3229 w
->frozen_window_start_p
= 0;
3231 ++window_select_count
;
3232 XSETFASTINT (w
->use_time
, window_select_count
);
3233 if (EQ (window
, selected_window
))
3236 /* Store the current buffer's actual point into the
3237 old selected window. It belongs to that window,
3238 and when the window is not selected, must be in the window. */
3239 if (!NILP (selected_window
))
3241 ow
= XWINDOW (selected_window
);
3242 if (! NILP (ow
->buffer
))
3243 set_marker_both (ow
->pointm
, ow
->buffer
,
3244 BUF_PT (XBUFFER (ow
->buffer
)),
3245 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3248 selected_window
= window
;
3249 sf
= SELECTED_FRAME ();
3250 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3252 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3253 /* Use this rather than Fhandle_switch_frame
3254 so that FRAME_FOCUS_FRAME is moved appropriately as we
3255 move around in the state where a minibuffer in a separate
3257 Fselect_frame (WINDOW_FRAME (w
));
3260 sf
->selected_window
= window
;
3262 if (NILP (norecord
))
3263 record_buffer (w
->buffer
);
3264 Fset_buffer (w
->buffer
);
3266 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3268 /* Go to the point recorded in the window.
3269 This is important when the buffer is in more
3270 than one window. It also matters when
3271 redisplay_window has altered point after scrolling,
3272 because it makes the change only in the window. */
3274 register int new_point
= marker_position (w
->pointm
);
3275 if (new_point
< BEGV
)
3277 else if (new_point
> ZV
)
3283 windows_or_buffers_changed
++;
3288 select_window_norecord (window
)
3291 return Fselect_window (window
, Qt
);
3294 /* Deiconify the frame containing the window WINDOW,
3295 unless it is the selected frame;
3298 The reason for the exception for the selected frame
3299 is that it seems better not to change the selected frames visibility
3300 merely because of displaying a different buffer in it.
3301 The deiconification is useful when a buffer gets shown in
3302 another frame that you were not using lately. */
3305 display_buffer_1 (window
)
3308 Lisp_Object frame
= XWINDOW (window
)->frame
;
3309 FRAME_PTR f
= XFRAME (frame
);
3311 FRAME_SAMPLE_VISIBILITY (f
);
3313 if (EQ (frame
, selected_frame
))
3314 ; /* Assume the selected frame is already visible enough. */
3315 else if (minibuf_level
> 0
3316 && MINI_WINDOW_P (XWINDOW (selected_window
))
3317 && WINDOW_LIVE_P (minibuf_selected_window
)
3318 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3319 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3322 if (FRAME_ICONIFIED_P (f
))
3323 Fmake_frame_visible (frame
);
3324 else if (FRAME_VISIBLE_P (f
))
3325 Fraise_frame (frame
);
3331 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3332 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3333 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3334 special frame for that buffer using the default frame parameters.
3336 If the value is a list, it is a list of frame parameters that would be used
3337 to make a frame for that buffer.
3338 The variables `special-display-buffer-names'
3339 and `special-display-regexps' control this. */)
3341 Lisp_Object buffer_name
;
3345 CHECK_STRING (buffer_name
);
3347 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3351 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3355 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3357 Lisp_Object car
= XCAR (tem
);
3359 && fast_string_match (car
, buffer_name
) >= 0)
3361 else if (CONSP (car
)
3362 && STRINGP (XCAR (car
))
3363 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3369 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3370 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3371 More precisely, if `display-buffer' or `pop-to-buffer' would display
3372 that buffer in the selected window rather than (as usual) in some other window.
3373 See `same-window-buffer-names' and `same-window-regexps'. */)
3375 Lisp_Object buffer_name
;
3379 CHECK_STRING (buffer_name
);
3381 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3385 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3389 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3391 Lisp_Object car
= XCAR (tem
);
3393 && fast_string_match (car
, buffer_name
) >= 0)
3395 else if (CONSP (car
)
3396 && STRINGP (XCAR (car
))
3397 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3403 /* Use B so the default is (other-buffer). */
3404 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3405 "BDisplay buffer: \nP",
3406 doc
: /* Make BUFFER appear in some window but don't select it.
3407 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3409 If BUFFER is shown already in some window, just use that one,
3410 unless the window is the selected window and the optional second
3411 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3412 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3413 Returns the window displaying BUFFER.
3414 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3415 displaying BUFFER, then simply raise that frame.
3417 The variables `special-display-buffer-names',
3418 `special-display-regexps', `same-window-buffer-names', and
3419 `same-window-regexps' customize how certain buffer names are handled.
3420 The latter two take effect only if NOT-THIS-WINDOW is t.
3422 If optional argument FRAME is `visible', search all visible frames.
3423 If FRAME is 0, search all visible and iconified frames.
3424 If FRAME is t, search all frames.
3425 If FRAME is a frame, search only that frame.
3426 If FRAME is nil, search only the selected frame
3427 (actually the last nonminibuffer frame),
3428 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3429 which means search visible and iconified frames.
3431 If a full-width window on a splittable frame is available to display
3432 the buffer, it may be split, subject to the value of the variable
3433 `split-height-threshold'.
3435 If `even-window-heights' is non-nil, window heights will be evened out
3436 if displaying the buffer causes two vertically adjacent windows to be
3438 (buffer
, not_this_window
, frame
)
3439 register Lisp_Object buffer
, not_this_window
, frame
;
3441 register Lisp_Object window
, tem
, swp
;
3445 buffer
= Fget_buffer (buffer
);
3446 CHECK_BUFFER (buffer
);
3448 if (!NILP (Vdisplay_buffer_function
))
3449 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3451 if (NILP (not_this_window
)
3452 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3453 return display_buffer_1 (selected_window
);
3455 /* See if the user has specified this buffer should appear
3456 in the selected window. */
3457 if (NILP (not_this_window
))
3459 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3460 if (!NILP (swp
) && !no_switch_window (selected_window
))
3462 Fswitch_to_buffer (buffer
, Qnil
);
3463 return display_buffer_1 (selected_window
);
3467 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3468 look for a window showing BUFFER on any visible or iconified frame.
3469 Otherwise search only the current frame. */
3472 else if (pop_up_frames
3473 || display_buffer_reuse_frames
3474 || last_nonminibuf_frame
== 0)
3475 XSETFASTINT (tem
, 0);
3477 XSETFRAME (tem
, last_nonminibuf_frame
);
3479 window
= Fget_buffer_window (buffer
, tem
);
3481 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3482 return display_buffer_1 (window
);
3484 /* Certain buffer names get special handling. */
3485 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3487 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3489 return call1 (Vspecial_display_function
, buffer
);
3491 return call2 (Vspecial_display_function
, buffer
, tem
);
3494 /* If there are no frames open that have more than a minibuffer,
3495 we need to create a new frame. */
3496 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3498 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3499 Fset_window_buffer (window
, buffer
, Qnil
);
3500 return display_buffer_1 (window
);
3503 f
= SELECTED_FRAME ();
3505 || FRAME_MINIBUF_ONLY_P (f
)
3506 /* If the current frame is a special display frame,
3507 don't try to reuse its windows. */
3508 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3513 if (FRAME_MINIBUF_ONLY_P (f
))
3514 XSETFRAME (frames
, last_nonminibuf_frame
);
3515 /* Don't try to create a window if we would get an error. */
3516 if (split_height_threshold
< window_min_height
<< 1)
3517 split_height_threshold
= window_min_height
<< 1;
3519 /* Note that both Fget_largest_window and Fget_lru_window
3520 ignore minibuffers and dedicated windows.
3521 This means they can return nil. */
3523 /* If the frame we would try to split cannot be split,
3524 try other frames. */
3525 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3527 /* Try visible frames first. */
3528 window
= Fget_largest_window (Qvisible
, Qt
);
3529 /* If that didn't work, try iconified frames. */
3531 window
= Fget_largest_window (make_number (0), Qt
);
3532 #if 0 /* Don't try windows on other displays. */
3534 window
= Fget_largest_window (Qt
, Qt
);
3538 window
= Fget_largest_window (frames
, Qt
);
3540 /* If we got a tall enough full-width window that can be split,
3543 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3544 && window_height (window
) >= split_height_threshold
3545 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3546 window
= Fsplit_window (window
, Qnil
, Qnil
);
3549 Lisp_Object upper
, lower
, other
;
3551 window
= Fget_lru_window (frames
, Qt
);
3552 /* If the LRU window is selected, and big enough,
3553 and can be split, split it. */
3555 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3556 && (EQ (window
, selected_window
)
3557 || EQ (XWINDOW (window
)->parent
, Qnil
))
3558 && window_height (window
) >= window_min_height
<< 1)
3559 window
= Fsplit_window (window
, Qnil
, Qnil
);
3561 window
= Fget_lru_window (frames
, Qnil
);
3562 /* If Fget_lru_window returned nil, try other approaches. */
3564 /* Try visible frames first. */
3566 window
= Fget_buffer_window (buffer
, Qvisible
);
3568 window
= Fget_largest_window (Qvisible
, Qnil
);
3569 /* If that didn't work, try iconified frames. */
3571 window
= Fget_buffer_window (buffer
, make_number (0));
3573 window
= Fget_largest_window (make_number (0), Qnil
);
3575 #if 0 /* Don't try frames on other displays. */
3577 window
= Fget_buffer_window (buffer
, Qt
);
3579 window
= Fget_largest_window (Qt
, Qnil
);
3581 /* As a last resort, make a new frame. */
3583 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3584 /* If window appears above or below another,
3585 even out their heights. */
3586 other
= upper
= lower
= Qnil
;
3587 if (!NILP (XWINDOW (window
)->prev
))
3588 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3589 if (!NILP (XWINDOW (window
)->next
))
3590 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3592 && !NILP (Veven_window_heights
)
3593 /* Check that OTHER and WINDOW are vertically arrayed. */
3594 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3595 && (XFASTINT (XWINDOW (other
)->total_lines
)
3596 > XFASTINT (XWINDOW (window
)->total_lines
)))
3598 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3599 + XFASTINT (XWINDOW (window
)->total_lines
));
3600 enlarge_window (upper
,
3601 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3607 window
= Fget_lru_window (Qnil
, Qnil
);
3609 Fset_window_buffer (window
, buffer
, Qnil
);
3610 return display_buffer_1 (window
);
3614 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3616 doc
: /* Force redisplay of all windows.
3617 If optional arg OBJECT is a window, force redisplay of that window only.
3618 If OBJECT is a buffer or buffer name, force redisplay of all windows
3619 displaying that buffer. */)
3625 windows_or_buffers_changed
++;
3626 update_mode_lines
++;
3630 if (WINDOWP (object
))
3632 struct window
*w
= XWINDOW (object
);
3633 mark_window_display_accurate (object
, 0);
3634 w
->update_mode_line
= Qt
;
3635 if (BUFFERP (w
->buffer
))
3636 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3637 ++update_mode_lines
;
3641 if (STRINGP (object
))
3642 object
= Fget_buffer (object
);
3643 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3645 /* Walk all windows looking for buffer, and force update
3646 of each of those windows. */
3648 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3649 return NILP (object
) ? Qnil
: Qt
;
3652 /* If nothing suitable was found, just return.
3653 We could signal an error, but this feature will typically be used
3654 asynchronously in timers or process sentinels, so we don't. */
3660 temp_output_buffer_show (buf
)
3661 register Lisp_Object buf
;
3663 register struct buffer
*old
= current_buffer
;
3664 register Lisp_Object window
;
3665 register struct window
*w
;
3667 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3670 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3674 #if 0 /* rms: there should be no reason for this. */
3675 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3677 set_buffer_internal (old
);
3679 if (!NILP (Vtemp_buffer_show_function
))
3680 call1 (Vtemp_buffer_show_function
, buf
);
3683 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3685 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3686 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3687 Vminibuf_scroll_window
= window
;
3688 w
= XWINDOW (window
);
3689 XSETFASTINT (w
->hscroll
, 0);
3690 XSETFASTINT (w
->min_hscroll
, 0);
3691 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3692 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3694 /* Run temp-buffer-show-hook, with the chosen window selected
3695 and its buffer current. */
3697 if (!NILP (Vrun_hooks
)
3698 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3699 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3701 int count
= SPECPDL_INDEX ();
3702 Lisp_Object prev_window
, prev_buffer
;
3703 prev_window
= selected_window
;
3704 XSETBUFFER (prev_buffer
, old
);
3706 /* Select the window that was chosen, for running the hook.
3707 Note: Both Fselect_window and select_window_norecord may
3708 set-buffer to the buffer displayed in the window,
3709 so we need to save the current buffer. --stef */
3710 record_unwind_protect (Fset_buffer
, prev_buffer
);
3711 record_unwind_protect (select_window_norecord
, prev_window
);
3712 Fselect_window (window
, Qt
);
3713 Fset_buffer (w
->buffer
);
3714 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3715 unbind_to (count
, Qnil
);
3721 make_dummy_parent (window
)
3725 register struct window
*o
, *p
;
3728 o
= XWINDOW (window
);
3729 p
= allocate_window ();
3730 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3731 ((struct Lisp_Vector
*) p
)->contents
[i
]
3732 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3733 XSETWINDOW (new, p
);
3736 XSETFASTINT (p
->sequence_number
, sequence_number
);
3738 /* Put new into window structure in place of window */
3739 replace_window (window
, new);
3752 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3753 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3754 WINDOW defaults to selected one and SIZE to half its size.
3755 If optional third arg HORFLAG is non-nil, split side by side
3756 and put SIZE columns in the first of the pair. In that case,
3757 SIZE includes that window's scroll bar, or the divider column to its right.
3758 Interactively, all arguments are nil.
3760 Returns the newly created window (which is the lower or rightmost one).
3761 The upper or leftmost window is the original one and remains selected.
3762 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3763 (window
, size
, horflag
)
3764 Lisp_Object window
, size
, horflag
;
3766 register Lisp_Object
new;
3767 register struct window
*o
, *p
;
3769 register int size_int
;
3772 window
= selected_window
;
3774 CHECK_LIVE_WINDOW (window
);
3776 o
= XWINDOW (window
);
3777 fo
= XFRAME (WINDOW_FRAME (o
));
3781 if (!NILP (horflag
))
3782 /* Calculate the size of the left-hand window, by dividing
3783 the usable space in columns by two.
3784 We round up, since the left-hand window may include
3785 a dividing line, while the right-hand may not. */
3786 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3788 size_int
= XFASTINT (o
->total_lines
) >> 1;
3792 CHECK_NUMBER (size
);
3793 size_int
= XINT (size
);
3796 if (MINI_WINDOW_P (o
))
3797 error ("Attempt to split minibuffer window");
3798 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3799 error ("Attempt to split fixed-size window");
3801 check_min_window_sizes ();
3805 if (size_int
< window_min_height
)
3806 error ("Window height %d too small (after splitting)", size_int
);
3807 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3808 error ("Window height %d too small (after splitting)",
3809 XFASTINT (o
->total_lines
) - size_int
);
3810 if (NILP (o
->parent
)
3811 || NILP (XWINDOW (o
->parent
)->vchild
))
3813 make_dummy_parent (window
);
3815 XWINDOW (new)->vchild
= window
;
3820 if (size_int
< window_min_width
)
3821 error ("Window width %d too small (after splitting)", size_int
);
3823 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3824 error ("Window width %d too small (after splitting)",
3825 XFASTINT (o
->total_cols
) - size_int
);
3826 if (NILP (o
->parent
)
3827 || NILP (XWINDOW (o
->parent
)->hchild
))
3829 make_dummy_parent (window
);
3831 XWINDOW (new)->hchild
= window
;
3835 /* Now we know that window's parent is a vertical combination
3836 if we are dividing vertically, or a horizontal combination
3837 if we are making side-by-side windows */
3839 windows_or_buffers_changed
++;
3840 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3841 new = make_window ();
3844 p
->frame
= o
->frame
;
3846 if (!NILP (p
->next
))
3847 XWINDOW (p
->next
)->prev
= new;
3850 p
->parent
= o
->parent
;
3852 p
->window_end_valid
= Qnil
;
3853 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3855 /* Duplicate special geometry settings. */
3857 p
->left_margin_cols
= o
->left_margin_cols
;
3858 p
->right_margin_cols
= o
->right_margin_cols
;
3859 p
->left_fringe_width
= o
->left_fringe_width
;
3860 p
->right_fringe_width
= o
->right_fringe_width
;
3861 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3862 p
->scroll_bar_width
= o
->scroll_bar_width
;
3863 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3865 /* Apportion the available frame space among the two new windows */
3867 if (!NILP (horflag
))
3869 p
->total_lines
= o
->total_lines
;
3870 p
->top_line
= o
->top_line
;
3871 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3872 XSETFASTINT (o
->total_cols
, size_int
);
3873 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3874 adjust_window_margins (p
);
3875 adjust_window_margins (o
);
3879 p
->left_col
= o
->left_col
;
3880 p
->total_cols
= o
->total_cols
;
3881 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3882 XSETFASTINT (o
->total_lines
, size_int
);
3883 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3886 /* Adjust glyph matrices. */
3889 Fset_window_buffer (new, o
->buffer
, Qt
);
3893 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3894 doc
: /* Make current window ARG lines bigger.
3895 From program, optional second arg non-nil means grow sideways ARG columns.
3896 Interactively, if an argument is not given, make the window one line bigger.
3897 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
3898 This function can delete windows, even the second window, if they get
3901 Lisp_Object arg
, horizontal
;
3904 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
3906 if (! NILP (Vwindow_configuration_change_hook
))
3907 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3912 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3913 doc
: /* Make current window ARG lines smaller.
3914 From program, optional second arg non-nil means shrink sideways arg columns.
3915 Interactively, if an argument is not given, make the window one line smaller. Only
3916 siblings to the right or below are changed. */)
3918 Lisp_Object arg
, side
;
3921 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3923 if (! NILP (Vwindow_configuration_change_hook
))
3924 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3930 window_height (window
)
3933 register struct window
*p
= XWINDOW (window
);
3934 return WINDOW_TOTAL_LINES (p
);
3938 window_width (window
)
3941 register struct window
*p
= XWINDOW (window
);
3942 return WINDOW_TOTAL_COLS (p
);
3947 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3949 #define CURSIZE(w) \
3950 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3953 /* Enlarge WINDOW by DELTA.
3954 HORIZ_FLAG nonzero means enlarge it horizontally;
3955 zero means do it vertically.
3957 Siblings of the selected window are resized to fulfill the size
3958 request. If they become too small in the process, they will be
3962 enlarge_window (window
, delta
, horiz_flag
)
3964 int delta
, horiz_flag
;
3966 Lisp_Object parent
, next
, prev
;
3970 int (*sizefun
) P_ ((Lisp_Object
))
3971 = horiz_flag
? window_width
: window_height
;
3972 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3973 = (horiz_flag
? set_window_width
: set_window_height
);
3975 /* Check values of window_min_width and window_min_height for
3977 check_min_window_sizes ();
3979 /* Give up if this window cannot be resized. */
3980 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3981 error ("Window is not resizable");
3983 /* Find the parent of the selected window. */
3986 p
= XWINDOW (window
);
3992 error ("No other window to side of this one");
3997 ? !NILP (XWINDOW (parent
)->hchild
)
3998 : !NILP (XWINDOW (parent
)->vchild
))
4004 sizep
= &CURSIZE (window
);
4007 register int maxdelta
;
4009 /* Compute the maximum size increment this window can have. */
4011 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4012 /* This is a main window followed by a minibuffer. */
4013 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4014 - window_min_size (XWINDOW (p
->next
),
4016 /* This is a minibuffer following a main window. */
4017 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4018 - window_min_size (XWINDOW (p
->prev
),
4020 /* This is a frame with only one window, a minibuffer-only
4021 or a minibufferless frame. */
4024 if (delta
> maxdelta
)
4025 /* This case traps trying to make the minibuffer
4026 the full frame, or make the only window aside from the
4027 minibuffer the full frame. */
4031 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4033 delete_window (window
);
4040 /* Find the total we can get from other siblings without deleting them. */
4042 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4043 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4045 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4046 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4049 /* If we can get it all from them without deleting them, do so. */
4050 if (delta
<= maximum
)
4052 Lisp_Object first_unaffected
;
4053 Lisp_Object first_affected
;
4058 first_affected
= window
;
4059 /* Look at one sibling at a time,
4060 moving away from this window in both directions alternately,
4061 and take as much as we can get without deleting that sibling. */
4063 && (!NILP (next
) || !NILP (prev
)))
4067 int this_one
= ((*sizefun
) (next
)
4068 - window_min_size (XWINDOW (next
),
4069 horiz_flag
, 0, &fixed_p
));
4072 if (this_one
> delta
)
4075 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4076 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4081 next
= XWINDOW (next
)->next
;
4089 int this_one
= ((*sizefun
) (prev
)
4090 - window_min_size (XWINDOW (prev
),
4091 horiz_flag
, 0, &fixed_p
));
4094 if (this_one
> delta
)
4097 first_affected
= prev
;
4099 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4100 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4105 prev
= XWINDOW (prev
)->prev
;
4109 xassert (delta
== 0);
4111 /* Now recalculate the edge positions of all the windows affected,
4112 based on the new sizes. */
4113 first_unaffected
= next
;
4114 prev
= first_affected
;
4115 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4116 prev
= next
, next
= XWINDOW (next
)->next
)
4118 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4119 /* This does not change size of NEXT,
4120 but it propagates the new top edge to its children */
4121 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4126 register int delta1
;
4127 register int opht
= (*sizefun
) (parent
);
4129 if (opht
<= XINT (*sizep
) + delta
)
4131 /* If trying to grow this window to or beyond size of the parent,
4132 just delete all the sibling windows. */
4133 Lisp_Object start
, tem
, next
;
4135 start
= XWINDOW (parent
)->vchild
;
4137 start
= XWINDOW (parent
)->hchild
;
4139 /* Delete any siblings that come after WINDOW. */
4140 tem
= XWINDOW (window
)->next
;
4141 while (! NILP (tem
))
4143 next
= XWINDOW (tem
)->next
;
4144 delete_window (tem
);
4148 /* Delete any siblings that come after WINDOW.
4149 Note that if START is not WINDOW, then WINDOW still
4150 Fhas siblings, so WINDOW has not yet replaced its parent. */
4152 while (! EQ (tem
, window
))
4154 next
= XWINDOW (tem
)->next
;
4155 delete_window (tem
);
4161 /* Otherwise, make delta1 just right so that if we add
4162 delta1 lines to this window and to the parent, and then
4163 shrink the parent back to its original size, the new
4164 proportional size of this window will increase by delta.
4166 The function size_window will compute the new height h'
4167 of the window from delta1 as:
4170 x = delta1 - delta1/n * n for the 1st resizable child
4173 where n is the number of children that can be resized.
4174 We can ignore x by choosing a delta1 that is a multiple of
4175 n. We want the height of this window to come out as
4185 The number of children n equals the number of resizable
4186 children of this window + 1 because we know window itself
4187 is resizable (otherwise we would have signalled an error). */
4189 struct window
*w
= XWINDOW (window
);
4193 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4194 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4196 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4197 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4202 /* Add delta1 lines or columns to this window, and to the parent,
4203 keeping things consistent while not affecting siblings. */
4204 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4205 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4207 /* Squeeze out delta1 lines or columns from our parent,
4208 shriking this window and siblings proportionately.
4209 This brings parent back to correct size.
4210 Delta1 was calculated so this makes this window the desired size,
4211 taking it all out of the siblings. */
4212 (*setsizefun
) (parent
, opht
, 0);
4217 XSETFASTINT (p
->last_modified
, 0);
4218 XSETFASTINT (p
->last_overlay_modified
, 0);
4220 /* Adjust glyph matrices. */
4221 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4225 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4226 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4227 zero means adjust the height, moving the bottom edge.
4229 Following siblings of the selected window are resized to fulfill
4230 the size request. If they become too small in the process, they
4231 are not deleted; instead, we signal an error. */
4234 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4236 int delta
, horiz_flag
;
4238 Lisp_Object parent
, child
;
4240 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4241 int delcount
= window_deletion_count
;
4243 /* Check values of window_min_width and window_min_height for
4245 check_min_window_sizes ();
4248 window
= Fselected_window ();
4250 CHECK_WINDOW (window
);
4252 /* Give up if this window cannot be resized. */
4253 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4254 error ("Window is not resizable");
4258 p
= XWINDOW (window
);
4261 /* Make sure there is a following window. */
4264 : NILP (XWINDOW (window
)->next
)))
4266 Fset_window_configuration (old_config
);
4267 error ("No other window following this one");
4270 /* Don't make this window too small. */
4271 if (XINT (CURSIZE (window
)) + delta
4272 < (horiz_flag
? window_min_width
: window_min_height
))
4274 Fset_window_configuration (old_config
);
4275 error ("Cannot adjust window size as specified");
4278 /* Clear out some redisplay caches. */
4279 XSETFASTINT (p
->last_modified
, 0);
4280 XSETFASTINT (p
->last_overlay_modified
, 0);
4282 /* Adjust this window's edge. */
4283 XSETINT (CURSIZE (window
),
4284 XINT (CURSIZE (window
)) + delta
);
4286 /* If this window has following siblings in the desired dimension,
4288 (If we reach the top of the tree and can never do this,
4289 we will fail and report an error, above.) */
4291 ? !NILP (XWINDOW (parent
)->hchild
)
4292 : !NILP (XWINDOW (parent
)->vchild
))
4294 if (!NILP (XWINDOW (window
)->next
))
4296 /* This may happen for the minibuffer. In that case
4297 the window_deletion_count check below does not work. */
4298 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4300 Fset_window_configuration (old_config
);
4301 error ("Cannot adjust window size as specified");
4304 XSETINT (CURBEG (p
->next
),
4305 XINT (CURBEG (p
->next
)) + delta
);
4306 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4312 /* Here we have a chain of parallel siblings, in the other dimension.
4313 Change the size of the other siblings. */
4314 for (child
= (horiz_flag
4315 ? XWINDOW (parent
)->vchild
4316 : XWINDOW (parent
)->hchild
);
4318 child
= XWINDOW (child
)->next
)
4319 if (! EQ (child
, window
))
4320 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4326 /* If we made a window so small it got deleted,
4327 we failed. Report failure. */
4328 if (delcount
!= window_deletion_count
)
4330 Fset_window_configuration (old_config
);
4331 error ("Cannot adjust window size as specified");
4334 /* Adjust glyph matrices. */
4335 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4341 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4342 Sadjust_window_trailing_edge
, 3, 3, 0,
4343 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4344 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4345 Otherwise, adjust the height, moving the bottom edge.
4347 Following siblings of the selected window are resized to fulfill
4348 the size request. If they become too small in the process, they
4349 are not deleted; instead, we signal an error. */)
4350 (window
, delta
, horizontal
)
4351 Lisp_Object window
, delta
, horizontal
;
4353 CHECK_NUMBER (delta
);
4354 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4356 if (! NILP (Vwindow_configuration_change_hook
))
4357 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4364 /***********************************************************************
4365 Resizing Mini-Windows
4366 ***********************************************************************/
4368 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4370 enum save_restore_action
4377 static int save_restore_orig_size
P_ ((struct window
*,
4378 enum save_restore_action
));
4380 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4381 from lowest windows first. */
4384 shrink_window_lowest_first (w
, height
)
4392 xassert (!MINI_WINDOW_P (w
));
4394 /* Set redisplay hints. */
4395 XSETFASTINT (w
->last_modified
, 0);
4396 XSETFASTINT (w
->last_overlay_modified
, 0);
4397 windows_or_buffers_changed
++;
4398 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4400 old_height
= XFASTINT (w
->total_lines
);
4401 XSETFASTINT (w
->total_lines
, height
);
4403 if (!NILP (w
->hchild
))
4405 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4407 c
= XWINDOW (child
);
4408 c
->top_line
= w
->top_line
;
4409 shrink_window_lowest_first (c
, height
);
4412 else if (!NILP (w
->vchild
))
4414 Lisp_Object last_child
;
4415 int delta
= old_height
- height
;
4420 /* Find the last child. We are taking space from lowest windows
4421 first, so we iterate over children from the last child
4423 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4426 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4427 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4431 c
= XWINDOW (child
);
4432 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4434 if (this_one
> delta
)
4437 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4441 /* Compute new positions. */
4442 last_top
= XINT (w
->top_line
);
4443 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4445 c
= XWINDOW (child
);
4446 c
->top_line
= make_number (last_top
);
4447 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4448 last_top
+= XFASTINT (c
->total_lines
);
4454 /* Save, restore, or check positions and sizes in the window tree
4455 rooted at W. ACTION says what to do.
4457 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4458 orig_total_lines members are valid for all windows in the window
4459 tree. Value is non-zero if they are valid.
4461 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4462 orig_top_line and orig_total_lines for all windows in the tree.
4464 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4465 stored in orig_top_line and orig_total_lines for all windows. */
4468 save_restore_orig_size (w
, action
)
4470 enum save_restore_action action
;
4476 if (!NILP (w
->hchild
))
4478 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4481 else if (!NILP (w
->vchild
))
4483 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4489 case CHECK_ORIG_SIZES
:
4490 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4494 case SAVE_ORIG_SIZES
:
4495 w
->orig_top_line
= w
->top_line
;
4496 w
->orig_total_lines
= w
->total_lines
;
4497 XSETFASTINT (w
->last_modified
, 0);
4498 XSETFASTINT (w
->last_overlay_modified
, 0);
4501 case RESTORE_ORIG_SIZES
:
4502 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4503 w
->top_line
= w
->orig_top_line
;
4504 w
->total_lines
= w
->orig_total_lines
;
4505 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4506 XSETFASTINT (w
->last_modified
, 0);
4507 XSETFASTINT (w
->last_overlay_modified
, 0);
4514 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4521 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4522 without deleting other windows. */
4525 grow_mini_window (w
, delta
)
4529 struct frame
*f
= XFRAME (w
->frame
);
4530 struct window
*root
;
4532 xassert (MINI_WINDOW_P (w
));
4533 xassert (delta
>= 0);
4535 /* Check values of window_min_width and window_min_height for
4537 check_min_window_sizes ();
4539 /* Compute how much we can enlarge the mini-window without deleting
4541 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4544 int min_height
= window_min_size (root
, 0, 0, 0);
4545 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4546 /* Note that the root window may already be smaller than
4548 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4553 /* Save original window sizes and positions, if not already done. */
4554 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4555 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4557 /* Shrink other windows. */
4558 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4560 /* Grow the mini-window. */
4561 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4562 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4563 XSETFASTINT (w
->last_modified
, 0);
4564 XSETFASTINT (w
->last_overlay_modified
, 0);
4571 /* Shrink mini-window W. If there is recorded info about window sizes
4572 before a call to grow_mini_window, restore recorded window sizes.
4573 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4577 shrink_mini_window (w
)
4580 struct frame
*f
= XFRAME (w
->frame
);
4581 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4583 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4585 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4587 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4588 windows_or_buffers_changed
= 1;
4590 else if (XFASTINT (w
->total_lines
) > 1)
4592 /* Distribute the additional lines of the mini-window
4593 among the other windows. */
4595 XSETWINDOW (window
, w
);
4596 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4602 /* Mark window cursors off for all windows in the window tree rooted
4603 at W by setting their phys_cursor_on_p flag to zero. Called from
4604 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4605 the frame are cleared. */
4608 mark_window_cursors_off (w
)
4613 if (!NILP (w
->hchild
))
4614 mark_window_cursors_off (XWINDOW (w
->hchild
));
4615 else if (!NILP (w
->vchild
))
4616 mark_window_cursors_off (XWINDOW (w
->vchild
));
4618 w
->phys_cursor_on_p
= 0;
4620 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4625 /* Return number of lines of text (not counting mode lines) in W. */
4628 window_internal_height (w
)
4631 int ht
= XFASTINT (w
->total_lines
);
4633 if (!MINI_WINDOW_P (w
))
4635 if (!NILP (w
->parent
)
4636 || !NILP (w
->vchild
)
4637 || !NILP (w
->hchild
)
4640 || WINDOW_WANTS_MODELINE_P (w
))
4643 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4651 /* Return the number of columns in W.
4652 Don't count columns occupied by scroll bars or the vertical bar
4653 separating W from the sibling to its right. */
4656 window_box_text_cols (w
)
4659 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4660 int width
= XINT (w
->total_cols
);
4662 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4663 /* Scroll bars occupy a few columns. */
4664 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4665 else if (!FRAME_WINDOW_P (f
)
4666 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4667 /* The column of `|' characters separating side-by-side windows
4668 occupies one column only. */
4671 if (FRAME_WINDOW_P (f
))
4672 /* On window-systems, fringes and display margins cannot be
4673 used for normal text. */
4674 width
-= (WINDOW_FRINGE_COLS (w
)
4675 + WINDOW_LEFT_MARGIN_COLS (w
)
4676 + WINDOW_RIGHT_MARGIN_COLS (w
));
4682 /************************************************************************
4684 ***********************************************************************/
4686 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4687 N screen-fulls, which is defined as the height of the window minus
4688 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4689 instead. Negative values of N mean scroll down. NOERROR non-zero
4690 means don't signal an error if we try to move over BEGV or ZV,
4694 window_scroll (window
, n
, whole
, noerror
)
4702 /* If we must, use the pixel-based version which is much slower than
4703 the line-based one but can handle varying line heights. */
4704 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4705 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4707 window_scroll_line_based (window
, n
, whole
, noerror
);
4713 /* Implementation of window_scroll that works based on pixel line
4714 heights. See the comment of window_scroll for parameter
4718 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4725 struct window
*w
= XWINDOW (window
);
4726 struct text_pos start
;
4728 int this_scroll_margin
;
4729 /* True if we fiddled the window vscroll field without really scrolling. */
4732 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4734 /* If PT is not visible in WINDOW, move back one half of
4735 the screen. Allow PT to be partially visible, otherwise
4736 something like (scroll-down 1) with PT in the line before
4737 the partially visible one would recenter. */
4738 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4741 /* Move backward half the height of the window. Performance note:
4742 vmotion used here is about 10% faster, but would give wrong
4743 results for variable height lines. */
4744 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4745 it
.current_y
= it
.last_visible_y
;
4746 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4748 /* The function move_iterator_vertically may move over more than
4749 the specified y-distance. If it->w is small, e.g. a
4750 mini-buffer window, we may end up in front of the window's
4751 display area. This is the case when Start displaying at the
4752 start of the line containing PT in this case. */
4753 if (it
.current_y
<= 0)
4755 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4756 move_it_vertically_backward (&it
, 0);
4760 start
= it
.current
.pos
;
4762 else if (auto_window_vscroll_p
)
4764 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4767 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4769 dy
= max ((window_box_height (w
)
4770 - next_screen_context_lines
* dy
),
4774 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4776 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4777 Fset_window_vscroll (window
, make_number (px
), Qt
);
4780 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4782 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4783 Fset_window_vscroll (window
, make_number (px
), Qt
);
4787 Fset_window_vscroll (window
, make_number (0), Qt
);
4790 /* If scroll_preserve_screen_position is non-nil, we try to set
4791 point in the same window line as it is now, so get that line. */
4792 if (!NILP (Vscroll_preserve_screen_position
))
4794 /* We preserve the goal pixel coordinate across consecutive
4795 calls to scroll-up or scroll-down. This avoids the
4796 possibility of point becoming "stuck" on a tall line when
4797 scrolling by one line. */
4798 if (window_scroll_pixel_based_preserve_y
< 0
4799 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
4800 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
4802 start_display (&it
, w
, start
);
4803 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4804 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4808 window_scroll_pixel_based_preserve_y
= -1;
4810 /* Move iterator it from start the specified distance forward or
4811 backward. The result is the new window start. */
4812 start_display (&it
, w
, start
);
4815 int start_pos
= IT_CHARPOS (it
);
4816 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4817 dy
= max ((window_box_height (w
)
4818 - next_screen_context_lines
* dy
),
4821 /* Note that move_it_vertically always moves the iterator to the
4822 start of a line. So, if the last line doesn't have a newline,
4823 we would end up at the start of the line ending at ZV. */
4826 move_it_vertically_backward (&it
, -dy
);
4827 /* Ensure we actually does move, e.g. in case we are currently
4828 looking at an image that is taller that the window height. */
4829 while (start_pos
== IT_CHARPOS (it
)
4830 && start_pos
> BEGV
)
4831 move_it_by_lines (&it
, -1, 1);
4835 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4836 MOVE_TO_POS
| MOVE_TO_Y
);
4837 /* Ensure we actually does move, e.g. in case we are currently
4838 looking at an image that is taller that the window height. */
4839 while (start_pos
== IT_CHARPOS (it
)
4841 move_it_by_lines (&it
, 1, 1);
4845 move_it_by_lines (&it
, n
, 1);
4847 /* We failed if we find ZV is already on the screen (scrolling up,
4848 means there's nothing past the end), or if we can't start any
4849 earlier (scrolling down, means there's nothing past the top). */
4850 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4851 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4853 if (IT_CHARPOS (it
) == ZV
)
4855 if (it
.current_y
< it
.last_visible_y
4856 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4857 >= it
.last_visible_y
))
4859 /* The last line was only partially visible, make it fully
4861 w
->vscroll
= (it
.last_visible_y
4862 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4863 adjust_glyphs (it
.f
);
4868 Fsignal (Qend_of_buffer
, Qnil
);
4872 if (w
->vscroll
!= 0)
4873 /* The first line was only partially visible, make it fully
4879 Fsignal (Qbeginning_of_buffer
, Qnil
);
4882 /* If control gets here, then we vscrolled. */
4884 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4886 /* Don't try to change the window start below. */
4892 int pos
= IT_CHARPOS (it
);
4895 /* If in the middle of a multi-glyph character move forward to
4896 the next character. */
4897 if (in_display_vector_p (&it
))
4900 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4903 /* Set the window start, and set up the window for redisplay. */
4904 set_marker_restricted (w
->start
, make_number (pos
),
4906 bytepos
= XMARKER (w
->start
)->bytepos
;
4907 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4909 w
->update_mode_line
= Qt
;
4910 XSETFASTINT (w
->last_modified
, 0);
4911 XSETFASTINT (w
->last_overlay_modified
, 0);
4912 /* Set force_start so that redisplay_window will run the
4913 window-scroll-functions. */
4914 w
->force_start
= Qt
;
4917 /* The rest of this function uses current_y in a nonstandard way,
4918 not including the height of the header line if any. */
4919 it
.current_y
= it
.vpos
= 0;
4921 /* Move PT out of scroll margins.
4922 This code wants current_y to be zero at the window start position
4923 even if there is a header line. */
4924 this_scroll_margin
= max (0, scroll_margin
);
4925 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4926 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4930 /* We moved the window start towards ZV, so PT may be now
4931 in the scroll margin at the top. */
4932 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4933 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4934 && (NILP (Vscroll_preserve_screen_position
)
4935 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4936 /* We found PT at a legitimate height. Leave it alone. */
4938 else if (window_scroll_pixel_based_preserve_y
>= 0)
4940 /* If we have a header line, take account of it.
4941 This is necessary because we set it.current_y to 0, above. */
4942 move_it_to (&it
, -1, -1,
4943 window_scroll_pixel_based_preserve_y
4944 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4946 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4950 while (it
.current_y
< this_scroll_margin
)
4952 int prev
= it
.current_y
;
4953 move_it_by_lines (&it
, 1, 1);
4954 if (prev
== it
.current_y
)
4957 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4962 int charpos
, bytepos
;
4965 /* Save our position, for the
4966 window_scroll_pixel_based_preserve_y case. */
4967 charpos
= IT_CHARPOS (it
);
4968 bytepos
= IT_BYTEPOS (it
);
4970 /* We moved the window start towards BEGV, so PT may be now
4971 in the scroll margin at the bottom. */
4972 move_it_to (&it
, PT
, -1,
4973 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4974 - this_scroll_margin
- 1),
4976 MOVE_TO_POS
| MOVE_TO_Y
);
4978 /* Save our position, in case it's correct. */
4979 charpos
= IT_CHARPOS (it
);
4980 bytepos
= IT_BYTEPOS (it
);
4982 /* See if point is on a partially visible line at the end. */
4983 if (it
.what
== IT_EOB
)
4984 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4987 move_it_by_lines (&it
, 1, 1);
4988 partial_p
= it
.current_y
> it
.last_visible_y
;
4991 if (charpos
== PT
&& !partial_p
4992 && (NILP (Vscroll_preserve_screen_position
)
4993 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4994 /* We found PT before we found the display margin, so PT is ok. */
4996 else if (window_scroll_pixel_based_preserve_y
>= 0)
4998 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4999 start_display (&it
, w
, start
);
5000 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5001 here because we called start_display again and did not
5002 alter it.current_y this time. */
5003 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5005 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5010 /* The last line was only partially visible, so back up two
5011 lines to make sure we're on a fully visible line. */
5013 move_it_by_lines (&it
, -2, 0);
5014 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5017 /* No, the position we saved is OK, so use it. */
5018 SET_PT_BOTH (charpos
, bytepos
);
5024 /* Implementation of window_scroll that works based on screen lines.
5025 See the comment of window_scroll for parameter descriptions. */
5028 window_scroll_line_based (window
, n
, whole
, noerror
)
5034 register struct window
*w
= XWINDOW (window
);
5035 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5036 register int pos
, pos_byte
;
5037 register int ht
= window_internal_height (w
);
5038 register Lisp_Object tem
;
5042 struct position posit
;
5045 /* If scrolling screen-fulls, compute the number of lines to
5046 scroll from the window's height. */
5048 n
*= max (1, ht
- next_screen_context_lines
);
5050 startpos
= marker_position (w
->start
);
5052 posit
= *compute_motion (startpos
, 0, 0, 0,
5054 -1, XINT (w
->hscroll
),
5056 original_vpos
= posit
.vpos
;
5058 XSETFASTINT (tem
, PT
);
5059 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5063 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5068 lose
= n
< 0 && PT
== BEGV
;
5069 Fvertical_motion (make_number (n
), window
);
5073 SET_PT_BOTH (opoint
, opoint_byte
);
5080 Fsignal (Qbeginning_of_buffer
, Qnil
);
5085 int this_scroll_margin
= scroll_margin
;
5087 /* Don't use a scroll margin that is negative or too large. */
5088 if (this_scroll_margin
< 0)
5089 this_scroll_margin
= 0;
5091 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5092 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5094 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5095 w
->start_at_line_beg
= bolp
;
5096 w
->update_mode_line
= Qt
;
5097 XSETFASTINT (w
->last_modified
, 0);
5098 XSETFASTINT (w
->last_overlay_modified
, 0);
5099 /* Set force_start so that redisplay_window will run
5100 the window-scroll-functions. */
5101 w
->force_start
= Qt
;
5103 if (!NILP (Vscroll_preserve_screen_position
)
5104 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5106 SET_PT_BOTH (pos
, pos_byte
);
5107 Fvertical_motion (make_number (original_vpos
), window
);
5109 /* If we scrolled forward, put point enough lines down
5110 that it is outside the scroll margin. */
5115 if (this_scroll_margin
> 0)
5117 SET_PT_BOTH (pos
, pos_byte
);
5118 Fvertical_motion (make_number (this_scroll_margin
), window
);
5124 if (top_margin
<= opoint
)
5125 SET_PT_BOTH (opoint
, opoint_byte
);
5126 else if (!NILP (Vscroll_preserve_screen_position
))
5128 SET_PT_BOTH (pos
, pos_byte
);
5129 Fvertical_motion (make_number (original_vpos
), window
);
5132 SET_PT (top_margin
);
5138 /* If we scrolled backward, put point near the end of the window
5139 but not within the scroll margin. */
5140 SET_PT_BOTH (pos
, pos_byte
);
5141 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5142 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5145 bottom_margin
= PT
+ 1;
5147 if (bottom_margin
> opoint
)
5148 SET_PT_BOTH (opoint
, opoint_byte
);
5151 if (!NILP (Vscroll_preserve_screen_position
))
5153 SET_PT_BOTH (pos
, pos_byte
);
5154 Fvertical_motion (make_number (original_vpos
), window
);
5157 Fvertical_motion (make_number (-1), window
);
5166 Fsignal (Qend_of_buffer
, Qnil
);
5171 /* Scroll selected_window up or down. If N is nil, scroll a
5172 screen-full which is defined as the height of the window minus
5173 next_screen_context_lines. If N is the symbol `-', scroll.
5174 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5175 up. This is the guts of Fscroll_up and Fscroll_down. */
5178 scroll_command (n
, direction
)
5182 int count
= SPECPDL_INDEX ();
5184 xassert (abs (direction
) == 1);
5186 /* If selected window's buffer isn't current, make it current for
5187 the moment. But don't screw up if window_scroll gets an error. */
5188 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5190 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5191 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5193 /* Make redisplay consider other windows than just selected_window. */
5194 ++windows_or_buffers_changed
;
5198 window_scroll (selected_window
, direction
, 1, 0);
5199 else if (EQ (n
, Qminus
))
5200 window_scroll (selected_window
, -direction
, 1, 0);
5203 n
= Fprefix_numeric_value (n
);
5204 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5207 unbind_to (count
, Qnil
);
5210 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5211 doc
: /* Scroll text of current window upward ARG lines.
5212 If ARG is omitted or nil, scroll upward by a near full screen.
5213 A near full screen is `next-screen-context-lines' less than a full screen.
5214 Negative ARG means scroll downward.
5215 If ARG is the atom `-', scroll downward by nearly full screen.
5216 When calling from a program, supply as argument a number, nil, or `-'. */)
5220 scroll_command (arg
, 1);
5224 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5225 doc
: /* Scroll text of current window down ARG lines.
5226 If ARG is omitted or nil, scroll down by a near full screen.
5227 A near full screen is `next-screen-context-lines' less than a full screen.
5228 Negative ARG means scroll upward.
5229 If ARG is the atom `-', scroll upward by nearly full screen.
5230 When calling from a program, supply as argument a number, nil, or `-'. */)
5234 scroll_command (arg
, -1);
5238 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5239 doc
: /* Return the other window for \"other window scroll\" commands.
5240 If `other-window-scroll-buffer' is non-nil, a window
5241 showing that buffer is used.
5242 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5243 specifies the window. This takes precedence over
5244 `other-window-scroll-buffer'. */)
5249 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5250 && !NILP (Vminibuf_scroll_window
))
5251 window
= Vminibuf_scroll_window
;
5252 /* If buffer is specified, scroll that buffer. */
5253 else if (!NILP (Vother_window_scroll_buffer
))
5255 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5257 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5261 /* Nothing specified; look for a neighboring window on the same
5263 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5265 if (EQ (window
, selected_window
))
5266 /* That didn't get us anywhere; look for a window on another
5269 window
= Fnext_window (window
, Qnil
, Qt
);
5270 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5271 && ! EQ (window
, selected_window
));
5274 CHECK_LIVE_WINDOW (window
);
5276 if (EQ (window
, selected_window
))
5277 error ("There is no other window");
5282 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5283 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5284 A near full screen is `next-screen-context-lines' less than a full screen.
5285 The next window is the one below the current one; or the one at the top
5286 if the current one is at the bottom. Negative ARG means scroll downward.
5287 If ARG is the atom `-', scroll downward by nearly full screen.
5288 When calling from a program, supply as argument a number, nil, or `-'.
5290 If `other-window-scroll-buffer' is non-nil, scroll the window
5291 showing that buffer, popping the buffer up if necessary.
5292 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5293 specifies the window to scroll. This takes precedence over
5294 `other-window-scroll-buffer'. */)
5300 int count
= SPECPDL_INDEX ();
5302 window
= Fother_window_for_scrolling ();
5303 w
= XWINDOW (window
);
5305 /* Don't screw up if window_scroll gets an error. */
5306 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5307 ++windows_or_buffers_changed
;
5309 Fset_buffer (w
->buffer
);
5310 SET_PT (marker_position (w
->pointm
));
5313 window_scroll (window
, 1, 1, 1);
5314 else if (EQ (arg
, Qminus
))
5315 window_scroll (window
, -1, 1, 1);
5321 window_scroll (window
, XINT (arg
), 0, 1);
5324 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5325 unbind_to (count
, Qnil
);
5330 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5331 doc
: /* Scroll selected window display ARG columns left.
5332 Default for ARG is window width minus 2.
5333 Value is the total amount of leftward horizontal scrolling in
5334 effect after the change.
5335 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5336 lower bound for automatic scrolling, i.e. automatic scrolling
5337 will not scroll a window to a column less than the value returned
5338 by this function. This happens in an interactive call. */)
5340 register Lisp_Object arg
, set_minimum
;
5344 struct window
*w
= XWINDOW (selected_window
);
5347 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5349 arg
= Fprefix_numeric_value (arg
);
5351 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5352 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5354 if (!NILP (set_minimum
))
5355 w
->min_hscroll
= w
->hscroll
;
5360 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5361 doc
: /* Scroll selected window display ARG columns right.
5362 Default for ARG is window width minus 2.
5363 Value is the total amount of leftward horizontal scrolling in
5364 effect after the change.
5365 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5366 lower bound for automatic scrolling, i.e. automatic scrolling
5367 will not scroll a window to a column less than the value returned
5368 by this function. This happens in an interactive call. */)
5370 register Lisp_Object arg
, set_minimum
;
5374 struct window
*w
= XWINDOW (selected_window
);
5377 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5379 arg
= Fprefix_numeric_value (arg
);
5381 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5382 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5384 if (!NILP (set_minimum
))
5385 w
->min_hscroll
= w
->hscroll
;
5390 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5391 doc
: /* Return the window which was selected when entering the minibuffer.
5392 Returns nil, if current window is not a minibuffer window. */)
5395 if (minibuf_level
> 0
5396 && MINI_WINDOW_P (XWINDOW (selected_window
))
5397 && WINDOW_LIVE_P (minibuf_selected_window
))
5398 return minibuf_selected_window
;
5403 /* Value is the number of lines actually displayed in window W,
5404 as opposed to its height. */
5407 displayed_window_lines (w
)
5411 struct text_pos start
;
5412 int height
= window_box_height (w
);
5413 struct buffer
*old_buffer
;
5416 if (XBUFFER (w
->buffer
) != current_buffer
)
5418 old_buffer
= current_buffer
;
5419 set_buffer_internal (XBUFFER (w
->buffer
));
5424 /* In case W->start is out of the accessible range, do something
5425 reasonable. This happens in Info mode when Info-scroll-down
5426 calls (recenter -1) while W->start is 1. */
5427 if (XMARKER (w
->start
)->charpos
< BEGV
)
5428 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5429 else if (XMARKER (w
->start
)->charpos
> ZV
)
5430 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5432 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5434 start_display (&it
, w
, start
);
5435 move_it_vertically (&it
, height
);
5436 bottom_y
= line_bottom_y (&it
);
5438 /* rms: On a non-window display,
5439 the value of it.vpos at the bottom of the screen
5440 seems to be 1 larger than window_box_height (w).
5441 This kludge fixes a bug whereby (move-to-window-line -1)
5442 when ZV is on the last screen line
5443 moves to the previous screen line instead of the last one. */
5444 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5447 /* Add in empty lines at the bottom of the window. */
5448 if (bottom_y
< height
)
5450 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5451 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5455 set_buffer_internal (old_buffer
);
5461 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5462 doc
: /* Center point in window and redisplay frame.
5463 With prefix argument ARG, recenter putting point on screen line ARG
5464 relative to the current window. If ARG is negative, it counts up from the
5465 bottom of the window. (ARG should be less than the height of the window.)
5467 If ARG is omitted or nil, erase the entire frame and then
5468 redraw with point in the center of the current window.
5469 Just C-u as prefix means put point in the center of the window
5470 and redisplay normally--don't erase and redraw the frame. */)
5472 register Lisp_Object arg
;
5474 struct window
*w
= XWINDOW (selected_window
);
5475 struct buffer
*buf
= XBUFFER (w
->buffer
);
5476 struct buffer
*obuf
= current_buffer
;
5478 int charpos
, bytepos
;
5480 int this_scroll_margin
;
5482 /* If redisplay is suppressed due to an error, try again. */
5483 obuf
->display_error_modiff
= 0;
5489 /* Invalidate pixel data calculated for all compositions. */
5490 for (i
= 0; i
< n_compositions
; i
++)
5491 composition_table
[i
]->font
= NULL
;
5493 Fredraw_frame (w
->frame
);
5494 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5497 else if (CONSP (arg
)) /* Just C-u. */
5501 arg
= Fprefix_numeric_value (arg
);
5506 set_buffer_internal (buf
);
5508 /* Do this after making BUF current
5509 in case scroll_margin is buffer-local. */
5510 this_scroll_margin
= max (0, scroll_margin
);
5511 this_scroll_margin
= min (this_scroll_margin
,
5512 XFASTINT (w
->total_lines
) / 4);
5514 /* Handle centering on a graphical frame specially. Such frames can
5515 have variable-height lines and centering point on the basis of
5516 line counts would lead to strange effects. */
5517 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5524 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5525 start_display (&it
, w
, pt
);
5526 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5527 charpos
= IT_CHARPOS (it
);
5528 bytepos
= IT_BYTEPOS (it
);
5535 int extra_line_spacing
;
5536 int h
= window_box_height (w
);
5538 iarg
= - max (-iarg
, this_scroll_margin
);
5540 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5541 start_display (&it
, w
, pt
);
5543 /* Be sure we have the exact height of the full line containing PT. */
5544 move_it_by_lines (&it
, 0, 1);
5546 /* The amount of pixels we have to move back is the window
5547 height minus what's displayed in the line containing PT,
5548 and the lines below. */
5551 move_it_by_lines (&it
, nlines
, 1);
5553 if (it
.vpos
== nlines
)
5557 /* Last line has no newline */
5558 h
-= line_bottom_y (&it
);
5562 /* Don't reserve space for extra line spacing of last line. */
5563 extra_line_spacing
= it
.max_extra_line_spacing
;
5565 /* If we can't move down NLINES lines because we hit
5566 the end of the buffer, count in some empty lines. */
5567 if (it
.vpos
< nlines
)
5570 extra_line_spacing
= it
.extra_line_spacing
;
5571 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5576 /* Now find the new top line (starting position) of the window. */
5577 start_display (&it
, w
, pt
);
5579 move_it_vertically_backward (&it
, h
);
5581 /* If extra line spacing is present, we may move too far
5582 back. This causes the last line to be only partially
5583 visible (which triggers redisplay to recenter that line
5584 in the middle), so move forward.
5585 But ignore extra line spacing on last line, as it is not
5586 considered to be part of the visible height of the line.
5588 h
+= extra_line_spacing
;
5589 while (-it
.current_y
> h
)
5590 move_it_by_lines (&it
, 1, 1);
5592 charpos
= IT_CHARPOS (it
);
5593 bytepos
= IT_BYTEPOS (it
);
5597 struct position pos
;
5599 iarg
= max (iarg
, this_scroll_margin
);
5601 pos
= *vmotion (PT
, -iarg
, w
);
5602 charpos
= pos
.bufpos
;
5603 bytepos
= pos
.bytepos
;
5608 struct position pos
;
5609 int ht
= window_internal_height (w
);
5616 /* Don't let it get into the margin at either top or bottom. */
5617 iarg
= max (iarg
, this_scroll_margin
);
5618 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5620 pos
= *vmotion (PT
, - iarg
, w
);
5621 charpos
= pos
.bufpos
;
5622 bytepos
= pos
.bytepos
;
5625 /* Set the new window start. */
5626 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5627 w
->window_end_valid
= Qnil
;
5629 w
->optional_new_start
= Qt
;
5631 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5632 w
->start_at_line_beg
= Qt
;
5634 w
->start_at_line_beg
= Qnil
;
5636 set_buffer_internal (obuf
);
5641 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5643 doc
: /* Return the height in lines of the text display area of WINDOW.
5644 This doesn't include the mode-line (or header-line if any) or any
5645 partial-height lines in the text display area. */)
5649 struct window
*w
= decode_window (window
);
5650 int pixel_height
= window_box_height (w
);
5651 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5652 return make_number (line_height
);
5657 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5659 doc
: /* Position point relative to window.
5660 With no argument, position point at center of window.
5661 An argument specifies vertical position within the window;
5662 zero means top of window, negative means relative to bottom of window. */)
5666 struct window
*w
= XWINDOW (selected_window
);
5670 int this_scroll_margin
;
5673 window
= selected_window
;
5674 start
= marker_position (w
->start
);
5675 if (start
< BEGV
|| start
> ZV
)
5677 int height
= window_internal_height (w
);
5678 Fvertical_motion (make_number (- (height
/ 2)), window
);
5679 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5680 w
->start_at_line_beg
= Fbolp ();
5681 w
->force_start
= Qt
;
5684 Fgoto_char (w
->start
);
5686 lines
= displayed_window_lines (w
);
5689 this_scroll_margin
= max (0, scroll_margin
);
5690 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5694 XSETFASTINT (arg
, lines
/ 2);
5697 int iarg
= XINT (Fprefix_numeric_value (arg
));
5700 iarg
= iarg
+ lines
;
5702 #if 0 /* This code would prevent move-to-window-line from moving point
5703 to a place inside the scroll margins (which would cause the
5704 next redisplay to scroll). I wrote this code, but then concluded
5705 it is probably better not to install it. However, it is here
5706 inside #if 0 so as not to lose it. -- rms. */
5708 /* Don't let it get into the margin at either top or bottom. */
5709 iarg
= max (iarg
, this_scroll_margin
);
5710 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5713 arg
= make_number (iarg
);
5716 /* Skip past a partially visible first line. */
5718 XSETINT (arg
, XINT (arg
) + 1);
5720 return Fvertical_motion (arg
, window
);
5725 /***********************************************************************
5726 Window Configuration
5727 ***********************************************************************/
5729 struct save_window_data
5731 EMACS_INT size_from_Lisp_Vector_struct
;
5732 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5733 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5734 Lisp_Object frame_tool_bar_lines
;
5735 Lisp_Object selected_frame
;
5736 Lisp_Object current_window
;
5737 Lisp_Object current_buffer
;
5738 Lisp_Object minibuf_scroll_window
;
5739 Lisp_Object minibuf_selected_window
;
5740 Lisp_Object root_window
;
5741 Lisp_Object focus_frame
;
5742 /* Record the values of window-min-width and window-min-height
5743 so that window sizes remain consistent with them. */
5744 Lisp_Object min_width
, min_height
;
5745 /* A vector, each of whose elements is a struct saved_window
5747 Lisp_Object saved_windows
;
5750 /* This is saved as a Lisp_Vector */
5753 /* these first two must agree with struct Lisp_Vector in lisp.h */
5754 EMACS_INT size_from_Lisp_Vector_struct
;
5755 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5758 Lisp_Object buffer
, start
, pointm
, mark
;
5759 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5760 Lisp_Object hscroll
, min_hscroll
;
5761 Lisp_Object parent
, prev
;
5762 Lisp_Object start_at_line_beg
;
5763 Lisp_Object display_table
;
5764 Lisp_Object orig_top_line
, orig_total_lines
;
5765 Lisp_Object left_margin_cols
, right_margin_cols
;
5766 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5767 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5770 #define SAVED_WINDOW_N(swv,n) \
5771 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5773 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5774 doc
: /* Return t if OBJECT is a window-configuration object. */)
5778 if (WINDOW_CONFIGURATIONP (object
))
5783 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5784 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5788 register struct save_window_data
*data
;
5789 struct Lisp_Vector
*saved_windows
;
5791 if (! WINDOW_CONFIGURATIONP (config
))
5792 wrong_type_argument (Qwindow_configuration_p
, config
);
5794 data
= (struct save_window_data
*) XVECTOR (config
);
5795 saved_windows
= XVECTOR (data
->saved_windows
);
5796 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5799 DEFUN ("set-window-configuration", Fset_window_configuration
,
5800 Sset_window_configuration
, 1, 1, 0,
5801 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5802 CONFIGURATION must be a value previously returned
5803 by `current-window-configuration' (which see).
5804 If CONFIGURATION was made from a frame that is now deleted,
5805 only frame-independent values can be restored. In this case,
5806 the return value is nil. Otherwise the value is t. */)
5808 Lisp_Object configuration
;
5810 register struct save_window_data
*data
;
5811 struct Lisp_Vector
*saved_windows
;
5812 Lisp_Object new_current_buffer
;
5817 while (!WINDOW_CONFIGURATIONP (configuration
))
5818 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5820 data
= (struct save_window_data
*) XVECTOR (configuration
);
5821 saved_windows
= XVECTOR (data
->saved_windows
);
5823 new_current_buffer
= data
->current_buffer
;
5824 if (NILP (XBUFFER (new_current_buffer
)->name
))
5825 new_current_buffer
= Qnil
;
5828 if (XBUFFER (new_current_buffer
) == current_buffer
)
5829 /* The code further down "preserves point" by saving here PT in
5830 old_point and then setting it later back into PT. When the
5831 current-selected-window and the final-selected-window both show
5832 the current buffer, this suffers from the problem that the
5833 current PT is the window-point of the current-selected-window,
5834 while the final PT is the point of the final-selected-window, so
5835 this copy from one PT to the other would end up moving the
5836 window-point of the final-selected-window to the window-point of
5837 the current-selected-window. So we have to be careful which
5838 point of the current-buffer we copy into old_point. */
5839 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5840 && WINDOWP (selected_window
)
5841 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5842 && !EQ (selected_window
, data
->current_window
))
5843 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5847 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5848 point in new_current_buffer as of the last time this buffer was
5849 used. This can be non-deterministic since it can be changed by
5850 things like jit-lock by mere temporary selection of some random
5851 window that happens to show this buffer.
5852 So if possible we want this arbitrary choice of "which point" to
5853 be the one from the to-be-selected-window so as to prevent this
5854 window's cursor from being copied from another window. */
5855 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5856 /* If current_window = selected_window, its point is in BUF_PT. */
5857 && !EQ (selected_window
, data
->current_window
))
5858 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5860 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5863 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5866 /* If f is a dead frame, don't bother rebuilding its window tree.
5867 However, there is other stuff we should still try to do below. */
5868 if (FRAME_LIVE_P (f
))
5870 register struct window
*w
;
5871 register struct saved_window
*p
;
5872 struct window
*root_window
;
5873 struct window
**leaf_windows
;
5877 /* If the frame has been resized since this window configuration was
5878 made, we change the frame to the size specified in the
5879 configuration, restore the configuration, and then resize it
5880 back. We keep track of the prevailing height in these variables. */
5881 int previous_frame_lines
= FRAME_LINES (f
);
5882 int previous_frame_cols
= FRAME_COLS (f
);
5883 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5884 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5886 /* The mouse highlighting code could get screwed up
5887 if it runs during this. */
5890 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5891 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5892 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5893 XFASTINT (data
->frame_cols
), 0, 0, 0);
5894 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5895 if (XFASTINT (data
->frame_menu_bar_lines
)
5896 != previous_frame_menu_bar_lines
)
5897 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5898 #ifdef HAVE_WINDOW_SYSTEM
5899 if (XFASTINT (data
->frame_tool_bar_lines
)
5900 != previous_frame_tool_bar_lines
)
5901 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5905 /* "Swap out" point from the selected window's buffer
5906 into the window itself. (Normally the pointm of the selected
5907 window holds garbage.) We do this now, before
5908 restoring the window contents, and prevent it from
5909 being done later on when we select a new window. */
5910 if (! NILP (XWINDOW (selected_window
)->buffer
))
5912 w
= XWINDOW (selected_window
);
5913 set_marker_both (w
->pointm
,
5915 BUF_PT (XBUFFER (w
->buffer
)),
5916 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5919 windows_or_buffers_changed
++;
5920 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5922 /* Problem: Freeing all matrices and later allocating them again
5923 is a serious redisplay flickering problem. What we would
5924 really like to do is to free only those matrices not reused
5926 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5928 = (struct window
**) alloca (count_windows (root_window
)
5929 * sizeof (struct window
*));
5930 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5932 /* Temporarily avoid any problems with windows that are smaller
5933 than they are supposed to be. */
5934 window_min_height
= 1;
5935 window_min_width
= 1;
5938 Mark all windows now on frame as "deleted".
5939 Restoring the new configuration "undeletes" any that are in it.
5941 Save their current buffers in their height fields, since we may
5942 need it later, if a buffer saved in the configuration is now
5944 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5946 for (k
= 0; k
< saved_windows
->size
; k
++)
5948 p
= SAVED_WINDOW_N (saved_windows
, k
);
5949 w
= XWINDOW (p
->window
);
5952 if (!NILP (p
->parent
))
5953 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5954 XFASTINT (p
->parent
))->window
;
5958 if (!NILP (p
->prev
))
5960 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5961 XFASTINT (p
->prev
))->window
;
5962 XWINDOW (w
->prev
)->next
= p
->window
;
5967 if (!NILP (w
->parent
))
5969 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5971 XWINDOW (w
->parent
)->vchild
= p
->window
;
5972 XWINDOW (w
->parent
)->hchild
= Qnil
;
5976 XWINDOW (w
->parent
)->hchild
= p
->window
;
5977 XWINDOW (w
->parent
)->vchild
= Qnil
;
5982 /* If we squirreled away the buffer in the window's height,
5984 if (BUFFERP (w
->total_lines
))
5985 w
->buffer
= w
->total_lines
;
5986 w
->left_col
= p
->left_col
;
5987 w
->top_line
= p
->top_line
;
5988 w
->total_cols
= p
->total_cols
;
5989 w
->total_lines
= p
->total_lines
;
5990 w
->hscroll
= p
->hscroll
;
5991 w
->min_hscroll
= p
->min_hscroll
;
5992 w
->display_table
= p
->display_table
;
5993 w
->orig_top_line
= p
->orig_top_line
;
5994 w
->orig_total_lines
= p
->orig_total_lines
;
5995 w
->left_margin_cols
= p
->left_margin_cols
;
5996 w
->right_margin_cols
= p
->right_margin_cols
;
5997 w
->left_fringe_width
= p
->left_fringe_width
;
5998 w
->right_fringe_width
= p
->right_fringe_width
;
5999 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6000 w
->scroll_bar_width
= p
->scroll_bar_width
;
6001 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6002 XSETFASTINT (w
->last_modified
, 0);
6003 XSETFASTINT (w
->last_overlay_modified
, 0);
6005 /* Reinstall the saved buffer and pointers into it. */
6006 if (NILP (p
->buffer
))
6007 w
->buffer
= p
->buffer
;
6010 if (!NILP (XBUFFER (p
->buffer
)->name
))
6011 /* If saved buffer is alive, install it. */
6013 w
->buffer
= p
->buffer
;
6014 w
->start_at_line_beg
= p
->start_at_line_beg
;
6015 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6016 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6017 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6018 p
->mark
, w
->buffer
);
6020 /* As documented in Fcurrent_window_configuration, don't
6021 restore the location of point in the buffer which was
6022 current when the window configuration was recorded. */
6023 if (!EQ (p
->buffer
, new_current_buffer
)
6024 && XBUFFER (p
->buffer
) == current_buffer
)
6025 Fgoto_char (w
->pointm
);
6027 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6028 /* Else unless window has a live buffer, get one. */
6030 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6031 /* This will set the markers to beginning of visible
6033 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6034 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6035 w
->start_at_line_beg
= Qt
;
6038 /* Keeping window's old buffer; make sure the markers
6041 /* Set window markers at start of visible range. */
6042 if (XMARKER (w
->start
)->buffer
== 0)
6043 set_marker_restricted (w
->start
, make_number (0),
6045 if (XMARKER (w
->pointm
)->buffer
== 0)
6046 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6047 BUF_PT (XBUFFER (w
->buffer
)),
6048 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6049 w
->start_at_line_beg
= Qt
;
6054 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6055 /* Prevent "swapping out point" in the old selected window
6056 using the buffer that has been restored into it.
6057 We already swapped out point that from that window's old buffer. */
6058 selected_window
= Qnil
;
6060 /* Arrange *not* to restore point in the buffer that was
6061 current when the window configuration was saved. */
6062 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6063 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6064 make_number (old_point
),
6065 XWINDOW (data
->current_window
)->buffer
);
6067 Fselect_window (data
->current_window
, Qnil
);
6068 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6071 if (NILP (data
->focus_frame
)
6072 || (FRAMEP (data
->focus_frame
)
6073 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6074 Fredirect_frame_focus (frame
, data
->focus_frame
);
6076 #if 0 /* I don't understand why this is needed, and it causes problems
6077 when the frame's old selected window has been deleted. */
6078 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6079 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6083 /* Set the screen height to the value it had before this function. */
6084 if (previous_frame_lines
!= FRAME_LINES (f
)
6085 || previous_frame_cols
!= FRAME_COLS (f
))
6086 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6088 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6089 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6090 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6092 #ifdef HAVE_WINDOW_SYSTEM
6093 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6094 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6099 /* Now, free glyph matrices in windows that were not reused. */
6100 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6102 if (NILP (leaf_windows
[i
]->buffer
))
6104 /* Assert it's not reused as a combination. */
6105 xassert (NILP (leaf_windows
[i
]->hchild
)
6106 && NILP (leaf_windows
[i
]->vchild
));
6107 free_window_matrices (leaf_windows
[i
]);
6109 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6117 /* Fselect_window will have made f the selected frame, so we
6118 reselect the proper frame here. Fhandle_switch_frame will change the
6119 selected window too, but that doesn't make the call to
6120 Fselect_window above totally superfluous; it still sets f's
6122 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6123 do_switch_frame (data
->selected_frame
, 0, 0);
6125 if (! NILP (Vwindow_configuration_change_hook
)
6126 && ! NILP (Vrun_hooks
))
6127 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6130 if (!NILP (new_current_buffer
))
6131 Fset_buffer (new_current_buffer
);
6133 /* Restore the minimum heights recorded in the configuration. */
6134 window_min_height
= XINT (data
->min_height
);
6135 window_min_width
= XINT (data
->min_width
);
6137 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6138 minibuf_selected_window
= data
->minibuf_selected_window
;
6140 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6143 /* Mark all windows now on frame as deleted
6144 by setting their buffers to nil. */
6147 delete_all_subwindows (w
)
6148 register struct window
*w
;
6150 if (!NILP (w
->next
))
6151 delete_all_subwindows (XWINDOW (w
->next
));
6152 if (!NILP (w
->vchild
))
6153 delete_all_subwindows (XWINDOW (w
->vchild
));
6154 if (!NILP (w
->hchild
))
6155 delete_all_subwindows (XWINDOW (w
->hchild
));
6157 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6159 if (!NILP (w
->buffer
))
6162 /* We set all three of these fields to nil, to make sure that we can
6163 distinguish this dead window from any live window. Live leaf
6164 windows will have buffer set, and combination windows will have
6165 vchild or hchild set. */
6170 Vwindow_list
= Qnil
;
6174 count_windows (window
)
6175 register struct window
*window
;
6177 register int count
= 1;
6178 if (!NILP (window
->next
))
6179 count
+= count_windows (XWINDOW (window
->next
));
6180 if (!NILP (window
->vchild
))
6181 count
+= count_windows (XWINDOW (window
->vchild
));
6182 if (!NILP (window
->hchild
))
6183 count
+= count_windows (XWINDOW (window
->hchild
));
6188 /* Fill vector FLAT with leaf windows under W, starting at index I.
6189 Value is last index + 1. */
6192 get_leaf_windows (w
, flat
, i
)
6194 struct window
**flat
;
6199 if (!NILP (w
->hchild
))
6200 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6201 else if (!NILP (w
->vchild
))
6202 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6206 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6213 /* Return a pointer to the glyph W's physical cursor is on. Value is
6214 null if W's current matrix is invalid, so that no meaningfull glyph
6218 get_phys_cursor_glyph (w
)
6221 struct glyph_row
*row
;
6222 struct glyph
*glyph
;
6224 if (w
->phys_cursor
.vpos
>= 0
6225 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6226 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6228 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6229 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6238 save_window_save (window
, vector
, i
)
6240 struct Lisp_Vector
*vector
;
6243 register struct saved_window
*p
;
6244 register struct window
*w
;
6245 register Lisp_Object tem
;
6247 for (;!NILP (window
); window
= w
->next
)
6249 p
= SAVED_WINDOW_N (vector
, i
);
6250 w
= XWINDOW (window
);
6252 XSETFASTINT (w
->temslot
, i
); i
++;
6254 p
->buffer
= w
->buffer
;
6255 p
->left_col
= w
->left_col
;
6256 p
->top_line
= w
->top_line
;
6257 p
->total_cols
= w
->total_cols
;
6258 p
->total_lines
= w
->total_lines
;
6259 p
->hscroll
= w
->hscroll
;
6260 p
->min_hscroll
= w
->min_hscroll
;
6261 p
->display_table
= w
->display_table
;
6262 p
->orig_top_line
= w
->orig_top_line
;
6263 p
->orig_total_lines
= w
->orig_total_lines
;
6264 p
->left_margin_cols
= w
->left_margin_cols
;
6265 p
->right_margin_cols
= w
->right_margin_cols
;
6266 p
->left_fringe_width
= w
->left_fringe_width
;
6267 p
->right_fringe_width
= w
->right_fringe_width
;
6268 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6269 p
->scroll_bar_width
= w
->scroll_bar_width
;
6270 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6271 if (!NILP (w
->buffer
))
6273 /* Save w's value of point in the window configuration.
6274 If w is the selected window, then get the value of point
6275 from the buffer; pointm is garbage in the selected window. */
6276 if (EQ (window
, selected_window
))
6278 p
->pointm
= Fmake_marker ();
6279 set_marker_both (p
->pointm
, w
->buffer
,
6280 BUF_PT (XBUFFER (w
->buffer
)),
6281 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6284 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6286 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6287 p
->start_at_line_beg
= w
->start_at_line_beg
;
6289 tem
= XBUFFER (w
->buffer
)->mark
;
6290 p
->mark
= Fcopy_marker (tem
, Qnil
);
6297 p
->start_at_line_beg
= Qnil
;
6300 if (NILP (w
->parent
))
6303 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6308 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6310 if (!NILP (w
->vchild
))
6311 i
= save_window_save (w
->vchild
, vector
, i
);
6312 if (!NILP (w
->hchild
))
6313 i
= save_window_save (w
->hchild
, vector
, i
);
6319 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6320 Scurrent_window_configuration
, 0, 1, 0,
6321 doc
: /* Return an object representing the current window configuration of FRAME.
6322 If FRAME is nil or omitted, use the selected frame.
6323 This describes the number of windows, their sizes and current buffers,
6324 and for each displayed buffer, where display starts, and the positions of
6325 point and mark. An exception is made for point in the current buffer:
6326 its value is -not- saved.
6327 This also records the currently selected frame, and FRAME's focus
6328 redirection (see `redirect-frame-focus'). */)
6332 register Lisp_Object tem
;
6333 register int n_windows
;
6334 register struct save_window_data
*data
;
6335 register struct Lisp_Vector
*vec
;
6340 frame
= selected_frame
;
6341 CHECK_LIVE_FRAME (frame
);
6344 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6345 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6346 data
= (struct save_window_data
*)vec
;
6348 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6349 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6350 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6351 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6352 data
->selected_frame
= selected_frame
;
6353 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6354 XSETBUFFER (data
->current_buffer
, current_buffer
);
6355 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6356 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6357 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6358 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6359 XSETINT (data
->min_height
, window_min_height
);
6360 XSETINT (data
->min_width
, window_min_width
);
6361 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6362 data
->saved_windows
= tem
;
6363 for (i
= 0; i
< n_windows
; i
++)
6364 XVECTOR (tem
)->contents
[i
]
6365 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6366 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6367 XSETWINDOW_CONFIGURATION (tem
, data
);
6371 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6373 doc
: /* Execute BODY, preserving window sizes and contents.
6374 Return the value of the last form in BODY.
6375 Restore which buffer appears in which window, where display starts,
6376 and the value of point and mark for each window.
6377 Also restore the choice of selected window.
6378 Also restore which buffer is current.
6379 Does not restore the value of point in current buffer.
6380 usage: (save-window-excursion BODY ...) */)
6384 register Lisp_Object val
;
6385 register int count
= SPECPDL_INDEX ();
6387 record_unwind_protect (Fset_window_configuration
,
6388 Fcurrent_window_configuration (Qnil
));
6389 val
= Fprogn (args
);
6390 return unbind_to (count
, val
);
6395 /***********************************************************************
6397 ***********************************************************************/
6403 Lisp_Object tail
= Qnil
;
6404 Lisp_Object result
= Qnil
;
6411 if (!NILP (w
->hchild
))
6412 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6413 window_tree (XWINDOW (w
->hchild
))));
6414 else if (!NILP (w
->vchild
))
6415 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6416 window_tree (XWINDOW (w
->vchild
))));
6420 result
= tail
= Fcons (wn
, Qnil
);
6424 XSETCDR (tail
, Fcons (wn
, Qnil
));
6428 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6436 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6438 doc
: /* Return the window tree for frame FRAME.
6440 The return value is a list of the form (ROOT MINI), where ROOT
6441 represents the window tree of the frame's root window, and MINI
6442 is the frame's minibuffer window.
6444 If the root window is not split, ROOT is the root window itself.
6445 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6446 horizontal split, and t for a vertical split, EDGES gives the combined
6447 size and position of the subwindows in the split, and the rest of the
6448 elements are the subwindows in the split. Each of the subwindows may
6449 again be a window or a list representing a window split, and so on.
6450 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6452 If FRAME is nil or omitted, return information on the currently
6460 frame
= selected_frame
;
6462 CHECK_FRAME (frame
);
6465 if (!FRAME_LIVE_P (f
))
6468 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6472 /***********************************************************************
6474 ***********************************************************************/
6476 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6478 doc
: /* Set width of marginal areas of window WINDOW.
6479 If WINDOW is nil, set margins of the currently selected window.
6480 Second arg LEFT-WIDTH specifies the number of character cells to
6481 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6482 does the same for the right marginal area. A nil width parameter
6483 means no margin. */)
6484 (window
, left_width
, right_width
)
6485 Lisp_Object window
, left_width
, right_width
;
6487 struct window
*w
= decode_window (window
);
6489 /* Translate negative or zero widths to nil.
6490 Margins that are too wide have to be checked elsewhere. */
6492 if (!NILP (left_width
))
6494 CHECK_NUMBER (left_width
);
6495 if (XINT (left_width
) <= 0)
6499 if (!NILP (right_width
))
6501 CHECK_NUMBER (right_width
);
6502 if (XINT (right_width
) <= 0)
6506 if (!EQ (w
->left_margin_cols
, left_width
)
6507 || !EQ (w
->right_margin_cols
, right_width
))
6509 w
->left_margin_cols
= left_width
;
6510 w
->right_margin_cols
= right_width
;
6512 adjust_window_margins (w
);
6514 ++windows_or_buffers_changed
;
6515 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6522 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6524 doc
: /* Get width of marginal areas of window WINDOW.
6525 If WINDOW is omitted or nil, use the currently selected window.
6526 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6527 If a marginal area does not exist, its width will be returned
6532 struct window
*w
= decode_window (window
);
6533 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6538 /***********************************************************************
6540 ***********************************************************************/
6542 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6544 doc
: /* Set the fringe widths of window WINDOW.
6545 If WINDOW is nil, set the fringe widths of the currently selected
6547 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6548 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6549 fringe width. If a fringe width arg is nil, that means to use the
6550 frame's default fringe width. Default fringe widths can be set with
6551 the command `set-fringe-style'.
6552 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6553 outside of the display margins. By default, fringes are drawn between
6554 display marginal areas and the text area. */)
6555 (window
, left_width
, right_width
, outside_margins
)
6556 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6558 struct window
*w
= decode_window (window
);
6560 if (!NILP (left_width
))
6561 CHECK_NATNUM (left_width
);
6562 if (!NILP (right_width
))
6563 CHECK_NATNUM (right_width
);
6565 if (!EQ (w
->left_fringe_width
, left_width
)
6566 || !EQ (w
->right_fringe_width
, right_width
)
6567 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6569 w
->left_fringe_width
= left_width
;
6570 w
->right_fringe_width
= right_width
;
6571 w
->fringes_outside_margins
= outside_margins
;
6573 adjust_window_margins (w
);
6575 clear_glyph_matrix (w
->current_matrix
);
6576 w
->window_end_valid
= Qnil
;
6578 ++windows_or_buffers_changed
;
6579 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6586 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6588 doc
: /* Get width of fringes of window WINDOW.
6589 If WINDOW is omitted or nil, use the currently selected window.
6590 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6594 struct window
*w
= decode_window (window
);
6595 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6596 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6597 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6598 Qt
: Qnil
), Qnil
)));
6603 /***********************************************************************
6605 ***********************************************************************/
6607 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6609 doc
: /* Set width and type of scroll bars of window WINDOW.
6610 If window is nil, set scroll bars of the currently selected window.
6611 Second parameter WIDTH specifies the pixel width for the scroll bar;
6612 this is automatically adjusted to a multiple of the frame column width.
6613 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6614 bar: left, right, or nil.
6615 If WIDTH is nil, use the frame's scroll-bar width.
6616 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6617 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6618 (window
, width
, vertical_type
, horizontal_type
)
6619 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6621 struct window
*w
= decode_window (window
);
6625 CHECK_NATNUM (width
);
6627 if (XINT (width
) == 0)
6628 vertical_type
= Qnil
;
6631 if (!(EQ (vertical_type
, Qnil
)
6632 || EQ (vertical_type
, Qleft
)
6633 || EQ (vertical_type
, Qright
)
6634 || EQ (vertical_type
, Qt
)))
6635 error ("Invalid type of vertical scroll bar");
6637 if (!EQ (w
->scroll_bar_width
, width
)
6638 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6640 w
->scroll_bar_width
= width
;
6641 w
->vertical_scroll_bar_type
= vertical_type
;
6643 adjust_window_margins (w
);
6645 clear_glyph_matrix (w
->current_matrix
);
6646 w
->window_end_valid
= Qnil
;
6648 ++windows_or_buffers_changed
;
6649 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6656 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6658 doc
: /* Get width and type of scroll bars of window WINDOW.
6659 If WINDOW is omitted or nil, use the currently selected window.
6660 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6661 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6666 struct window
*w
= decode_window (window
);
6667 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6668 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6669 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6670 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6671 Fcons (w
->vertical_scroll_bar_type
,
6672 Fcons (Qnil
, Qnil
))));
6677 /***********************************************************************
6679 ***********************************************************************/
6681 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6682 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6683 Use the selected window if WINDOW is nil or omitted.
6684 Normally, value is a multiple of the canonical character height of WINDOW;
6685 optional second arg PIXELS-P means value is measured in pixels. */)
6687 Lisp_Object window
, pixels_p
;
6694 window
= selected_window
;
6696 CHECK_WINDOW (window
);
6697 w
= XWINDOW (window
);
6698 f
= XFRAME (w
->frame
);
6700 if (FRAME_WINDOW_P (f
))
6701 result
= (NILP (pixels_p
)
6702 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6703 : make_number (-w
->vscroll
));
6705 result
= make_number (0);
6710 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6712 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6713 WINDOW nil means use the selected window. Normally, VSCROLL is a
6714 non-negative multiple of the canonical character height of WINDOW;
6715 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6716 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6717 corresponds to an integral number of pixels. The return value is the
6718 result of this rounding.
6719 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6720 (window
, vscroll
, pixels_p
)
6721 Lisp_Object window
, vscroll
, pixels_p
;
6727 window
= selected_window
;
6729 CHECK_WINDOW (window
);
6730 CHECK_NUMBER_OR_FLOAT (vscroll
);
6732 w
= XWINDOW (window
);
6733 f
= XFRAME (w
->frame
);
6735 if (FRAME_WINDOW_P (f
))
6737 int old_dy
= w
->vscroll
;
6739 w
->vscroll
= - (NILP (pixels_p
)
6740 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6741 : XFLOATINT (vscroll
));
6742 w
->vscroll
= min (w
->vscroll
, 0);
6744 if (w
->vscroll
!= old_dy
)
6746 /* Adjust glyph matrix of the frame if the virtual display
6747 area becomes larger than before. */
6748 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6751 /* Prevent redisplay shortcuts. */
6752 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6756 return Fwindow_vscroll (window
, pixels_p
);
6760 /* Call FN for all leaf windows on frame F. FN is called with the
6761 first argument being a pointer to the leaf window, and with
6762 additional argument USER_DATA. Stops when FN returns 0. */
6765 foreach_window (f
, fn
, user_data
)
6767 int (* fn
) P_ ((struct window
*, void *));
6770 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6774 /* Helper function for foreach_window. Call FN for all leaf windows
6775 reachable from W. FN is called with the first argument being a
6776 pointer to the leaf window, and with additional argument USER_DATA.
6777 Stop when FN returns 0. Value is 0 if stopped by FN. */
6780 foreach_window_1 (w
, fn
, user_data
)
6782 int (* fn
) P_ ((struct window
*, void *));
6787 for (cont
= 1; w
&& cont
;)
6789 if (!NILP (w
->hchild
))
6790 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6791 else if (!NILP (w
->vchild
))
6792 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6794 cont
= fn (w
, user_data
);
6796 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6803 /* Freeze or unfreeze the window start of W unless it is a
6804 mini-window or the selected window. FREEZE_P non-null means freeze
6805 the window start. */
6808 freeze_window_start (w
, freeze_p
)
6812 if (w
== XWINDOW (selected_window
)
6813 || MINI_WINDOW_P (w
)
6814 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6815 && ! NILP (Vminibuf_scroll_window
)
6816 && w
== XWINDOW (Vminibuf_scroll_window
)))
6819 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6824 /* Freeze or unfreeze the window starts of all leaf windows on frame
6825 F, except the selected window and a mini-window. FREEZE_P non-zero
6826 means freeze the window start. */
6829 freeze_window_starts (f
, freeze_p
)
6833 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6837 /***********************************************************************
6839 ***********************************************************************/
6841 /* Return 1 if window configurations C1 and C2
6842 describe the same state of affairs. This is used by Fequal. */
6845 compare_window_configurations (c1
, c2
, ignore_positions
)
6847 int ignore_positions
;
6849 register struct save_window_data
*d1
, *d2
;
6850 struct Lisp_Vector
*sw1
, *sw2
;
6853 if (!WINDOW_CONFIGURATIONP (c1
))
6854 wrong_type_argument (Qwindow_configuration_p
, c1
);
6855 if (!WINDOW_CONFIGURATIONP (c2
))
6856 wrong_type_argument (Qwindow_configuration_p
, c2
);
6858 d1
= (struct save_window_data
*) XVECTOR (c1
);
6859 d2
= (struct save_window_data
*) XVECTOR (c2
);
6860 sw1
= XVECTOR (d1
->saved_windows
);
6861 sw2
= XVECTOR (d2
->saved_windows
);
6863 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6865 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6867 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6869 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6871 /* Don't compare the current_window field directly.
6872 Instead see w1_is_current and w2_is_current, below. */
6873 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6875 if (! ignore_positions
)
6877 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6879 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6882 /* Don't compare the root_window field.
6883 We don't require the two configurations
6884 to use the same window object,
6885 and the two root windows must be equivalent
6886 if everything else compares equal. */
6887 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6889 if (! EQ (d1
->min_width
, d2
->min_width
))
6891 if (! EQ (d1
->min_height
, d2
->min_height
))
6894 /* Verify that the two confis have the same number of windows. */
6895 if (sw1
->size
!= sw2
->size
)
6898 for (i
= 0; i
< sw1
->size
; i
++)
6900 struct saved_window
*p1
, *p2
;
6901 int w1_is_current
, w2_is_current
;
6903 p1
= SAVED_WINDOW_N (sw1
, i
);
6904 p2
= SAVED_WINDOW_N (sw2
, i
);
6906 /* Verify that the current windows in the two
6907 configurations correspond to each other. */
6908 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6909 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6911 if (w1_is_current
!= w2_is_current
)
6914 /* Verify that the corresponding windows do match. */
6915 if (! EQ (p1
->buffer
, p2
->buffer
))
6917 if (! EQ (p1
->left_col
, p2
->left_col
))
6919 if (! EQ (p1
->top_line
, p2
->top_line
))
6921 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6923 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6925 if (! EQ (p1
->display_table
, p2
->display_table
))
6927 if (! EQ (p1
->parent
, p2
->parent
))
6929 if (! EQ (p1
->prev
, p2
->prev
))
6931 if (! ignore_positions
)
6933 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6935 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6937 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6939 if (NILP (Fequal (p1
->start
, p2
->start
)))
6941 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6943 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6946 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6948 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6950 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6952 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6954 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6956 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6958 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6965 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6966 Scompare_window_configurations
, 2, 2, 0,
6967 doc
: /* Compare two window configurations as regards the structure of windows.
6968 This function ignores details such as the values of point and mark
6969 and scrolling positions. */)
6973 if (compare_window_configurations (x
, y
, 1))
6981 struct frame
*f
= make_terminal_frame ();
6982 XSETFRAME (selected_frame
, f
);
6983 Vterminal_frame
= selected_frame
;
6984 minibuf_window
= f
->minibuffer_window
;
6985 selected_window
= f
->selected_window
;
6986 last_nonminibuf_frame
= f
;
6988 window_initialized
= 1;
6994 Vwindow_list
= Qnil
;
7000 Qscroll_up
= intern ("scroll-up");
7001 staticpro (&Qscroll_up
);
7003 Qscroll_down
= intern ("scroll-down");
7004 staticpro (&Qscroll_down
);
7006 Qwindow_size_fixed
= intern ("window-size-fixed");
7007 staticpro (&Qwindow_size_fixed
);
7008 Fset (Qwindow_size_fixed
, Qnil
);
7010 staticpro (&Qwindow_configuration_change_hook
);
7011 Qwindow_configuration_change_hook
7012 = intern ("window-configuration-change-hook");
7014 Qwindowp
= intern ("windowp");
7015 staticpro (&Qwindowp
);
7017 Qwindow_configuration_p
= intern ("window-configuration-p");
7018 staticpro (&Qwindow_configuration_p
);
7020 Qwindow_live_p
= intern ("window-live-p");
7021 staticpro (&Qwindow_live_p
);
7023 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7024 staticpro (&Qtemp_buffer_show_hook
);
7026 staticpro (&Vwindow_list
);
7028 minibuf_selected_window
= Qnil
;
7029 staticpro (&minibuf_selected_window
);
7031 window_scroll_pixel_based_preserve_y
= -1;
7033 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7034 doc
: /* Non-nil means call as function to display a help buffer.
7035 The function is called with one argument, the buffer to be displayed.
7036 Used by `with-output-to-temp-buffer'.
7037 If this function is used, then it must do the entire job of showing
7038 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7039 Vtemp_buffer_show_function
= Qnil
;
7041 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7042 doc
: /* If non-nil, function to call to handle `display-buffer'.
7043 It will receive two args, the buffer and a flag which if non-nil means
7044 that the currently selected window is not acceptable.
7045 It should choose or create a window, display the specified buffer in it,
7046 and return the window.
7047 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7048 work using this function. */);
7049 Vdisplay_buffer_function
= Qnil
;
7051 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7052 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7053 If nil, `display-buffer' will leave the window configuration alone. */);
7054 Veven_window_heights
= Qt
;
7056 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7057 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7058 Vminibuf_scroll_window
= Qnil
;
7060 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7061 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7062 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7063 is displayed in the `mode-line' face. */);
7064 mode_line_in_non_selected_windows
= 1;
7066 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7067 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7068 Vother_window_scroll_buffer
= Qnil
;
7070 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7071 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7074 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7075 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7076 auto_window_vscroll_p
= 1;
7078 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7079 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7080 If the buffer in question is already displayed in a frame, raise that frame. */);
7081 display_buffer_reuse_frames
= 0;
7083 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7084 doc
: /* Function to call to handle automatic new frame creation.
7085 It is called with no arguments and should return a newly created frame.
7087 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7088 where `pop-up-frame-alist' would hold the default frame parameters. */);
7089 Vpop_up_frame_function
= Qnil
;
7091 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7092 doc
: /* *List of buffer names that should have their own special frames.
7093 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7094 if its name is in this list, makes a special frame for it
7095 using `special-display-function'. See also `special-display-regexps'.
7097 An element of the list can be a list instead of just a string.
7098 There are two ways to use a list as an element:
7099 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7100 In the first case, the FRAME-PARAMETERS are pairs of the form
7101 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7102 In the second case, FUNCTION is called with BUFFER as the first argument,
7103 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7104 All this is done by the function found in `special-display-function'.
7106 If the specified frame parameters include (same-buffer . t), the
7107 buffer is displayed in the currently selected window. Otherwise, if
7108 they include (same-frame . t), the buffer is displayed in a new window
7109 in the currently selected frame.
7111 If this variable appears \"not to work\", because you add a name to it
7112 but that buffer still appears in the selected window, look at the
7113 values of `same-window-buffer-names' and `same-window-regexps'.
7114 Those variables take precedence over this one. */);
7115 Vspecial_display_buffer_names
= Qnil
;
7117 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7118 doc
: /* *List of regexps saying which buffers should have their own special frames.
7119 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7120 if any regexp in this list matches the buffer name, it makes a
7121 special frame for the buffer by calling `special-display-function'.
7123 An element of the list can be a list instead of just a string.
7124 There are two ways to use a list as an element:
7125 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7126 In the first case, the FRAME-PARAMETERS are pairs of the form
7127 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7128 In the second case, FUNCTION is called with BUFFER as the first argument,
7129 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7130 All this is done by the function found in `special-display-function'.
7132 If the specified frame parameters include (same-buffer . t), the
7133 buffer is displayed in the currently selected window. Otherwise, if
7134 they include (same-frame . t), the buffer is displayed in a new window
7135 in the currently selected frame.
7137 If this variable appears \"not to work\", because you add a regexp to it
7138 but the matching buffers still appear in the selected window, look at the
7139 values of `same-window-buffer-names' and `same-window-regexps'.
7140 Those variables take precedence over this one. */);
7141 Vspecial_display_regexps
= Qnil
;
7143 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7144 doc
: /* Function to call to make a new frame for a special buffer.
7145 It is called with two arguments, the buffer and optional buffer specific
7146 data, and should return a window displaying that buffer.
7147 The default value normally makes a separate frame for the buffer,
7148 using `special-display-frame-alist' to specify the frame parameters.
7149 But if the buffer specific data includes (same-buffer . t) then the
7150 buffer is displayed in the current selected window.
7151 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7152 a new window in the currently selected frame.
7154 A buffer is special if it is listed in `special-display-buffer-names'
7155 or matches a regexp in `special-display-regexps'. */);
7156 Vspecial_display_function
= Qnil
;
7158 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7159 doc
: /* *List of buffer names that should appear in the selected window.
7160 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7161 switches to it in the selected window, rather than making it appear
7162 in some other window.
7164 An element of the list can be a cons cell instead of just a string.
7165 Then the car must be a string, which specifies the buffer name.
7166 This is for compatibility with `special-display-buffer-names';
7167 the cdr of the cons cell is ignored.
7169 See also `same-window-regexps'. */);
7170 Vsame_window_buffer_names
= Qnil
;
7172 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7173 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7174 If a buffer name matches one of these regexps, then displaying it
7175 using `display-buffer' or `pop-to-buffer' switches to it
7176 in the selected window, rather than making it appear in some other window.
7178 An element of the list can be a cons cell instead of just a string.
7179 Then the car must be a string, which specifies the buffer name.
7180 This is for compatibility with `special-display-buffer-names';
7181 the cdr of the cons cell is ignored.
7183 See also `same-window-buffer-names'. */);
7184 Vsame_window_regexps
= Qnil
;
7186 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7187 doc
: /* *Non-nil means display-buffer should make new windows. */);
7190 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7191 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7192 next_screen_context_lines
= 2;
7194 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7195 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
7196 If there is only one window, it is split regardless of this value. */);
7197 split_height_threshold
= 500;
7199 DEFVAR_INT ("window-min-height", &window_min_height
,
7200 doc
: /* *Delete any window less than this tall (including its mode line). */);
7201 window_min_height
= 4;
7203 DEFVAR_INT ("window-min-width", &window_min_width
,
7204 doc
: /* *Delete any window less than this wide. */);
7205 window_min_width
= 10;
7207 DEFVAR_LISP ("scroll-preserve-screen-position",
7208 &Vscroll_preserve_screen_position
,
7209 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7210 A value of nil means point does not keep its screen position except
7211 at the scroll margin or window boundary respectively.
7212 A value of t means point keeps its screen position if the scroll
7213 command moved it vertically out of the window, e.g. when scrolling
7215 Any other value means point always keeps its screen position. */);
7216 Vscroll_preserve_screen_position
= Qnil
;
7218 DEFVAR_LISP ("window-configuration-change-hook",
7219 &Vwindow_configuration_change_hook
,
7220 doc
: /* Functions to call when window configuration changes.
7221 The selected frame is the one whose configuration has changed. */);
7222 Vwindow_configuration_change_hook
= Qnil
;
7224 defsubr (&Sselected_window
);
7225 defsubr (&Sminibuffer_window
);
7226 defsubr (&Swindow_minibuffer_p
);
7227 defsubr (&Swindowp
);
7228 defsubr (&Swindow_live_p
);
7229 defsubr (&Spos_visible_in_window_p
);
7230 defsubr (&Swindow_buffer
);
7231 defsubr (&Swindow_height
);
7232 defsubr (&Swindow_width
);
7233 defsubr (&Swindow_hscroll
);
7234 defsubr (&Sset_window_hscroll
);
7235 defsubr (&Swindow_redisplay_end_trigger
);
7236 defsubr (&Sset_window_redisplay_end_trigger
);
7237 defsubr (&Swindow_edges
);
7238 defsubr (&Swindow_pixel_edges
);
7239 defsubr (&Swindow_inside_edges
);
7240 defsubr (&Swindow_inside_pixel_edges
);
7241 defsubr (&Scoordinates_in_window_p
);
7242 defsubr (&Swindow_at
);
7243 defsubr (&Swindow_point
);
7244 defsubr (&Swindow_start
);
7245 defsubr (&Swindow_end
);
7246 defsubr (&Sset_window_point
);
7247 defsubr (&Sset_window_start
);
7248 defsubr (&Swindow_dedicated_p
);
7249 defsubr (&Sset_window_dedicated_p
);
7250 defsubr (&Swindow_display_table
);
7251 defsubr (&Sset_window_display_table
);
7252 defsubr (&Snext_window
);
7253 defsubr (&Sprevious_window
);
7254 defsubr (&Sother_window
);
7255 defsubr (&Sget_lru_window
);
7256 defsubr (&Sget_largest_window
);
7257 defsubr (&Sget_buffer_window
);
7258 defsubr (&Sdelete_other_windows
);
7259 defsubr (&Sdelete_windows_on
);
7260 defsubr (&Sreplace_buffer_in_windows
);
7261 defsubr (&Sdelete_window
);
7262 defsubr (&Sset_window_buffer
);
7263 defsubr (&Sselect_window
);
7264 defsubr (&Sspecial_display_p
);
7265 defsubr (&Ssame_window_p
);
7266 defsubr (&Sdisplay_buffer
);
7267 defsubr (&Sforce_window_update
);
7268 defsubr (&Ssplit_window
);
7269 defsubr (&Senlarge_window
);
7270 defsubr (&Sshrink_window
);
7271 defsubr (&Sadjust_window_trailing_edge
);
7272 defsubr (&Sscroll_up
);
7273 defsubr (&Sscroll_down
);
7274 defsubr (&Sscroll_left
);
7275 defsubr (&Sscroll_right
);
7276 defsubr (&Sother_window_for_scrolling
);
7277 defsubr (&Sscroll_other_window
);
7278 defsubr (&Sminibuffer_selected_window
);
7279 defsubr (&Srecenter
);
7280 defsubr (&Swindow_text_height
);
7281 defsubr (&Smove_to_window_line
);
7282 defsubr (&Swindow_configuration_p
);
7283 defsubr (&Swindow_configuration_frame
);
7284 defsubr (&Sset_window_configuration
);
7285 defsubr (&Scurrent_window_configuration
);
7286 defsubr (&Ssave_window_excursion
);
7287 defsubr (&Swindow_tree
);
7288 defsubr (&Sset_window_margins
);
7289 defsubr (&Swindow_margins
);
7290 defsubr (&Sset_window_fringes
);
7291 defsubr (&Swindow_fringes
);
7292 defsubr (&Sset_window_scroll_bars
);
7293 defsubr (&Swindow_scroll_bars
);
7294 defsubr (&Swindow_vscroll
);
7295 defsubr (&Sset_window_vscroll
);
7296 defsubr (&Scompare_window_configurations
);
7297 defsubr (&Swindow_list
);
7303 initial_define_key (control_x_map
, '1', "delete-other-windows");
7304 initial_define_key (control_x_map
, '2', "split-window");
7305 initial_define_key (control_x_map
, '0', "delete-window");
7306 initial_define_key (control_x_map
, 'o', "other-window");
7307 initial_define_key (control_x_map
, '^', "enlarge-window");
7308 initial_define_key (control_x_map
, '<', "scroll-left");
7309 initial_define_key (control_x_map
, '>', "scroll-right");
7311 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7312 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7313 initial_define_key (meta_map
, 'v', "scroll-down");
7315 initial_define_key (global_map
, Ctl('L'), "recenter");
7316 initial_define_key (meta_map
, 'r', "move-to-window-line");
7319 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7320 (do not change this comment) */