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. */
36 #include "dispextern.h"
37 #include "blockinput.h"
38 #include "intervals.h"
42 #endif /* HAVE_X_WINDOWS */
54 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
55 Lisp_Object Qscroll_up
, Qscroll_down
;
56 Lisp_Object Qwindow_size_fixed
;
57 extern Lisp_Object Qleft_margin
, Qright_margin
;
59 static int displayed_window_lines
P_ ((struct window
*));
60 static struct window
*decode_window
P_ ((Lisp_Object
));
61 static int count_windows
P_ ((struct window
*));
62 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
63 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
64 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
65 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
66 static int window_min_size_1
P_ ((struct window
*, int));
67 static int window_min_size
P_ ((struct window
*, int, int, int *));
68 static void size_window
P_ ((Lisp_Object
, int, int, int));
69 static int freeze_window_start
P_ ((struct window
*, void *));
70 static int window_fixed_size_p
P_ ((struct window
*, int, int));
71 static void enlarge_window
P_ ((Lisp_Object
, int, int));
72 static Lisp_Object window_list
P_ ((void));
73 static int add_window_to_list
P_ ((struct window
*, void *));
74 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
80 static int foreach_window_1
P_ ((struct window
*,
81 int (* fn
) (struct window
*, void *),
83 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
85 /* This is the window in which the terminal's cursor should
86 be left when nothing is being done with it. This must
87 always be a leaf window, and its buffer is selected by
88 the top level editing loop at the end of each command.
90 This value is always the same as
91 FRAME_SELECTED_WINDOW (selected_frame). */
93 Lisp_Object selected_window
;
95 /* A list of all windows for use by next_window and Fwindow_list.
96 Functions creating or deleting windows should invalidate this cache
97 by setting it to nil. */
99 Lisp_Object Vwindow_list
;
101 /* The mini-buffer window of the selected frame.
102 Note that you cannot test for mini-bufferness of an arbitrary window
103 by comparing against this; but you can test for mini-bufferness of
104 the selected window. */
106 Lisp_Object minibuf_window
;
108 /* Non-nil means it is the window whose mode line should be
109 shown as the selected window when the minibuffer is selected. */
111 Lisp_Object minibuf_selected_window
;
113 /* Non-nil means it is the window for C-M-v to scroll
114 when the mini-buffer is selected. */
116 Lisp_Object Vminibuf_scroll_window
;
118 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
120 Lisp_Object Vother_window_scroll_buffer
;
122 /* Non-nil means it's function to call to display temp buffers. */
124 Lisp_Object Vtemp_buffer_show_function
;
126 /* Non-zero means line and page scrolling on tall lines (with images)
127 does partial scrolling by modifying window-vscroll. */
129 int auto_window_vscroll_p
;
131 /* Non-zero means to use mode-line-inactive face in all windows but the
132 selected-window and the minibuffer-scroll-window when the
133 minibuffer is active. */
134 int mode_line_in_non_selected_windows
;
136 /* If a window gets smaller than either of these, it is removed. */
138 EMACS_INT window_min_height
;
139 EMACS_INT window_min_width
;
141 /* Nonzero implies Fdisplay_buffer should create windows. */
145 /* Nonzero implies make new frames for Fdisplay_buffer. */
149 /* Nonzero means reuse existing frames for displaying buffers. */
151 int display_buffer_reuse_frames
;
153 /* Non-nil means use this function instead of default */
155 Lisp_Object Vpop_up_frame_function
;
157 /* Function to call to handle Fdisplay_buffer. */
159 Lisp_Object Vdisplay_buffer_function
;
161 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
163 Lisp_Object Veven_window_heights
;
165 /* List of buffer *names* for buffers that should have their own frames. */
167 Lisp_Object Vspecial_display_buffer_names
;
169 /* List of regexps for buffer names that should have their own frames. */
171 Lisp_Object Vspecial_display_regexps
;
173 /* Function to pop up a special frame. */
175 Lisp_Object Vspecial_display_function
;
177 /* List of buffer *names* for buffers to appear in selected window. */
179 Lisp_Object Vsame_window_buffer_names
;
181 /* List of regexps for buffer names to appear in selected window. */
183 Lisp_Object Vsame_window_regexps
;
185 /* Hook run at end of temp_output_buffer_show. */
187 Lisp_Object Qtemp_buffer_show_hook
;
189 /* Fdisplay_buffer always splits the largest window
190 if that window is more than this high. */
192 EMACS_INT split_height_threshold
;
194 /* Number of lines of continuity in scrolling by screenfuls. */
196 EMACS_INT next_screen_context_lines
;
198 /* Incremented for each window created. */
200 static int sequence_number
;
202 /* Nonzero after init_window_once has finished. */
204 static int window_initialized
;
206 /* Hook to run when window config changes. */
208 Lisp_Object Qwindow_configuration_change_hook
;
209 Lisp_Object Vwindow_configuration_change_hook
;
211 /* Non-nil means scroll commands try to put point
212 at the same screen height as previously. */
214 Lisp_Object Vscroll_preserve_screen_position
;
216 /* Incremented by 1 whenever a window is deleted. */
218 int window_deletion_count
;
220 /* Used by the function window_scroll_pixel_based */
222 static int window_scroll_pixel_based_preserve_y
;
224 #if 0 /* This isn't used anywhere. */
225 /* Nonzero means we can split a frame even if it is "unsplittable". */
226 static int inhibit_frame_unsplittable
;
229 extern EMACS_INT scroll_margin
;
231 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
233 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
234 doc
: /* Returns t if OBJECT is a window. */)
238 return WINDOWP (object
) ? Qt
: Qnil
;
241 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
242 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
246 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
253 register struct window
*p
;
255 p
= allocate_window ();
257 XSETFASTINT (p
->sequence_number
, sequence_number
);
258 XSETFASTINT (p
->left_col
, 0);
259 XSETFASTINT (p
->top_line
, 0);
260 XSETFASTINT (p
->total_lines
, 0);
261 XSETFASTINT (p
->total_cols
, 0);
262 XSETFASTINT (p
->hscroll
, 0);
263 XSETFASTINT (p
->min_hscroll
, 0);
264 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
265 p
->start
= Fmake_marker ();
266 p
->pointm
= Fmake_marker ();
267 XSETFASTINT (p
->use_time
, 0);
269 p
->display_table
= Qnil
;
271 p
->pseudo_window_p
= 0;
272 bzero (&p
->cursor
, sizeof (p
->cursor
));
273 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
274 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
275 p
->desired_matrix
= p
->current_matrix
= 0;
276 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
277 p
->phys_cursor_type
= -1;
278 p
->phys_cursor_width
= -1;
279 p
->must_be_updated_p
= 0;
280 XSETFASTINT (p
->window_end_vpos
, 0);
281 XSETFASTINT (p
->window_end_pos
, 0);
282 p
->window_end_valid
= Qnil
;
285 XSETFASTINT (p
->last_point
, 0);
286 p
->frozen_window_start_p
= 0;
287 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
288 p
->left_margin_cols
= Qnil
;
289 p
->right_margin_cols
= Qnil
;
290 p
->left_fringe_width
= Qnil
;
291 p
->right_fringe_width
= Qnil
;
292 p
->fringes_outside_margins
= Qnil
;
293 p
->scroll_bar_width
= Qnil
;
294 p
->vertical_scroll_bar_type
= Qt
;
300 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
301 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
304 return selected_window
;
307 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
308 doc
: /* Return the window used now for minibuffers.
309 If the optional argument FRAME is specified, return the minibuffer window
310 used by that frame. */)
315 frame
= selected_frame
;
316 CHECK_LIVE_FRAME (frame
);
317 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
320 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
321 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
322 WINDOW defaults to the selected window. */)
326 struct window
*w
= decode_window (window
);
327 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
331 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
332 Spos_visible_in_window_p
, 0, 3, 0,
333 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
334 Return nil if that position is scrolled vertically out of view.
335 If a character is only partially visible, nil is returned, unless the
336 optional argument PARTIALLY is non-nil.
337 If POS is only out of view because of horizontal scrolling, return non-nil.
338 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
340 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
341 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
342 relative to the top left corner of the window. PARTIAL is nil if the character
343 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
344 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
345 (pos
, window
, partially
)
346 Lisp_Object pos
, window
, partially
;
348 register struct window
*w
;
350 register struct buffer
*buf
;
352 Lisp_Object in_window
= Qnil
;
353 int rtop
, rbot
, fully_p
= 1;
356 w
= decode_window (window
);
357 buf
= XBUFFER (w
->buffer
);
358 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
362 CHECK_NUMBER_COERCE_MARKER (pos
);
365 else if (w
== XWINDOW (selected_window
))
368 posint
= XMARKER (w
->pointm
)->charpos
;
370 /* If position is above window start or outside buffer boundaries,
371 or if window start is out of range, position is not visible. */
372 if (posint
>= CHARPOS (top
)
373 && posint
<= BUF_ZV (buf
)
374 && CHARPOS (top
) >= BUF_BEGV (buf
)
375 && CHARPOS (top
) <= BUF_ZV (buf
)
376 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
377 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
380 if (!NILP (in_window
) && !NILP (partially
))
381 in_window
= Fcons (make_number (x
),
382 Fcons (make_number (y
),
383 Fcons ((fully_p
? Qnil
384 : Fcons (make_number (rtop
),
385 make_number (rbot
))),
391 static struct window
*
392 decode_window (window
)
393 register Lisp_Object window
;
396 return XWINDOW (selected_window
);
398 CHECK_LIVE_WINDOW (window
);
399 return XWINDOW (window
);
402 static struct window
*
403 decode_any_window (window
)
404 register Lisp_Object window
;
407 return XWINDOW (selected_window
);
409 CHECK_WINDOW (window
);
410 return XWINDOW (window
);
413 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
414 doc
: /* Return the buffer that WINDOW is displaying.
415 WINDOW defaults to the selected window. */)
419 return decode_window (window
)->buffer
;
422 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
423 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
427 return decode_any_window (window
)->total_lines
;
430 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
431 doc
: /* Return the number of display columns in WINDOW.
432 This is the width that is usable columns available for text in WINDOW.
433 If you want to find out how many columns WINDOW takes up,
434 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
438 return make_number (window_box_text_cols (decode_any_window (window
)));
441 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
442 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
446 return decode_window (window
)->hscroll
;
449 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
450 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
451 Return NCOL. NCOL should be zero or positive.
453 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
454 window so that the location of point becomes invisible. */)
456 Lisp_Object window
, ncol
;
458 struct window
*w
= decode_window (window
);
462 hscroll
= max (0, XINT (ncol
));
464 /* Prevent redisplay shortcuts when changing the hscroll. */
465 if (XINT (w
->hscroll
) != hscroll
)
466 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
468 w
->hscroll
= make_number (hscroll
);
472 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
473 Swindow_redisplay_end_trigger
, 0, 1, 0,
474 doc
: /* Return WINDOW's redisplay end trigger value.
475 See `set-window-redisplay-end-trigger' for more information. */)
479 return decode_window (window
)->redisplay_end_trigger
;
482 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
483 Sset_window_redisplay_end_trigger
, 2, 2, 0,
484 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
485 VALUE should be a buffer position (typically a marker) or nil.
486 If it is a buffer position, then if redisplay in WINDOW reaches a position
487 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
488 with two arguments: WINDOW, and the end trigger value.
489 Afterwards the end-trigger value is reset to nil. */)
491 register Lisp_Object window
, value
;
493 register struct window
*w
;
495 w
= decode_window (window
);
496 w
->redisplay_end_trigger
= value
;
500 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
501 doc
: /* Return a list of the edge coordinates of WINDOW.
502 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
503 RIGHT is one more than the rightmost column occupied by WINDOW,
504 and BOTTOM is one more than the bottommost row occupied by WINDOW.
505 The edges include the space used by the window's scroll bar,
506 display margins, fringes, header line, and mode line, if it has them.
507 To get the edges of the actual text area, use `window-inside-edges'. */)
511 register struct window
*w
= decode_any_window (window
);
513 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
514 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
515 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
516 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
520 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
521 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
522 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
523 RIGHT is one more than the rightmost x position occupied by WINDOW,
524 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
525 The pixel edges include the space used by the window's scroll bar,
526 display margins, fringes, header line, and mode line, if it has them.
527 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
531 register struct window
*w
= decode_any_window (window
);
533 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
534 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
535 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
536 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
540 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
541 doc
: /* Return a list of the edge coordinates of WINDOW.
542 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
543 RIGHT is one more than the rightmost column used by text in WINDOW,
544 and BOTTOM is one more than the bottommost row used by text in WINDOW.
545 The inside edges do not include the space used by the window's scroll bar,
546 display margins, fringes, header line, and/or mode line. */)
550 register struct window
*w
= decode_any_window (window
);
552 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
553 + WINDOW_LEFT_MARGIN_COLS (w
)
554 + WINDOW_LEFT_FRINGE_COLS (w
)),
555 make_number (WINDOW_TOP_EDGE_LINE (w
)
556 + WINDOW_HEADER_LINE_LINES (w
)),
557 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
558 - WINDOW_RIGHT_MARGIN_COLS (w
)
559 - WINDOW_RIGHT_FRINGE_COLS (w
)),
560 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
561 - WINDOW_MODE_LINE_LINES (w
)));
564 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
565 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
566 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
567 RIGHT is one more than the rightmost x position used by text in WINDOW,
568 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
569 The inside edges do not include the space used by the window's scroll bar,
570 display margins, fringes, header line, and/or mode line. */)
574 register struct window
*w
= decode_any_window (window
);
576 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
577 + WINDOW_LEFT_MARGIN_WIDTH (w
)
578 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
579 make_number (WINDOW_TOP_EDGE_Y (w
)
580 + WINDOW_HEADER_LINE_HEIGHT (w
)),
581 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
582 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
583 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
584 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
585 - WINDOW_MODE_LINE_HEIGHT (w
)));
588 /* Test if the character at column *X, row *Y is within window W.
589 If it is not, return ON_NOTHING;
590 if it is in the window's text area,
591 set *x and *y to its location relative to the upper left corner
594 if it is on the window's modeline, return ON_MODE_LINE;
595 if it is on the border between the window and its right sibling,
596 return ON_VERTICAL_BORDER.
597 if it is on a scroll bar,
598 return ON_SCROLL_BAR.
599 if it is on the window's top line, return ON_HEADER_LINE;
600 if it is in left or right fringe of the window,
601 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
602 to window-relative coordinates;
603 if it is in the marginal area to the left/right of the window,
604 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
605 to window-relative coordinates.
607 X and Y are frame relative pixel coordinates. */
609 static enum window_part
610 coordinates_in_window (w
, x
, y
)
611 register struct window
*w
;
614 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
615 int left_x
, right_x
, top_y
, bottom_y
;
616 enum window_part part
;
617 int ux
= FRAME_COLUMN_WIDTH (f
);
618 int x0
= WINDOW_LEFT_EDGE_X (w
);
619 int x1
= WINDOW_RIGHT_EDGE_X (w
);
620 /* The width of the area where the vertical line can be dragged.
621 (Between mode lines for instance. */
622 int grabbable_width
= ux
;
623 int lmargin_width
, rmargin_width
, text_left
, text_right
;
625 /* In what's below, we subtract 1 when computing right_x because we
626 want the rightmost pixel, which is given by left_pixel+width-1. */
627 if (w
->pseudo_window_p
)
630 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
631 top_y
= WINDOW_TOP_EDGE_Y (w
);
632 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
636 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
637 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
638 top_y
= WINDOW_TOP_EDGE_Y (w
);
639 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
642 /* Outside any interesting row? */
643 if (*y
< top_y
|| *y
>= bottom_y
)
646 /* On the mode line or header line? If it's near the start of
647 the mode or header line of window that's has a horizontal
648 sibling, say it's on the vertical line. That's to be able
649 to resize windows horizontally in case we're using toolkit
652 if (WINDOW_WANTS_MODELINE_P (w
)
653 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
657 header_vertical_border_check
:
658 /* We're somewhere on the mode line. We consider the place
659 between mode lines of horizontally adjacent mode lines
660 as the vertical border. If scroll bars on the left,
661 return the right window. */
662 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
663 || WINDOW_RIGHTMOST_P (w
))
665 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
666 return ON_VERTICAL_BORDER
;
670 if (abs (*x
- x1
) < grabbable_width
)
671 return ON_VERTICAL_BORDER
;
674 if (*x
< x0
|| *x
>= x1
)
677 /* Convert X and Y to window relative coordinates.
678 Mode line starts at left edge of window. */
684 if (WINDOW_WANTS_HEADER_LINE_P (w
)
685 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
687 part
= ON_HEADER_LINE
;
688 goto header_vertical_border_check
;
691 if (*x
< x0
|| *x
>= x1
)
694 /* Outside any interesting column? */
695 if (*x
< left_x
|| *x
> right_x
)
698 return ON_SCROLL_BAR
;
701 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
702 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
704 text_left
= window_box_left (w
, TEXT_AREA
);
705 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
707 if (FRAME_WINDOW_P (f
))
709 if (!w
->pseudo_window_p
710 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
711 && !WINDOW_RIGHTMOST_P (w
)
712 && (abs (*x
- right_x
) < grabbable_width
))
713 return ON_VERTICAL_BORDER
;
717 /* Need to say "*x > right_x" rather than >=, since on character
718 terminals, the vertical line's x coordinate is right_x. */
719 if (!w
->pseudo_window_p
720 && !WINDOW_RIGHTMOST_P (w
)
721 && *x
> right_x
- ux
)
723 /* On the border on the right side of the window? Assume that
724 this area begins at RIGHT_X minus a canonical char width. */
725 return ON_VERTICAL_BORDER
;
731 if (lmargin_width
> 0
732 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
733 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
734 : (*x
< left_x
+ lmargin_width
)))
737 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
738 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
740 return ON_LEFT_MARGIN
;
743 /* Convert X and Y to window-relative pixel coordinates. */
746 return ON_LEFT_FRINGE
;
749 if (*x
>= text_right
)
751 if (rmargin_width
> 0
752 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
753 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
754 : (*x
>= right_x
- rmargin_width
)))
756 *x
-= right_x
- rmargin_width
;
757 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
758 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
760 return ON_RIGHT_MARGIN
;
763 /* Convert X and Y to window-relative pixel coordinates. */
764 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
766 return ON_RIGHT_FRINGE
;
769 /* Everything special ruled out - must be on text area */
776 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
777 Scoordinates_in_window_p
, 2, 2, 0,
778 doc
: /* Return non-nil if COORDINATES are in WINDOW.
779 COORDINATES is a cons of the form (X . Y), X and Y being distances
780 measured in characters from the upper-left corner of the frame.
781 \(0 . 0) denotes the character in the upper left corner of the
783 If COORDINATES are in the text portion of WINDOW,
784 the coordinates relative to the window are returned.
785 If they are in the mode line of WINDOW, `mode-line' is returned.
786 If they are in the top mode line of WINDOW, `header-line' is returned.
787 If they are in the left fringe of WINDOW, `left-fringe' is returned.
788 If they are in the right fringe of WINDOW, `right-fringe' is returned.
789 If they are on the border between WINDOW and its right sibling,
790 `vertical-line' is returned.
791 If they are in the windows's left or right marginal areas, `left-margin'\n\
792 or `right-margin' is returned. */)
793 (coordinates
, window
)
794 register Lisp_Object coordinates
, window
;
801 CHECK_WINDOW (window
);
802 w
= XWINDOW (window
);
803 f
= XFRAME (w
->frame
);
804 CHECK_CONS (coordinates
);
805 lx
= Fcar (coordinates
);
806 ly
= Fcdr (coordinates
);
807 CHECK_NUMBER_OR_FLOAT (lx
);
808 CHECK_NUMBER_OR_FLOAT (ly
);
809 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
810 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
812 switch (coordinates_in_window (w
, &x
, &y
))
818 /* X and Y are now window relative pixel coordinates. Convert
819 them to canonical char units before returning them. */
820 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
821 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
826 case ON_VERTICAL_BORDER
:
827 return Qvertical_line
;
835 case ON_RIGHT_FRINGE
:
836 return Qright_fringe
;
841 case ON_RIGHT_MARGIN
:
842 return Qright_margin
;
845 /* Historically we are supposed to return nil in this case. */
854 /* Callback for foreach_window, used in window_from_coordinates.
855 Check if window W contains coordinates specified by USER_DATA which
856 is actually a pointer to a struct check_window_data CW.
858 Check if window W contains coordinates *CW->x and *CW->y. If it
859 does, return W in *CW->window, as Lisp_Object, and return in
860 *CW->part the part of the window under coordinates *X,*Y. Return
861 zero from this function to stop iterating over windows. */
863 struct check_window_data
867 enum window_part
*part
;
871 check_window_containing (w
, user_data
)
875 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
876 enum window_part found
;
879 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
880 if (found
!= ON_NOTHING
)
883 XSETWINDOW (*cw
->window
, w
);
891 /* Find the window containing frame-relative pixel position X/Y and
892 return it as a Lisp_Object.
894 If X, Y is on one of the window's special `window_part' elements,
895 set *PART to the id of that element, and return X and Y converted
896 to window relative coordinates in WX and WY.
898 If there is no window under X, Y return nil and leave *PART
899 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
901 This function was previously implemented with a loop cycling over
902 windows with Fnext_window, and starting with the frame's selected
903 window. It turned out that this doesn't work with an
904 implementation of next_window using Vwindow_list, because
905 FRAME_SELECTED_WINDOW (F) is not always contained in the window
906 tree of F when this function is called asynchronously from
907 note_mouse_highlight. The original loop didn't terminate in this
911 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
914 enum window_part
*part
;
919 struct check_window_data cw
;
920 enum window_part dummy
;
926 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
927 foreach_window (f
, check_window_containing
, &cw
);
929 /* If not found above, see if it's in the tool bar window, if a tool
933 && WINDOWP (f
->tool_bar_window
)
934 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
935 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
939 window
= f
->tool_bar_window
;
948 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
949 doc
: /* Return window containing coordinates X and Y on FRAME.
950 If omitted, FRAME defaults to the currently selected frame.
951 The top left corner of the frame is considered to be row 0,
954 Lisp_Object x
, y
, frame
;
959 frame
= selected_frame
;
960 CHECK_LIVE_FRAME (frame
);
963 /* Check that arguments are integers or floats. */
964 CHECK_NUMBER_OR_FLOAT (x
);
965 CHECK_NUMBER_OR_FLOAT (y
);
967 return window_from_coordinates (f
,
968 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
969 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
970 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
971 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
975 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
976 doc
: /* Return current value of point in WINDOW.
977 For a nonselected window, this is the value point would have
978 if that window were selected.
980 Note that, when WINDOW is the selected window and its buffer
981 is also currently selected, the value returned is the same as (point).
982 It would be more strictly correct to return the `top-level' value
983 of point, outside of any save-excursion forms.
984 But that is hard to define. */)
988 register struct window
*w
= decode_window (window
);
990 if (w
== XWINDOW (selected_window
)
991 && current_buffer
== XBUFFER (w
->buffer
))
993 return Fmarker_position (w
->pointm
);
996 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
997 doc
: /* Return position at which display currently starts in WINDOW.
998 This is updated by redisplay or by calling `set-window-start'. */)
1002 return Fmarker_position (decode_window (window
)->start
);
1005 /* This is text temporarily removed from the doc string below.
1007 This function returns nil if the position is not currently known.
1008 That happens when redisplay is preempted and doesn't finish.
1009 If in that case you want to compute where the end of the window would
1010 have been if redisplay had finished, do this:
1012 (goto-char (window-start window))
1013 (vertical-motion (1- (window-height window)) window)
1016 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1017 doc
: /* Return position at which display currently ends in WINDOW.
1018 This is updated by redisplay, when it runs to completion.
1019 Simply changing the buffer text or setting `window-start'
1020 does not update this value.
1021 Return nil if there is no recorded value. \(This can happen if the
1022 last redisplay of WINDOW was preempted, and did not finish.)
1023 If UPDATE is non-nil, compute the up-to-date position
1024 if it isn't already recorded. */)
1026 Lisp_Object window
, update
;
1029 struct window
*w
= decode_window (window
);
1035 #if 0 /* This change broke some things. We should make it later. */
1036 /* If we don't know the end position, return nil.
1037 The user can compute it with vertical-motion if he wants to.
1038 It would be nicer to do it automatically,
1039 but that's so slow that it would probably bother people. */
1040 if (NILP (w
->window_end_valid
))
1045 && ! (! NILP (w
->window_end_valid
)
1046 && XFASTINT (w
->last_modified
) >= MODIFF
)
1049 struct text_pos startp
;
1051 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1053 /* In case W->start is out of the range, use something
1054 reasonable. This situation occurred when loading a file with
1055 `-l' containing a call to `rmail' with subsequent other
1056 commands. At the end, W->start happened to be BEG, while
1057 rmail had already narrowed the buffer. */
1058 if (XMARKER (w
->start
)->charpos
< BEGV
)
1059 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1060 else if (XMARKER (w
->start
)->charpos
> ZV
)
1061 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1063 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1065 /* Cannot use Fvertical_motion because that function doesn't
1066 cope with variable-height lines. */
1067 if (b
!= current_buffer
)
1069 old_buffer
= current_buffer
;
1070 set_buffer_internal (b
);
1073 start_display (&it
, w
, startp
);
1074 move_it_vertically (&it
, window_box_height (w
));
1075 if (it
.current_y
< it
.last_visible_y
)
1076 move_it_past_eol (&it
);
1077 value
= make_number (IT_CHARPOS (it
));
1080 set_buffer_internal (old_buffer
);
1083 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1088 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1089 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1092 Lisp_Object window
, pos
;
1094 register struct window
*w
= decode_window (window
);
1096 CHECK_NUMBER_COERCE_MARKER (pos
);
1097 if (w
== XWINDOW (selected_window
)
1098 && XBUFFER (w
->buffer
) == current_buffer
)
1101 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1103 /* We have to make sure that redisplay updates the window to show
1104 the new value of point. */
1105 if (!EQ (window
, selected_window
))
1106 ++windows_or_buffers_changed
;
1111 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1112 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1114 Optional third arg NOFORCE non-nil inhibits next redisplay
1115 from overriding motion of point in order to display at this exact start. */)
1116 (window
, pos
, noforce
)
1117 Lisp_Object window
, pos
, noforce
;
1119 register struct window
*w
= decode_window (window
);
1121 CHECK_NUMBER_COERCE_MARKER (pos
);
1122 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1123 /* this is not right, but much easier than doing what is right. */
1124 w
->start_at_line_beg
= Qnil
;
1126 w
->force_start
= Qt
;
1127 w
->update_mode_line
= Qt
;
1128 XSETFASTINT (w
->last_modified
, 0);
1129 XSETFASTINT (w
->last_overlay_modified
, 0);
1130 if (!EQ (window
, selected_window
))
1131 windows_or_buffers_changed
++;
1136 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1138 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1139 See also `set-window-dedicated-p'. */)
1143 return decode_window (window
)->dedicated
;
1146 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1147 Sset_window_dedicated_p
, 2, 2, 0,
1148 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1149 If it is dedicated, Emacs will not automatically change
1150 which buffer appears in it.
1151 The second argument is the new value for the dedication flag;
1152 non-nil means yes. */)
1154 Lisp_Object window
, arg
;
1156 register struct window
*w
= decode_window (window
);
1160 return w
->dedicated
;
1163 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1165 doc
: /* Return the display-table that WINDOW is using. */)
1169 return decode_window (window
)->display_table
;
1172 /* Get the display table for use on window W. This is either W's
1173 display table or W's buffer's display table. Ignore the specified
1174 tables if they are not valid; if no valid table is specified,
1177 struct Lisp_Char_Table
*
1178 window_display_table (w
)
1181 struct Lisp_Char_Table
*dp
= NULL
;
1183 if (DISP_TABLE_P (w
->display_table
))
1184 dp
= XCHAR_TABLE (w
->display_table
);
1185 else if (BUFFERP (w
->buffer
))
1187 struct buffer
*b
= XBUFFER (w
->buffer
);
1189 if (DISP_TABLE_P (b
->display_table
))
1190 dp
= XCHAR_TABLE (b
->display_table
);
1191 else if (DISP_TABLE_P (Vstandard_display_table
))
1192 dp
= XCHAR_TABLE (Vstandard_display_table
);
1198 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1199 doc
: /* Set WINDOW's display-table to TABLE. */)
1201 register Lisp_Object window
, table
;
1203 register struct window
*w
;
1205 w
= decode_window (window
);
1206 w
->display_table
= table
;
1210 /* Record info on buffer window w is displaying
1211 when it is about to cease to display that buffer. */
1214 register struct window
*w
;
1221 if (b
!= XMARKER (w
->pointm
)->buffer
)
1225 if (w
== XWINDOW (selected_window
)
1226 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1227 /* Do this except when the selected window's buffer
1228 is being removed from some other window. */
1230 /* last_window_start records the start position that this buffer
1231 had in the last window to be disconnected from it.
1232 Now that this statement is unconditional,
1233 it is possible for the buffer to be displayed in the
1234 selected window, while last_window_start reflects another
1235 window which was recently showing the same buffer.
1236 Some people might say that might be a good thing. Let's see. */
1237 b
->last_window_start
= marker_position (w
->start
);
1239 /* Point in the selected window's buffer
1240 is actually stored in that buffer, and the window's pointm isn't used.
1241 So don't clobber point in that buffer. */
1242 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1243 /* This line helps to fix Horsley's testbug.el bug. */
1244 && !(WINDOWP (b
->last_selected_window
)
1245 && w
!= XWINDOW (b
->last_selected_window
)
1246 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1247 temp_set_point_both (b
,
1248 clip_to_bounds (BUF_BEGV (b
),
1249 XMARKER (w
->pointm
)->charpos
,
1251 clip_to_bounds (BUF_BEGV_BYTE (b
),
1252 marker_byte_position (w
->pointm
),
1255 if (WINDOWP (b
->last_selected_window
)
1256 && w
== XWINDOW (b
->last_selected_window
))
1257 b
->last_selected_window
= Qnil
;
1260 /* Put replacement into the window structure in place of old. */
1262 replace_window (old
, replacement
)
1263 Lisp_Object old
, replacement
;
1265 register Lisp_Object tem
;
1266 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1268 /* If OLD is its frame's root_window, then replacement is the new
1269 root_window for that frame. */
1271 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1272 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1274 p
->left_col
= o
->left_col
;
1275 p
->top_line
= o
->top_line
;
1276 p
->total_cols
= o
->total_cols
;
1277 p
->total_lines
= o
->total_lines
;
1278 p
->desired_matrix
= p
->current_matrix
= 0;
1280 bzero (&p
->cursor
, sizeof (p
->cursor
));
1281 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1282 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1283 p
->phys_cursor_type
= -1;
1284 p
->phys_cursor_width
= -1;
1285 p
->must_be_updated_p
= 0;
1286 p
->pseudo_window_p
= 0;
1287 XSETFASTINT (p
->window_end_vpos
, 0);
1288 XSETFASTINT (p
->window_end_pos
, 0);
1289 p
->window_end_valid
= Qnil
;
1290 p
->frozen_window_start_p
= 0;
1291 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1293 p
->next
= tem
= o
->next
;
1295 XWINDOW (tem
)->prev
= replacement
;
1297 p
->prev
= tem
= o
->prev
;
1299 XWINDOW (tem
)->next
= replacement
;
1301 p
->parent
= tem
= o
->parent
;
1304 if (EQ (XWINDOW (tem
)->vchild
, old
))
1305 XWINDOW (tem
)->vchild
= replacement
;
1306 if (EQ (XWINDOW (tem
)->hchild
, old
))
1307 XWINDOW (tem
)->hchild
= replacement
;
1310 /*** Here, if replacement is a vertical combination
1311 and so is its new parent, we should make replacement's
1312 children be children of that parent instead. ***/
1315 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1316 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1318 register Lisp_Object window
;
1320 delete_window (window
);
1322 if (! NILP (Vwindow_configuration_change_hook
)
1323 && ! NILP (Vrun_hooks
))
1324 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1330 delete_window (window
)
1331 register Lisp_Object window
;
1333 register Lisp_Object tem
, parent
, sib
;
1334 register struct window
*p
;
1335 register struct window
*par
;
1338 /* Because this function is called by other C code on non-leaf
1339 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1340 so we can't decode_window here. */
1342 window
= selected_window
;
1344 CHECK_WINDOW (window
);
1345 p
= XWINDOW (window
);
1347 /* It's a no-op to delete an already-deleted window. */
1348 if (NILP (p
->buffer
)
1350 && NILP (p
->vchild
))
1355 error ("Attempt to delete minibuffer or sole ordinary window");
1356 par
= XWINDOW (parent
);
1358 windows_or_buffers_changed
++;
1359 Vwindow_list
= Qnil
;
1360 f
= XFRAME (WINDOW_FRAME (p
));
1361 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1363 /* Are we trying to delete any frame's selected window? */
1365 Lisp_Object swindow
, pwindow
;
1367 /* See if the frame's selected window is either WINDOW
1368 or any subwindow of it, by finding all that window's parents
1369 and comparing each one with WINDOW. */
1370 swindow
= FRAME_SELECTED_WINDOW (f
);
1375 while (!NILP (pwindow
))
1377 if (EQ (window
, pwindow
))
1379 pwindow
= XWINDOW (pwindow
)->parent
;
1382 /* If the window being deleted is not a parent of SWINDOW,
1383 then SWINDOW is ok as the new selected window. */
1384 if (!EQ (window
, pwindow
))
1386 /* Otherwise, try another window for SWINDOW. */
1387 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1389 /* If we get back to the frame's selected window,
1390 it means there was no acceptable alternative,
1391 so we cannot delete. */
1392 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1393 error ("Cannot delete window");
1396 /* If we need to change SWINDOW, do it. */
1397 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1399 /* If we're about to delete the selected window on the
1400 selected frame, then we should use Fselect_window to select
1401 the new window. On the other hand, if we're about to
1402 delete the selected window on any other frame, we shouldn't do
1403 anything but set the frame's selected_window slot. */
1404 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1405 Fselect_window (swindow
, Qnil
);
1407 FRAME_SELECTED_WINDOW (f
) = swindow
;
1411 /* Now we know we can delete this one. */
1412 window_deletion_count
++;
1415 /* tem is null for dummy parent windows
1416 (which have inferiors but not any contents themselves) */
1420 unchain_marker (XMARKER (p
->pointm
));
1421 unchain_marker (XMARKER (p
->start
));
1424 /* Free window glyph matrices. It is sure that they are allocated
1425 again when ADJUST_GLYPHS is called. Block input so that expose
1426 events and other events that access glyph matrices are not
1427 processed while we are changing them. */
1429 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1433 XWINDOW (tem
)->prev
= p
->prev
;
1437 XWINDOW (tem
)->next
= p
->next
;
1439 if (EQ (window
, par
->hchild
))
1440 par
->hchild
= p
->next
;
1441 if (EQ (window
, par
->vchild
))
1442 par
->vchild
= p
->next
;
1444 /* Find one of our siblings to give our space to. */
1448 /* If p gives its space to its next sibling, that sibling needs
1449 to have its top/left side pulled back to where p's is.
1450 set_window_{height,width} will re-position the sibling's
1453 XWINDOW (sib
)->top_line
= p
->top_line
;
1454 XWINDOW (sib
)->left_col
= p
->left_col
;
1457 /* Stretch that sibling. */
1458 if (!NILP (par
->vchild
))
1459 set_window_height (sib
,
1460 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1462 if (!NILP (par
->hchild
))
1463 set_window_width (sib
,
1464 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1467 /* If parent now has only one child,
1468 put the child into the parent's place. */
1472 if (NILP (XWINDOW (tem
)->next
)) {
1473 replace_window (parent
, tem
);
1474 par
= XWINDOW (tem
);
1477 /* Since we may be deleting combination windows, we must make sure that
1478 not only p but all its children have been marked as deleted. */
1479 if (! NILP (p
->hchild
))
1480 delete_all_subwindows (XWINDOW (p
->hchild
));
1481 else if (! NILP (p
->vchild
))
1482 delete_all_subwindows (XWINDOW (p
->vchild
));
1484 /* Mark this window as deleted. */
1485 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1487 if (! NILP (par
->parent
))
1488 par
= XWINDOW (par
->parent
);
1490 /* Check if we have a v/hchild with a v/hchild. In that case remove
1493 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1495 p
= XWINDOW (par
->vchild
);
1496 par
->vchild
= p
->vchild
;
1499 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1501 p
= XWINDOW (par
->hchild
);
1502 par
->hchild
= p
->hchild
;
1510 while (! NILP (tem
)) {
1511 XWINDOW (tem
)->parent
= p
->parent
;
1512 if (NILP (XWINDOW (tem
)->next
))
1514 tem
= XWINDOW (tem
)->next
;
1517 /* The next of the v/hchild we are removing is now the next of the
1518 last child for the v/hchild:
1519 Before v/hchild -> v/hchild -> next1 -> next2
1522 After: v/hchild -> next1 -> next2 -> next3
1524 XWINDOW (tem
)->next
= p
->next
;
1525 if (! NILP (p
->next
))
1526 XWINDOW (p
->next
)->prev
= tem
;
1528 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1532 /* Adjust glyph matrices. */
1539 /***********************************************************************
1541 ***********************************************************************/
1543 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1544 pointer. This is a callback function for foreach_window, used in
1545 function window_list. */
1548 add_window_to_list (w
, user_data
)
1552 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1554 XSETWINDOW (window
, w
);
1555 *list
= Fcons (window
, *list
);
1560 /* Return a list of all windows, for use by next_window. If
1561 Vwindow_list is a list, return that list. Otherwise, build a new
1562 list, cache it in Vwindow_list, and return that. */
1567 if (!CONSP (Vwindow_list
))
1571 Vwindow_list
= Qnil
;
1572 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1574 Lisp_Object args
[2];
1576 /* We are visiting windows in canonical order, and add
1577 new windows at the front of args[1], which means we
1578 have to reverse this list at the end. */
1580 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1581 args
[0] = Vwindow_list
;
1582 args
[1] = Fnreverse (args
[1]);
1583 Vwindow_list
= Fnconc (2, args
);
1587 return Vwindow_list
;
1591 /* Value is non-zero if WINDOW satisfies the constraints given by
1592 OWINDOW, MINIBUF and ALL_FRAMES.
1594 MINIBUF t means WINDOW may be minibuffer windows.
1595 `lambda' means WINDOW may not be a minibuffer window.
1596 a window means a specific minibuffer window
1598 ALL_FRAMES t means search all frames,
1599 nil means search just current frame,
1600 `visible' means search just visible frames,
1601 0 means search visible and iconified frames,
1602 a window means search the frame that window belongs to,
1603 a frame means consider windows on that frame, only. */
1606 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1607 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1609 struct window
*w
= XWINDOW (window
);
1610 struct frame
*f
= XFRAME (w
->frame
);
1611 int candidate_p
= 1;
1613 if (!BUFFERP (w
->buffer
))
1615 else if (MINI_WINDOW_P (w
)
1616 && (EQ (minibuf
, Qlambda
)
1617 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1619 /* If MINIBUF is `lambda' don't consider any mini-windows.
1620 If it is a window, consider only that one. */
1623 else if (EQ (all_frames
, Qt
))
1625 else if (NILP (all_frames
))
1627 xassert (WINDOWP (owindow
));
1628 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1630 else if (EQ (all_frames
, Qvisible
))
1632 FRAME_SAMPLE_VISIBILITY (f
);
1633 candidate_p
= FRAME_VISIBLE_P (f
);
1635 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1637 FRAME_SAMPLE_VISIBILITY (f
);
1638 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1640 else if (WINDOWP (all_frames
))
1641 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1642 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1643 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1644 else if (FRAMEP (all_frames
))
1645 candidate_p
= EQ (all_frames
, w
->frame
);
1651 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1652 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1656 decode_next_window_args (window
, minibuf
, all_frames
)
1657 Lisp_Object
*window
, *minibuf
, *all_frames
;
1660 *window
= selected_window
;
1662 CHECK_LIVE_WINDOW (*window
);
1664 /* MINIBUF nil may or may not include minibuffers. Decide if it
1666 if (NILP (*minibuf
))
1667 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1668 else if (!EQ (*minibuf
, Qt
))
1671 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1672 => count none of them, or a specific minibuffer window (the
1673 active one) to count. */
1675 /* ALL_FRAMES nil doesn't specify which frames to include. */
1676 if (NILP (*all_frames
))
1677 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1678 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1680 else if (EQ (*all_frames
, Qvisible
))
1682 else if (EQ (*all_frames
, make_number (0)))
1684 else if (FRAMEP (*all_frames
))
1686 else if (!EQ (*all_frames
, Qt
))
1689 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1690 search just current frame, `visible' meaning search just visible
1691 frames, 0 meaning search visible and iconified frames, or a
1692 window, meaning search the frame that window belongs to, or a
1693 frame, meaning consider windows on that frame, only. */
1697 /* Return the next or previous window of WINDOW in canonical ordering
1698 of windows. NEXT_P non-zero means return the next window. See the
1699 documentation string of next-window for the meaning of MINIBUF and
1703 next_window (window
, minibuf
, all_frames
, next_p
)
1704 Lisp_Object window
, minibuf
, all_frames
;
1707 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1709 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1710 return the first window on the frame. */
1711 if (FRAMEP (all_frames
)
1712 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1713 return Fframe_first_window (all_frames
);
1719 /* Find WINDOW in the list of all windows. */
1720 list
= Fmemq (window
, window_list ());
1722 /* Scan forward from WINDOW to the end of the window list. */
1724 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1725 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1728 /* Scan from the start of the window list up to WINDOW. */
1730 for (list
= Vwindow_list
;
1731 CONSP (list
) && !EQ (XCAR (list
), window
);
1733 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1737 window
= XCAR (list
);
1741 Lisp_Object candidate
, list
;
1743 /* Scan through the list of windows for candidates. If there are
1744 candidate windows in front of WINDOW, the last one of these
1745 is the one we want. If there are candidates following WINDOW
1746 in the list, again the last one of these is the one we want. */
1748 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1750 if (EQ (XCAR (list
), window
))
1752 if (WINDOWP (candidate
))
1755 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1757 candidate
= XCAR (list
);
1760 if (WINDOWP (candidate
))
1768 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1769 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1770 If omitted, WINDOW defaults to the selected window.
1772 Optional second arg MINIBUF t means count the minibuffer window even
1773 if not active. MINIBUF nil or omitted means count the minibuffer iff
1774 it is active. MINIBUF neither t nor nil means not to count the
1775 minibuffer even if it is active.
1777 Several frames may share a single minibuffer; if the minibuffer
1778 counts, all windows on all frames that share that minibuffer count
1779 too. Therefore, `next-window' can be used to iterate through the
1780 set of windows even when the minibuffer is on another frame. If the
1781 minibuffer does not count, only windows from WINDOW's frame count.
1783 Optional third arg ALL-FRAMES t means include windows on all frames.
1784 ALL-FRAMES nil or omitted means cycle within the frames as specified
1785 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1786 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1787 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1788 Anything else means restrict to WINDOW's frame.
1790 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1791 `next-window' to iterate through the entire cycle of acceptable
1792 windows, eventually ending up back at the window you started with.
1793 `previous-window' traverses the same cycle, in the reverse order. */)
1794 (window
, minibuf
, all_frames
)
1795 Lisp_Object window
, minibuf
, all_frames
;
1797 return next_window (window
, minibuf
, all_frames
, 1);
1801 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1802 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1803 If omitted, WINDOW defaults to the selected window.
1805 Optional second arg MINIBUF t means count the minibuffer window even
1806 if not active. MINIBUF nil or omitted means count the minibuffer iff
1807 it is active. MINIBUF neither t nor nil means not to count the
1808 minibuffer even if it is active.
1810 Several frames may share a single minibuffer; if the minibuffer
1811 counts, all windows on all frames that share that minibuffer count
1812 too. Therefore, `previous-window' can be used to iterate through
1813 the set of windows even when the minibuffer is on another frame. If
1814 the minibuffer does not count, only windows from WINDOW's frame count
1816 Optional third arg ALL-FRAMES t means include windows on all frames.
1817 ALL-FRAMES nil or omitted means cycle within the frames as specified
1818 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1819 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1820 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1821 Anything else means restrict to WINDOW's frame.
1823 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1824 `previous-window' to iterate through the entire cycle of acceptable
1825 windows, eventually ending up back at the window you started with.
1826 `next-window' traverses the same cycle, in the reverse order. */)
1827 (window
, minibuf
, all_frames
)
1828 Lisp_Object window
, minibuf
, all_frames
;
1830 return next_window (window
, minibuf
, all_frames
, 0);
1834 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1835 doc
: /* Select the ARG'th different window on this frame.
1836 All windows on current frame are arranged in a cyclic order.
1837 This command selects the window ARG steps away in that order.
1838 A negative ARG moves in the opposite order. The optional second
1839 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1841 Lisp_Object arg
, all_frames
;
1847 window
= selected_window
;
1849 for (i
= XINT (arg
); i
> 0; --i
)
1850 window
= Fnext_window (window
, Qnil
, all_frames
);
1852 window
= Fprevious_window (window
, Qnil
, all_frames
);
1854 Fselect_window (window
, Qnil
);
1859 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1860 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1861 FRAME nil or omitted means use the selected frame.
1862 WINDOW nil or omitted means use the selected window.
1863 MINIBUF t means include the minibuffer window, even if it isn't active.
1864 MINIBUF nil or omitted means include the minibuffer window only
1866 MINIBUF neither nil nor t means never include the minibuffer window. */)
1867 (frame
, minibuf
, window
)
1868 Lisp_Object frame
, minibuf
, window
;
1871 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
1872 CHECK_WINDOW (window
);
1874 frame
= selected_frame
;
1876 if (!EQ (frame
, XWINDOW (window
)->frame
))
1877 error ("Window is on a different frame");
1879 return window_list_1 (window
, minibuf
, frame
);
1883 /* Return a list of windows in canonical ordering. Arguments are like
1884 for `next-window'. */
1887 window_list_1 (window
, minibuf
, all_frames
)
1888 Lisp_Object window
, minibuf
, all_frames
;
1890 Lisp_Object tail
, list
, rest
;
1892 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1895 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1896 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1897 list
= Fcons (XCAR (tail
), list
);
1899 /* Rotate the list to start with WINDOW. */
1900 list
= Fnreverse (list
);
1901 rest
= Fmemq (window
, list
);
1902 if (!NILP (rest
) && !EQ (rest
, list
))
1904 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1906 XSETCDR (tail
, Qnil
);
1907 list
= nconc2 (rest
, list
);
1914 /* Look at all windows, performing an operation specified by TYPE
1916 If FRAMES is Qt, look at all frames;
1917 Qnil, look at just the selected frame;
1918 Qvisible, look at visible frames;
1919 a frame, just look at windows on that frame.
1920 If MINI is non-zero, perform the operation on minibuffer windows too. */
1925 GET_BUFFER_WINDOW
, /* Arg is buffer */
1926 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1927 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1928 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1930 UNSHOW_BUFFER
, /* Arg is buffer */
1931 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1936 window_loop (type
, obj
, mini
, frames
)
1937 enum window_loop type
;
1938 Lisp_Object obj
, frames
;
1941 Lisp_Object window
, windows
, best_window
, frame_arg
;
1943 struct gcpro gcpro1
;
1945 /* If we're only looping through windows on a particular frame,
1946 frame points to that frame. If we're looping through windows
1947 on all frames, frame is 0. */
1948 if (FRAMEP (frames
))
1949 f
= XFRAME (frames
);
1950 else if (NILP (frames
))
1951 f
= SELECTED_FRAME ();
1956 frame_arg
= Qlambda
;
1957 else if (EQ (frames
, make_number (0)))
1959 else if (EQ (frames
, Qvisible
))
1964 /* frame_arg is Qlambda to stick to one frame,
1965 Qvisible to consider all visible frames,
1968 /* Pick a window to start with. */
1972 window
= FRAME_SELECTED_WINDOW (f
);
1974 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1976 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1980 for (; CONSP (windows
); windows
= XCDR (windows
))
1984 window
= XCAR (windows
);
1985 w
= XWINDOW (window
);
1987 /* Note that we do not pay attention here to whether the frame
1988 is visible, since Fwindow_list skips non-visible frames if
1989 that is desired, under the control of frame_arg. */
1990 if (!MINI_WINDOW_P (w
)
1991 /* For UNSHOW_BUFFER, we must always consider all windows. */
1992 || type
== UNSHOW_BUFFER
1993 || (mini
&& minibuf_level
> 0))
1996 case GET_BUFFER_WINDOW
:
1997 if (EQ (w
->buffer
, obj
)
1998 /* Don't find any minibuffer window
1999 except the one that is currently in use. */
2000 && (MINI_WINDOW_P (w
)
2001 ? EQ (window
, minibuf_window
)
2004 if (NILP (best_window
))
2005 best_window
= window
;
2006 else if (EQ (window
, selected_window
))
2007 /* For compatibility with 20.x, prefer to return
2009 best_window
= window
;
2013 case GET_LRU_WINDOW
:
2014 /* `obj' is an integer encoding a bitvector.
2015 `obj & 1' means consider only full-width windows.
2016 `obj & 2' means consider also dedicated windows. */
2017 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2018 || (!(XINT (obj
) & 2) && EQ (w
->dedicated
, Qt
))
2019 /* Minibuffer windows are always ignored. */
2020 || MINI_WINDOW_P (w
))
2022 if (NILP (best_window
)
2023 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2024 > XFASTINT (w
->use_time
)))
2025 best_window
= window
;
2028 case DELETE_OTHER_WINDOWS
:
2029 if (!EQ (window
, obj
))
2030 Fdelete_window (window
);
2033 case DELETE_BUFFER_WINDOWS
:
2034 if (EQ (w
->buffer
, obj
))
2036 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2038 /* If this window is dedicated, and in a frame of its own,
2040 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2041 && !NILP (w
->dedicated
)
2042 && other_visible_frames (f
))
2044 /* Skip the other windows on this frame.
2045 There might be one, the minibuffer! */
2046 while (CONSP (XCDR (windows
))
2047 && EQ (XWINDOW (XCAR (windows
))->frame
,
2048 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2049 windows
= XCDR (windows
);
2051 /* Now we can safely delete the frame. */
2052 Fdelete_frame (w
->frame
, Qnil
);
2054 else if (NILP (w
->parent
))
2056 /* If we're deleting the buffer displayed in the
2057 only window on the frame, find a new buffer to
2060 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2061 Fset_window_buffer (window
, buffer
, Qnil
);
2062 if (EQ (window
, selected_window
))
2063 Fset_buffer (w
->buffer
);
2066 Fdelete_window (window
);
2070 case GET_LARGEST_WINDOW
:
2071 { /* nil `obj' means to ignore dedicated windows. */
2072 /* Ignore dedicated windows and minibuffers. */
2073 if (MINI_WINDOW_P (w
) || (NILP (obj
) && EQ (w
->dedicated
, Qt
)))
2076 if (NILP (best_window
))
2077 best_window
= window
;
2080 struct window
*b
= XWINDOW (best_window
);
2081 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2082 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2083 best_window
= window
;
2089 if (EQ (w
->buffer
, obj
))
2092 struct frame
*f
= XFRAME (w
->frame
);
2094 /* Find another buffer to show in this window. */
2095 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2097 /* If this window is dedicated, and in a frame of its own,
2099 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2100 && !NILP (w
->dedicated
)
2101 && other_visible_frames (f
))
2103 /* Skip the other windows on this frame.
2104 There might be one, the minibuffer! */
2105 while (CONSP (XCDR (windows
))
2106 && EQ (XWINDOW (XCAR (windows
))->frame
,
2107 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2108 windows
= XCDR (windows
);
2110 /* Now we can safely delete the frame. */
2111 Fdelete_frame (w
->frame
, Qnil
);
2113 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2116 XSETWINDOW (window
, w
);
2117 /* If this window is dedicated and not the only window
2118 in its frame, then kill it. */
2119 Fdelete_window (window
);
2123 /* Otherwise show a different buffer in the window. */
2124 w
->dedicated
= Qnil
;
2125 Fset_window_buffer (window
, buffer
, Qnil
);
2126 if (EQ (window
, selected_window
))
2127 Fset_buffer (w
->buffer
);
2132 case REDISPLAY_BUFFER_WINDOWS
:
2133 if (EQ (w
->buffer
, obj
))
2135 mark_window_display_accurate (window
, 0);
2136 w
->update_mode_line
= Qt
;
2137 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2138 ++update_mode_lines
;
2139 best_window
= window
;
2143 /* Check for a window that has a killed buffer. */
2144 case CHECK_ALL_WINDOWS
:
2145 if (! NILP (w
->buffer
)
2146 && NILP (XBUFFER (w
->buffer
)->name
))
2150 case WINDOW_LOOP_UNUSED
:
2159 /* Used for debugging. Abort if any window has a dead buffer. */
2162 check_all_windows ()
2164 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2167 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2168 doc
: /* Return the window least recently selected or used for display.
2169 Return a full-width window if possible.
2170 A minibuffer window is never a candidate.
2171 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2172 so if all windows are dedicated, the value is nil.
2173 If optional argument FRAME is `visible', search all visible frames.
2174 If FRAME is 0, search all visible and iconified frames.
2175 If FRAME is t, search all frames.
2176 If FRAME is nil, search only the selected frame.
2177 If FRAME is a frame, search only that frame. */)
2179 Lisp_Object frame
, dedicated
;
2181 register Lisp_Object w
;
2182 /* First try for a window that is full-width */
2183 w
= window_loop (GET_LRU_WINDOW
,
2184 NILP (dedicated
) ? make_number (1) : make_number (3),
2186 if (!NILP (w
) && !EQ (w
, selected_window
))
2188 /* If none of them, try the rest */
2189 return window_loop (GET_LRU_WINDOW
,
2190 NILP (dedicated
) ? make_number (0) : make_number (2),
2194 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2195 doc
: /* Return the largest window in area.
2196 A minibuffer window is never a candidate.
2197 A dedicated window is never a candidate unless DEDICATED is non-nil,
2198 so if all windows are dedicated, the value is nil.
2199 If optional argument FRAME is `visible', search all visible frames.
2200 If FRAME is 0, search all visible and iconified frames.
2201 If FRAME is t, search all frames.
2202 If FRAME is nil, search only the selected frame.
2203 If FRAME is a frame, search only that frame. */)
2205 Lisp_Object frame
, dedicated
;
2207 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2211 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2212 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2213 BUFFER can be a buffer or a buffer name.
2214 If optional argument FRAME is `visible', search all visible frames.
2215 If optional argument FRAME is 0, search all visible and iconified frames.
2216 If FRAME is t, search all frames.
2217 If FRAME is nil, search only the selected frame.
2218 If FRAME is a frame, search only that frame. */)
2220 Lisp_Object buffer
, frame
;
2222 buffer
= Fget_buffer (buffer
);
2223 if (BUFFERP (buffer
))
2224 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2229 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2231 doc
: /* Make WINDOW (or the selected window) fill its frame.
2232 Only the frame WINDOW is on is affected.
2233 This function tries to reduce display jumps
2234 by keeping the text previously visible in WINDOW
2235 in the same place on the frame. Doing this depends on
2236 the value of (window-start WINDOW), so if calling this function
2237 in a program gives strange scrolling, make sure the window-start
2238 value is reasonable when this function is called. */)
2247 window
= selected_window
;
2249 CHECK_LIVE_WINDOW (window
);
2250 w
= XWINDOW (window
);
2252 startpos
= marker_position (w
->start
);
2253 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2255 if (MINI_WINDOW_P (w
) && top
> 0)
2256 error ("Can't expand minibuffer to full frame");
2258 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2260 /* Try to minimize scrolling, by setting the window start to the point
2261 will cause the text at the old window start to be at the same place
2262 on the frame. But don't try to do this if the window start is
2263 outside the visible portion (as might happen when the display is
2264 not current, due to typeahead). */
2265 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2267 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2268 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2270 struct position pos
;
2271 struct buffer
*obuf
= current_buffer
;
2273 Fset_buffer (w
->buffer
);
2274 /* This computation used to temporarily move point, but that can
2275 have unwanted side effects due to text properties. */
2276 pos
= *vmotion (startpos
, -top
, w
);
2278 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2279 w
->window_end_valid
= Qnil
;
2280 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2281 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2283 /* We need to do this, so that the window-scroll-functions
2285 w
->optional_new_start
= Qt
;
2287 set_buffer_internal (obuf
);
2293 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2294 1, 2, "bDelete windows on (buffer): ",
2295 doc
: /* Delete all windows showing BUFFER.
2296 BUFFER must be a buffer or the name of an existing buffer.
2297 Optional second argument FRAME controls which frames are affected.
2298 If optional argument FRAME is `visible', search all visible frames.
2299 If FRAME is 0, search all visible and iconified frames.
2300 If FRAME is nil, search all frames.
2301 If FRAME is t, search only the selected frame.
2302 If FRAME is a frame, search only that frame. */)
2304 Lisp_Object buffer
, frame
;
2306 /* FRAME uses t and nil to mean the opposite of what window_loop
2310 else if (EQ (frame
, Qt
))
2315 buffer
= Fget_buffer (buffer
);
2316 CHECK_BUFFER (buffer
);
2317 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2323 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2324 Sreplace_buffer_in_windows
,
2325 1, 1, "bReplace buffer in windows: ",
2326 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2327 BUFFER may be a buffer or the name of an existing buffer. */)
2333 buffer
= Fget_buffer (buffer
);
2334 CHECK_BUFFER (buffer
);
2335 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2340 /* Replace BUFFER with some other buffer in all windows
2341 of all frames, even those on other keyboards. */
2344 replace_buffer_in_all_windows (buffer
)
2348 Lisp_Object tail
, frame
;
2350 /* A single call to window_loop won't do the job
2351 because it only considers frames on the current keyboard.
2352 So loop manually over frames, and handle each one. */
2353 FOR_EACH_FRAME (tail
, frame
)
2354 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2356 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2360 /* Set the height of WINDOW and all its inferiors. */
2362 /* The smallest acceptable dimensions for a window. Anything smaller
2363 might crash Emacs. */
2365 #define MIN_SAFE_WINDOW_WIDTH (2)
2366 #define MIN_SAFE_WINDOW_HEIGHT (1)
2368 /* Make sure that window_min_height and window_min_width are
2369 not too small; if they are, set them to safe minima. */
2372 check_min_window_sizes ()
2374 /* Smaller values might permit a crash. */
2375 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2376 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2377 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2378 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2381 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2382 minimum allowable size. */
2385 check_frame_size (frame
, rows
, cols
)
2389 /* For height, we have to see:
2390 how many windows the frame has at minimum (one or two),
2391 and whether it has a menu bar or other special stuff at the top. */
2393 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2394 ? MIN_SAFE_WINDOW_HEIGHT
2395 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2397 if (FRAME_TOP_MARGIN (frame
) > 0)
2398 min_height
+= FRAME_TOP_MARGIN (frame
);
2400 if (*rows
< min_height
)
2402 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2403 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2407 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2408 check if W's width can be changed, otherwise check W's height.
2409 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2410 siblings, too. If none of the siblings is resizable, WINDOW isn't
2414 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2416 int width_p
, check_siblings_p
;
2421 if (!NILP (w
->hchild
))
2423 c
= XWINDOW (w
->hchild
);
2427 /* A horiz. combination is fixed-width if all of if its
2429 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2430 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2431 fixed_p
= c
== NULL
;
2435 /* A horiz. combination is fixed-height if one of if its
2437 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2438 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2439 fixed_p
= c
!= NULL
;
2442 else if (!NILP (w
->vchild
))
2444 c
= XWINDOW (w
->vchild
);
2448 /* A vert. combination is fixed-width if one of if its
2450 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2451 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2452 fixed_p
= c
!= NULL
;
2456 /* A vert. combination is fixed-height if all of if its
2458 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2459 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2460 fixed_p
= c
== NULL
;
2463 else if (BUFFERP (w
->buffer
))
2465 struct buffer
*old
= current_buffer
;
2468 current_buffer
= XBUFFER (w
->buffer
);
2469 val
= find_symbol_value (Qwindow_size_fixed
);
2470 current_buffer
= old
;
2473 if (!EQ (val
, Qunbound
))
2475 fixed_p
= !NILP (val
);
2478 && ((EQ (val
, Qheight
) && width_p
)
2479 || (EQ (val
, Qwidth
) && !width_p
)))
2483 /* Can't tell if this one is resizable without looking at
2484 siblings. If all siblings are fixed-size this one is too. */
2485 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2489 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2490 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2494 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2495 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2509 /* Return the minimum size of window W, not taking fixed-width windows
2510 into account. WIDTH_P non-zero means return the minimum width,
2511 otherwise return the minimum height. If W is a combination window,
2512 compute the minimum size from the minimum sizes of W's children. */
2515 window_min_size_1 (w
, width_p
)
2522 if (!NILP (w
->hchild
))
2524 c
= XWINDOW (w
->hchild
);
2529 /* The min width of a horizontal combination is
2530 the sum of the min widths of its children. */
2533 size
+= window_min_size_1 (c
, width_p
);
2534 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2539 /* The min height a horizontal combination equals
2540 the maximum of all min height of its children. */
2543 int min_size
= window_min_size_1 (c
, width_p
);
2544 size
= max (min_size
, size
);
2545 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2549 else if (!NILP (w
->vchild
))
2551 c
= XWINDOW (w
->vchild
);
2556 /* The min width of a vertical combination is
2557 the maximum of the min widths of its children. */
2560 int min_size
= window_min_size_1 (c
, width_p
);
2561 size
= max (min_size
, size
);
2562 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2567 /* The min height of a vertical combination equals
2568 the sum of the min height of its children. */
2571 size
+= window_min_size_1 (c
, width_p
);
2572 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2579 size
= max (window_min_width
,
2580 (MIN_SAFE_WINDOW_WIDTH
2581 + WINDOW_FRINGE_COLS (w
)
2582 + WINDOW_SCROLL_BAR_COLS (w
)));
2585 if (MINI_WINDOW_P (w
)
2586 || (!WINDOW_WANTS_MODELINE_P (w
)
2587 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2590 size
= window_min_height
;
2598 /* Return the minimum size of window W, taking fixed-size windows into
2599 account. WIDTH_P non-zero means return the minimum width,
2600 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2601 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2602 unless FIXED is null. */
2605 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2607 int width_p
, ignore_fixed_p
, *fixed
;
2614 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2620 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2622 size
= window_min_size_1 (w
, width_p
);
2628 /* Adjust the margins of window W if text area is too small.
2629 Return 1 if window width is ok after adjustment; 0 if window
2630 is still too narrow. */
2633 adjust_window_margins (w
)
2636 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2637 - WINDOW_FRINGE_COLS (w
)
2638 - WINDOW_SCROLL_BAR_COLS (w
));
2639 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2640 + WINDOW_RIGHT_MARGIN_COLS (w
));
2642 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2645 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2648 /* Window's text area is too narrow, but reducing the window
2649 margins will fix that. */
2650 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2651 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2653 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2654 w
->left_margin_cols
= w
->right_margin_cols
2655 = make_number (margin_cols
/2);
2657 w
->right_margin_cols
= make_number (margin_cols
);
2660 w
->left_margin_cols
= make_number (margin_cols
);
2664 /* Calculate new sizes for windows in the list FORWARD when the window size
2665 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2666 The number of windows in FORWARD is NCHILDREN, and the number that
2667 can shrink is SHRINKABLE.
2668 The minimum size a window can have is MIN_SIZE.
2669 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2670 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2673 This function returns an allocated array of new sizes that the caller
2674 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2675 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2676 the second, and so on.
2678 This function tries to keep windows at least at the minimum size
2679 and resize other windows before it resizes any window to zero (i.e.
2680 delete that window).
2682 Windows are resized proportional to their size, so bigger windows
2683 shrink more than smaller windows. */
2685 shrink_windows (total
, size
, nchildren
, shrinkable
,
2686 min_size
, resize_fixed_p
, forward
, width_p
)
2687 int total
, size
, nchildren
, shrinkable
, min_size
;
2688 int resize_fixed_p
, width_p
;
2689 Lisp_Object forward
;
2691 int available_resize
= 0;
2695 int smallest
= total
;
2696 int total_removed
= 0;
2697 int total_shrink
= total
- size
;
2700 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2702 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2706 c
= XWINDOW (child
);
2707 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2709 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2713 new_sizes
[i
] = child_size
;
2714 if (child_size
> min_size
)
2715 available_resize
+= child_size
- min_size
;
2718 /* We might need to shrink some windows to zero. Find the smallest
2719 windows and set them to 0 until we can fulfil the new size. */
2721 while (shrinkable
> 1 && size
+ available_resize
< total
)
2723 for (i
= 0; i
< nchildren
; ++i
)
2724 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2725 smallest
= new_sizes
[i
];
2727 for (i
= 0; i
< nchildren
; ++i
)
2728 if (new_sizes
[i
] == smallest
)
2730 /* Resize this window down to zero. */
2732 if (smallest
> min_size
)
2733 available_resize
-= smallest
- min_size
;
2734 available_resize
+= smallest
;
2736 total_removed
+= smallest
;
2738 /* We don't know what the smallest is now. */
2741 /* Out of for, just remove one window at the time and
2742 check again if we have enough space. */
2747 /* Now, calculate the new sizes. Try to shrink each window
2748 proportional to its size. */
2749 for (i
= 0; i
< nchildren
; ++i
)
2751 if (new_sizes
[i
] > min_size
)
2753 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2754 if (new_sizes
[i
] - to_shrink
< min_size
)
2755 to_shrink
= new_sizes
[i
] - min_size
;
2756 new_sizes
[i
] -= to_shrink
;
2757 total_removed
+= to_shrink
;
2761 /* Any reminder due to rounding, we just subtract from windows
2762 that are left and still can be shrunk. */
2763 while (total_shrink
> total_removed
)
2765 int nonzero_sizes
= 0;
2766 int nonzero_idx
= -1;
2768 for (i
= 0; i
< nchildren
; ++i
)
2769 if (new_sizes
[i
] > 0)
2775 for (i
= 0; i
< nchildren
; ++i
)
2776 if (new_sizes
[i
] > min_size
)
2781 /* Out of for, just shrink one window at the time and
2782 check again if we have enough space. */
2787 /* Special case, only one window left. */
2788 if (nonzero_sizes
== 1)
2792 /* Any surplus due to rounding, we add to windows that are left. */
2793 while (total_shrink
< total_removed
)
2795 for (i
= 0; i
< nchildren
; ++i
)
2797 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2809 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2810 WINDOW's width. Resize WINDOW's children, if any, so that they
2811 keep their proportionate size relative to WINDOW. Propagate
2812 WINDOW's top or left edge position to children. Delete windows
2813 that become too small unless NODELETE_P is non-zero.
2815 If NODELETE_P is 2, that means we do delete windows that are
2816 too small, even if they were too small before! */
2819 size_window (window
, size
, width_p
, nodelete_p
)
2821 int size
, width_p
, nodelete_p
;
2823 struct window
*w
= XWINDOW (window
);
2825 Lisp_Object child
, *forward
, *sideward
;
2826 int old_size
, min_size
, safe_min_size
;
2828 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2829 seems like it's too soon to do this here. ++KFS. */
2830 if (nodelete_p
== 2)
2833 check_min_window_sizes ();
2834 size
= max (0, size
);
2836 /* If the window has been "too small" at one point,
2837 don't delete it for being "too small" in the future.
2838 Preserve it as long as that is at all possible. */
2841 old_size
= WINDOW_TOTAL_COLS (w
);
2842 min_size
= window_min_width
;
2843 /* Ensure that there is room for the scroll bar and fringes!
2844 We may reduce display margins though. */
2845 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2846 + WINDOW_FRINGE_COLS (w
)
2847 + WINDOW_SCROLL_BAR_COLS (w
));
2851 old_size
= XINT (w
->total_lines
);
2852 min_size
= window_min_height
;
2853 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2856 if (old_size
< min_size
&& nodelete_p
!= 2)
2857 w
->too_small_ok
= Qt
;
2859 /* Maybe delete WINDOW if it's too small. */
2860 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2862 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2863 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2864 if (min_size
< safe_min_size
)
2865 min_size
= safe_min_size
;
2866 if (size
< min_size
)
2868 delete_window (window
);
2873 /* Set redisplay hints. */
2874 w
->last_modified
= make_number (0);
2875 w
->last_overlay_modified
= make_number (0);
2876 windows_or_buffers_changed
++;
2877 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2881 sideward
= &w
->vchild
;
2882 forward
= &w
->hchild
;
2883 w
->total_cols
= make_number (size
);
2884 adjust_window_margins (w
);
2888 sideward
= &w
->hchild
;
2889 forward
= &w
->vchild
;
2890 w
->total_lines
= make_number (size
);
2891 w
->orig_total_lines
= Qnil
;
2894 if (!NILP (*sideward
))
2896 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2898 c
= XWINDOW (child
);
2900 c
->left_col
= w
->left_col
;
2902 c
->top_line
= w
->top_line
;
2903 size_window (child
, size
, width_p
, nodelete_p
);
2906 else if (!NILP (*forward
))
2908 int fixed_size
, each
, extra
, n
;
2909 int resize_fixed_p
, nfixed
;
2910 int last_pos
, first_pos
, nchildren
, total
;
2911 int *new_sizes
= NULL
;
2913 /* Determine the fixed-size portion of the this window, and the
2914 number of child windows. */
2915 fixed_size
= nchildren
= nfixed
= total
= 0;
2916 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2920 c
= XWINDOW (child
);
2921 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2922 total
+= child_size
;
2924 if (window_fixed_size_p (c
, width_p
, 0))
2926 fixed_size
+= child_size
;
2931 /* If the new size is smaller than fixed_size, or if there
2932 aren't any resizable windows, allow resizing fixed-size
2934 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2936 /* Compute how many lines/columns to add/remove to each child. The
2937 value of extra takes care of rounding errors. */
2938 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2939 if (size
< total
&& n
> 1)
2940 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2941 resize_fixed_p
, *forward
, width_p
);
2944 each
= (size
- total
) / n
;
2945 extra
= (size
- total
) - n
* each
;
2948 /* Compute new children heights and edge positions. */
2949 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2950 last_pos
= first_pos
;
2951 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2953 int new_size
, old_size
;
2955 c
= XWINDOW (child
);
2956 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2957 new_size
= old_size
;
2959 /* The top or left edge position of this child equals the
2960 bottom or right edge of its predecessor. */
2962 c
->left_col
= make_number (last_pos
);
2964 c
->top_line
= make_number (last_pos
);
2966 /* If this child can be resized, do it. */
2967 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2969 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2973 /* Set new height. Note that size_window also propagates
2974 edge positions to children, so it's not a no-op if we
2975 didn't change the child's size. */
2976 size_window (child
, new_size
, width_p
, 1);
2978 /* Remember the bottom/right edge position of this child; it
2979 will be used to set the top/left edge of the next child. */
2980 last_pos
+= new_size
;
2983 if (new_sizes
) xfree (new_sizes
);
2985 /* We should have covered the parent exactly with child windows. */
2986 xassert (size
== last_pos
- first_pos
);
2988 /* Now delete any children that became too small. */
2990 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2993 c
= XWINDOW (child
);
2994 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2995 size_window (child
, child_size
, width_p
, 2);
3000 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3001 WINDOW's children. NODELETE non-zero means don't delete windows
3002 that become too small in the process. (The caller should check
3003 later and do so if appropriate.) */
3006 set_window_height (window
, height
, nodelete
)
3011 size_window (window
, height
, 0, nodelete
);
3015 /* Set WINDOW's width to WIDTH, and recursively change the width of
3016 WINDOW's children. NODELETE non-zero means don't delete windows
3017 that become too small in the process. (The caller should check
3018 later and do so if appropriate.) */
3021 set_window_width (window
, width
, nodelete
)
3026 size_window (window
, width
, 1, nodelete
);
3029 /* Change window heights in windows rooted in WINDOW by N lines. */
3032 change_window_heights (window
, n
)
3036 struct window
*w
= XWINDOW (window
);
3038 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3039 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3041 if (INTEGERP (w
->orig_top_line
))
3042 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3043 if (INTEGERP (w
->orig_total_lines
))
3044 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3046 /* Handle just the top child in a vertical split. */
3047 if (!NILP (w
->vchild
))
3048 change_window_heights (w
->vchild
, n
);
3050 /* Adjust all children in a horizontal split. */
3051 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3053 w
= XWINDOW (window
);
3054 change_window_heights (window
, n
);
3059 int window_select_count
;
3062 Fset_window_buffer_unwind (obuf
)
3069 EXFUN (Fset_window_fringes
, 4);
3070 EXFUN (Fset_window_scroll_bars
, 4);
3072 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3073 means it's allowed to run hooks. See make_frame for a case where
3074 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3075 margins, fringes, and scroll-bar settings of the window are not
3076 reset from the buffer's local settings. */
3079 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3080 Lisp_Object window
, buffer
;
3081 int run_hooks_p
, keep_margins_p
;
3083 struct window
*w
= XWINDOW (window
);
3084 struct buffer
*b
= XBUFFER (buffer
);
3085 int count
= SPECPDL_INDEX ();
3089 if (EQ (window
, selected_window
))
3090 b
->last_selected_window
= window
;
3092 /* Let redisplay errors through. */
3093 b
->display_error_modiff
= 0;
3095 /* Update time stamps of buffer display. */
3096 if (INTEGERP (b
->display_count
))
3097 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3098 b
->display_time
= Fcurrent_time ();
3100 XSETFASTINT (w
->window_end_pos
, 0);
3101 XSETFASTINT (w
->window_end_vpos
, 0);
3102 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3103 w
->window_end_valid
= Qnil
;
3104 w
->hscroll
= w
->min_hscroll
= make_number (0);
3106 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3107 set_marker_restricted (w
->start
,
3108 make_number (b
->last_window_start
),
3110 w
->start_at_line_beg
= Qnil
;
3111 w
->force_start
= Qnil
;
3112 XSETFASTINT (w
->last_modified
, 0);
3113 XSETFASTINT (w
->last_overlay_modified
, 0);
3114 windows_or_buffers_changed
++;
3116 /* We must select BUFFER for running the window-scroll-functions.
3117 If WINDOW is selected, switch permanently.
3118 Otherwise, switch but go back to the ambient buffer afterward. */
3119 if (EQ (window
, selected_window
))
3120 Fset_buffer (buffer
);
3121 /* We can't check ! NILP (Vwindow_scroll_functions) here
3122 because that might itself be a local variable. */
3123 else if (window_initialized
)
3125 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3126 Fset_buffer (buffer
);
3129 if (!keep_margins_p
)
3131 /* Set left and right marginal area width etc. from buffer. */
3133 /* This may call adjust_window_margins three times, so
3134 temporarily disable window margins. */
3135 Lisp_Object save_left
= w
->left_margin_cols
;
3136 Lisp_Object save_right
= w
->right_margin_cols
;
3138 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3140 Fset_window_fringes (window
,
3141 b
->left_fringe_width
, b
->right_fringe_width
,
3142 b
->fringes_outside_margins
);
3144 Fset_window_scroll_bars (window
,
3145 b
->scroll_bar_width
,
3146 b
->vertical_scroll_bar_type
, Qnil
);
3148 w
->left_margin_cols
= save_left
;
3149 w
->right_margin_cols
= save_right
;
3151 Fset_window_margins (window
,
3152 b
->left_margin_cols
, b
->right_margin_cols
);
3157 if (! NILP (Vwindow_scroll_functions
))
3158 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3159 Fmarker_position (w
->start
));
3161 if (! NILP (Vwindow_configuration_change_hook
)
3162 && ! NILP (Vrun_hooks
))
3163 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3166 unbind_to (count
, Qnil
);
3170 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3171 doc
: /* Make WINDOW display BUFFER as its contents.
3172 BUFFER can be a buffer or the name of an existing buffer.
3173 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3174 display margins, fringe widths, and scroll bar settings are maintained;
3175 the default is to reset these from BUFFER's local settings or the frame
3178 This function runs the hook `window-scroll-functions'. */)
3179 (window
, buffer
, keep_margins
)
3180 register Lisp_Object window
, buffer
, keep_margins
;
3182 register Lisp_Object tem
;
3183 register struct window
*w
= decode_window (window
);
3185 XSETWINDOW (window
, w
);
3186 buffer
= Fget_buffer (buffer
);
3187 CHECK_BUFFER (buffer
);
3189 if (NILP (XBUFFER (buffer
)->name
))
3190 error ("Attempt to display deleted buffer");
3194 error ("Window is deleted");
3195 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3196 is first being set up. */
3198 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3199 error ("Window is dedicated to `%s'",
3200 SDATA (XBUFFER (tem
)->name
));
3205 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3209 /* Note that selected_window can be nil
3210 when this is called from Fset_window_configuration. */
3212 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3213 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3214 If WINDOW is not already selected, make WINDOW's buffer current
3215 and make WINDOW the frame's selected window. Return WINDOW.
3216 Optional second arg NORECORD non-nil means
3217 do not put this buffer at the front of the list of recently selected ones.
3219 Note that the main editor command loop
3220 selects the buffer of the selected window before each command. */)
3222 register Lisp_Object window
, norecord
;
3224 register struct window
*w
;
3225 register struct window
*ow
;
3228 CHECK_LIVE_WINDOW (window
);
3230 w
= XWINDOW (window
);
3231 w
->frozen_window_start_p
= 0;
3233 ++window_select_count
;
3234 XSETFASTINT (w
->use_time
, window_select_count
);
3235 if (EQ (window
, selected_window
))
3238 /* Store the current buffer's actual point into the
3239 old selected window. It belongs to that window,
3240 and when the window is not selected, must be in the window. */
3241 if (!NILP (selected_window
))
3243 ow
= XWINDOW (selected_window
);
3244 if (! NILP (ow
->buffer
))
3245 set_marker_both (ow
->pointm
, ow
->buffer
,
3246 BUF_PT (XBUFFER (ow
->buffer
)),
3247 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3250 selected_window
= window
;
3251 sf
= SELECTED_FRAME ();
3252 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3254 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3255 /* Use this rather than Fhandle_switch_frame
3256 so that FRAME_FOCUS_FRAME is moved appropriately as we
3257 move around in the state where a minibuffer in a separate
3259 Fselect_frame (WINDOW_FRAME (w
));
3262 sf
->selected_window
= window
;
3264 if (NILP (norecord
))
3265 record_buffer (w
->buffer
);
3266 Fset_buffer (w
->buffer
);
3268 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3270 /* Go to the point recorded in the window.
3271 This is important when the buffer is in more
3272 than one window. It also matters when
3273 redisplay_window has altered point after scrolling,
3274 because it makes the change only in the window. */
3276 register int new_point
= marker_position (w
->pointm
);
3277 if (new_point
< BEGV
)
3279 else if (new_point
> ZV
)
3285 windows_or_buffers_changed
++;
3290 select_window_norecord (window
)
3293 return Fselect_window (window
, Qt
);
3296 /* Deiconify the frame containing the window WINDOW,
3297 unless it is the selected frame;
3300 The reason for the exception for the selected frame
3301 is that it seems better not to change the selected frames visibility
3302 merely because of displaying a different buffer in it.
3303 The deiconification is useful when a buffer gets shown in
3304 another frame that you were not using lately. */
3307 display_buffer_1 (window
)
3310 Lisp_Object frame
= XWINDOW (window
)->frame
;
3311 FRAME_PTR f
= XFRAME (frame
);
3313 FRAME_SAMPLE_VISIBILITY (f
);
3315 if (EQ (frame
, selected_frame
))
3316 ; /* Assume the selected frame is already visible enough. */
3317 else if (minibuf_level
> 0
3318 && MINI_WINDOW_P (XWINDOW (selected_window
))
3319 && WINDOW_LIVE_P (minibuf_selected_window
)
3320 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3321 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3324 if (FRAME_ICONIFIED_P (f
))
3325 Fmake_frame_visible (frame
);
3326 else if (FRAME_VISIBLE_P (f
))
3327 Fraise_frame (frame
);
3333 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3334 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3335 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3336 special frame for that buffer using the default frame parameters.
3338 If the value is a list, it is a list of frame parameters that would be used
3339 to make a frame for that buffer.
3340 The variables `special-display-buffer-names'
3341 and `special-display-regexps' control this. */)
3343 Lisp_Object buffer_name
;
3347 CHECK_STRING (buffer_name
);
3349 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3353 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3357 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3359 Lisp_Object car
= XCAR (tem
);
3361 && fast_string_match (car
, buffer_name
) >= 0)
3363 else if (CONSP (car
)
3364 && STRINGP (XCAR (car
))
3365 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3371 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3372 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3373 More precisely, if `display-buffer' or `pop-to-buffer' would display
3374 that buffer in the selected window rather than (as usual) in some other window.
3375 See `same-window-buffer-names' and `same-window-regexps'. */)
3377 Lisp_Object buffer_name
;
3381 CHECK_STRING (buffer_name
);
3383 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3387 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3391 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3393 Lisp_Object car
= XCAR (tem
);
3395 && fast_string_match (car
, buffer_name
) >= 0)
3397 else if (CONSP (car
)
3398 && STRINGP (XCAR (car
))
3399 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3405 /* Use B so the default is (other-buffer). */
3406 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3407 "BDisplay buffer: \nP",
3408 doc
: /* Make BUFFER appear in some window but don't select it.
3409 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3411 If BUFFER is shown already in some window, just use that one,
3412 unless the window is the selected window and the optional second
3413 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3414 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3415 Returns the window displaying BUFFER.
3416 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3417 displaying BUFFER, then simply raise that frame.
3419 The variables `special-display-buffer-names',
3420 `special-display-regexps', `same-window-buffer-names', and
3421 `same-window-regexps' customize how certain buffer names are handled.
3422 The latter two take effect only if NOT-THIS-WINDOW is t.
3424 If optional argument FRAME is `visible', search all visible frames.
3425 If FRAME is 0, search all visible and iconified frames.
3426 If FRAME is t, search all frames.
3427 If FRAME is a frame, search only that frame.
3428 If FRAME is nil, search only the selected frame
3429 (actually the last nonminibuffer frame),
3430 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3431 which means search visible and iconified frames.
3433 If a full-width window on a splittable frame is available to display
3434 the buffer, it may be split, subject to the value of the variable
3435 `split-height-threshold'.
3437 If `even-window-heights' is non-nil, window heights will be evened out
3438 if displaying the buffer causes two vertically adjacent windows to be
3440 (buffer
, not_this_window
, frame
)
3441 register Lisp_Object buffer
, not_this_window
, frame
;
3443 register Lisp_Object window
, tem
, swp
;
3447 buffer
= Fget_buffer (buffer
);
3448 CHECK_BUFFER (buffer
);
3450 if (!NILP (Vdisplay_buffer_function
))
3451 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3453 if (NILP (not_this_window
)
3454 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3455 return display_buffer_1 (selected_window
);
3457 /* See if the user has specified this buffer should appear
3458 in the selected window. */
3459 if (NILP (not_this_window
))
3461 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3462 if (!NILP (swp
) && !no_switch_window (selected_window
))
3464 Fswitch_to_buffer (buffer
, Qnil
);
3465 return display_buffer_1 (selected_window
);
3469 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3470 look for a window showing BUFFER on any visible or iconified frame.
3471 Otherwise search only the current frame. */
3474 else if (pop_up_frames
3475 || display_buffer_reuse_frames
3476 || last_nonminibuf_frame
== 0)
3477 XSETFASTINT (tem
, 0);
3479 XSETFRAME (tem
, last_nonminibuf_frame
);
3481 window
= Fget_buffer_window (buffer
, tem
);
3483 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3484 return display_buffer_1 (window
);
3486 /* Certain buffer names get special handling. */
3487 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3489 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3491 return call1 (Vspecial_display_function
, buffer
);
3493 return call2 (Vspecial_display_function
, buffer
, tem
);
3496 /* If there are no frames open that have more than a minibuffer,
3497 we need to create a new frame. */
3498 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3500 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3501 Fset_window_buffer (window
, buffer
, Qnil
);
3502 return display_buffer_1 (window
);
3505 f
= SELECTED_FRAME ();
3507 || FRAME_MINIBUF_ONLY_P (f
)
3508 /* If the current frame is a special display frame,
3509 don't try to reuse its windows. */
3510 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3515 if (FRAME_MINIBUF_ONLY_P (f
))
3516 XSETFRAME (frames
, last_nonminibuf_frame
);
3517 /* Don't try to create a window if we would get an error. */
3518 if (split_height_threshold
< window_min_height
<< 1)
3519 split_height_threshold
= window_min_height
<< 1;
3521 /* Note that both Fget_largest_window and Fget_lru_window
3522 ignore minibuffers and dedicated windows.
3523 This means they can return nil. */
3525 /* If the frame we would try to split cannot be split,
3526 try other frames. */
3527 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3529 /* Try visible frames first. */
3530 window
= Fget_largest_window (Qvisible
, Qt
);
3531 /* If that didn't work, try iconified frames. */
3533 window
= Fget_largest_window (make_number (0), Qt
);
3534 #if 0 /* Don't try windows on other displays. */
3536 window
= Fget_largest_window (Qt
, Qt
);
3540 window
= Fget_largest_window (frames
, Qt
);
3542 /* If we got a tall enough full-width window that can be split,
3545 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3546 && window_height (window
) >= split_height_threshold
3547 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3548 window
= Fsplit_window (window
, Qnil
, Qnil
);
3551 Lisp_Object upper
, lower
, other
;
3553 window
= Fget_lru_window (frames
, Qt
);
3554 /* If the LRU window is selected, and big enough,
3555 and can be split, split it. */
3557 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3558 && (EQ (window
, selected_window
)
3559 || EQ (XWINDOW (window
)->parent
, Qnil
))
3560 && window_height (window
) >= window_min_height
<< 1)
3561 window
= Fsplit_window (window
, Qnil
, Qnil
);
3563 window
= Fget_lru_window (frames
, Qnil
);
3564 /* If Fget_lru_window returned nil, try other approaches. */
3566 /* Try visible frames first. */
3568 window
= Fget_buffer_window (buffer
, Qvisible
);
3570 window
= Fget_largest_window (Qvisible
, Qnil
);
3571 /* If that didn't work, try iconified frames. */
3573 window
= Fget_buffer_window (buffer
, make_number (0));
3575 window
= Fget_largest_window (make_number (0), Qnil
);
3577 #if 0 /* Don't try frames on other displays. */
3579 window
= Fget_buffer_window (buffer
, Qt
);
3581 window
= Fget_largest_window (Qt
, Qnil
);
3583 /* As a last resort, make a new frame. */
3585 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3586 /* If window appears above or below another,
3587 even out their heights. */
3588 other
= upper
= lower
= Qnil
;
3589 if (!NILP (XWINDOW (window
)->prev
))
3590 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3591 if (!NILP (XWINDOW (window
)->next
))
3592 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3594 && !NILP (Veven_window_heights
)
3595 /* Check that OTHER and WINDOW are vertically arrayed. */
3596 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3597 && (XFASTINT (XWINDOW (other
)->total_lines
)
3598 > XFASTINT (XWINDOW (window
)->total_lines
)))
3600 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3601 + XFASTINT (XWINDOW (window
)->total_lines
));
3602 enlarge_window (upper
,
3603 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3609 window
= Fget_lru_window (Qnil
, Qnil
);
3611 Fset_window_buffer (window
, buffer
, Qnil
);
3612 return display_buffer_1 (window
);
3616 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3618 doc
: /* Force redisplay of all windows.
3619 If optional arg OBJECT is a window, force redisplay of that window only.
3620 If OBJECT is a buffer or buffer name, force redisplay of all windows
3621 displaying that buffer. */)
3627 windows_or_buffers_changed
++;
3628 update_mode_lines
++;
3632 if (WINDOWP (object
))
3634 struct window
*w
= XWINDOW (object
);
3635 mark_window_display_accurate (object
, 0);
3636 w
->update_mode_line
= Qt
;
3637 if (BUFFERP (w
->buffer
))
3638 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3639 ++update_mode_lines
;
3643 if (STRINGP (object
))
3644 object
= Fget_buffer (object
);
3645 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3647 /* Walk all windows looking for buffer, and force update
3648 of each of those windows. */
3650 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3651 return NILP (object
) ? Qnil
: Qt
;
3654 /* If nothing suitable was found, just return.
3655 We could signal an error, but this feature will typically be used
3656 asynchronously in timers or process sentinels, so we don't. */
3662 temp_output_buffer_show (buf
)
3663 register Lisp_Object buf
;
3665 register struct buffer
*old
= current_buffer
;
3666 register Lisp_Object window
;
3667 register struct window
*w
;
3669 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3672 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3676 #if 0 /* rms: there should be no reason for this. */
3677 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3679 set_buffer_internal (old
);
3681 if (!NILP (Vtemp_buffer_show_function
))
3682 call1 (Vtemp_buffer_show_function
, buf
);
3685 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3687 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3688 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3689 Vminibuf_scroll_window
= window
;
3690 w
= XWINDOW (window
);
3691 XSETFASTINT (w
->hscroll
, 0);
3692 XSETFASTINT (w
->min_hscroll
, 0);
3693 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3694 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3696 /* Run temp-buffer-show-hook, with the chosen window selected
3697 and its buffer current. */
3699 if (!NILP (Vrun_hooks
)
3700 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3701 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3703 int count
= SPECPDL_INDEX ();
3704 Lisp_Object prev_window
, prev_buffer
;
3705 prev_window
= selected_window
;
3706 XSETBUFFER (prev_buffer
, old
);
3708 /* Select the window that was chosen, for running the hook.
3709 Note: Both Fselect_window and select_window_norecord may
3710 set-buffer to the buffer displayed in the window,
3711 so we need to save the current buffer. --stef */
3712 record_unwind_protect (Fset_buffer
, prev_buffer
);
3713 record_unwind_protect (select_window_norecord
, prev_window
);
3714 Fselect_window (window
, Qt
);
3715 Fset_buffer (w
->buffer
);
3716 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3717 unbind_to (count
, Qnil
);
3723 make_dummy_parent (window
)
3727 register struct window
*o
, *p
;
3730 o
= XWINDOW (window
);
3731 p
= allocate_window ();
3732 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3733 ((struct Lisp_Vector
*) p
)->contents
[i
]
3734 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3735 XSETWINDOW (new, p
);
3738 XSETFASTINT (p
->sequence_number
, sequence_number
);
3740 /* Put new into window structure in place of window */
3741 replace_window (window
, new);
3754 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3755 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3756 WINDOW defaults to selected one and SIZE to half its size.
3757 If optional third arg HORFLAG is non-nil, split side by side
3758 and put SIZE columns in the first of the pair. In that case,
3759 SIZE includes that window's scroll bar, or the divider column to its right.
3760 Interactively, all arguments are nil.
3762 Returns the newly created window (which is the lower or rightmost one).
3763 The upper or leftmost window is the original one and remains selected.
3764 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3765 (window
, size
, horflag
)
3766 Lisp_Object window
, size
, horflag
;
3768 register Lisp_Object
new;
3769 register struct window
*o
, *p
;
3771 register int size_int
;
3774 window
= selected_window
;
3776 CHECK_LIVE_WINDOW (window
);
3778 o
= XWINDOW (window
);
3779 fo
= XFRAME (WINDOW_FRAME (o
));
3783 if (!NILP (horflag
))
3784 /* Calculate the size of the left-hand window, by dividing
3785 the usable space in columns by two.
3786 We round up, since the left-hand window may include
3787 a dividing line, while the right-hand may not. */
3788 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3790 size_int
= XFASTINT (o
->total_lines
) >> 1;
3794 CHECK_NUMBER (size
);
3795 size_int
= XINT (size
);
3798 if (MINI_WINDOW_P (o
))
3799 error ("Attempt to split minibuffer window");
3800 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3801 error ("Attempt to split fixed-size window");
3803 check_min_window_sizes ();
3807 if (size_int
< window_min_height
)
3808 error ("Window height %d too small (after splitting)", size_int
);
3809 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3810 error ("Window height %d too small (after splitting)",
3811 XFASTINT (o
->total_lines
) - size_int
);
3812 if (NILP (o
->parent
)
3813 || NILP (XWINDOW (o
->parent
)->vchild
))
3815 make_dummy_parent (window
);
3817 XWINDOW (new)->vchild
= window
;
3822 if (size_int
< window_min_width
)
3823 error ("Window width %d too small (after splitting)", size_int
);
3825 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3826 error ("Window width %d too small (after splitting)",
3827 XFASTINT (o
->total_cols
) - size_int
);
3828 if (NILP (o
->parent
)
3829 || NILP (XWINDOW (o
->parent
)->hchild
))
3831 make_dummy_parent (window
);
3833 XWINDOW (new)->hchild
= window
;
3837 /* Now we know that window's parent is a vertical combination
3838 if we are dividing vertically, or a horizontal combination
3839 if we are making side-by-side windows */
3841 windows_or_buffers_changed
++;
3842 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3843 new = make_window ();
3846 p
->frame
= o
->frame
;
3848 if (!NILP (p
->next
))
3849 XWINDOW (p
->next
)->prev
= new;
3852 p
->parent
= o
->parent
;
3854 p
->window_end_valid
= Qnil
;
3855 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3857 /* Duplicate special geometry settings. */
3859 p
->left_margin_cols
= o
->left_margin_cols
;
3860 p
->right_margin_cols
= o
->right_margin_cols
;
3861 p
->left_fringe_width
= o
->left_fringe_width
;
3862 p
->right_fringe_width
= o
->right_fringe_width
;
3863 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3864 p
->scroll_bar_width
= o
->scroll_bar_width
;
3865 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3867 /* Apportion the available frame space among the two new windows */
3869 if (!NILP (horflag
))
3871 p
->total_lines
= o
->total_lines
;
3872 p
->top_line
= o
->top_line
;
3873 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3874 XSETFASTINT (o
->total_cols
, size_int
);
3875 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3876 adjust_window_margins (p
);
3877 adjust_window_margins (o
);
3881 p
->left_col
= o
->left_col
;
3882 p
->total_cols
= o
->total_cols
;
3883 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3884 XSETFASTINT (o
->total_lines
, size_int
);
3885 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3888 /* Adjust glyph matrices. */
3891 Fset_window_buffer (new, o
->buffer
, Qt
);
3895 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3896 doc
: /* Make current window ARG lines bigger.
3897 From program, optional second arg non-nil means grow sideways ARG columns.
3898 Interactively, if an argument is not given, make the window one line bigger.
3899 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
3900 This function can delete windows, even the second window, if they get
3903 Lisp_Object arg
, horizontal
;
3906 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
3908 if (! NILP (Vwindow_configuration_change_hook
))
3909 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3914 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3915 doc
: /* Make current window ARG lines smaller.
3916 From program, optional second arg non-nil means shrink sideways arg columns.
3917 Interactively, if an argument is not given, make the window one line smaller. Only
3918 siblings to the right or below are changed. */)
3920 Lisp_Object arg
, side
;
3923 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3925 if (! NILP (Vwindow_configuration_change_hook
))
3926 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3932 window_height (window
)
3935 register struct window
*p
= XWINDOW (window
);
3936 return WINDOW_TOTAL_LINES (p
);
3940 window_width (window
)
3943 register struct window
*p
= XWINDOW (window
);
3944 return WINDOW_TOTAL_COLS (p
);
3949 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3951 #define CURSIZE(w) \
3952 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3955 /* Enlarge WINDOW by DELTA.
3956 HORIZ_FLAG nonzero means enlarge it horizontally;
3957 zero means do it vertically.
3959 Siblings of the selected window are resized to fulfill the size
3960 request. If they become too small in the process, they will be
3964 enlarge_window (window
, delta
, horiz_flag
)
3966 int delta
, horiz_flag
;
3968 Lisp_Object parent
, next
, prev
;
3972 int (*sizefun
) P_ ((Lisp_Object
))
3973 = horiz_flag
? window_width
: window_height
;
3974 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3975 = (horiz_flag
? set_window_width
: set_window_height
);
3977 /* Check values of window_min_width and window_min_height for
3979 check_min_window_sizes ();
3981 /* Give up if this window cannot be resized. */
3982 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3983 error ("Window is not resizable");
3985 /* Find the parent of the selected window. */
3988 p
= XWINDOW (window
);
3994 error ("No other window to side of this one");
3999 ? !NILP (XWINDOW (parent
)->hchild
)
4000 : !NILP (XWINDOW (parent
)->vchild
))
4006 sizep
= &CURSIZE (window
);
4009 register int maxdelta
;
4011 /* Compute the maximum size increment this window can have. */
4013 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4014 /* This is a main window followed by a minibuffer. */
4015 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4016 - window_min_size (XWINDOW (p
->next
),
4018 /* This is a minibuffer following a main window. */
4019 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4020 - window_min_size (XWINDOW (p
->prev
),
4022 /* This is a frame with only one window, a minibuffer-only
4023 or a minibufferless frame. */
4026 if (delta
> maxdelta
)
4027 /* This case traps trying to make the minibuffer
4028 the full frame, or make the only window aside from the
4029 minibuffer the full frame. */
4033 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4035 delete_window (window
);
4042 /* Find the total we can get from other siblings without deleting them. */
4044 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4045 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4047 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4048 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4051 /* If we can get it all from them without deleting them, do so. */
4052 if (delta
<= maximum
)
4054 Lisp_Object first_unaffected
;
4055 Lisp_Object first_affected
;
4060 first_affected
= window
;
4061 /* Look at one sibling at a time,
4062 moving away from this window in both directions alternately,
4063 and take as much as we can get without deleting that sibling. */
4065 && (!NILP (next
) || !NILP (prev
)))
4069 int this_one
= ((*sizefun
) (next
)
4070 - window_min_size (XWINDOW (next
),
4071 horiz_flag
, 0, &fixed_p
));
4074 if (this_one
> delta
)
4077 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4078 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4083 next
= XWINDOW (next
)->next
;
4091 int this_one
= ((*sizefun
) (prev
)
4092 - window_min_size (XWINDOW (prev
),
4093 horiz_flag
, 0, &fixed_p
));
4096 if (this_one
> delta
)
4099 first_affected
= prev
;
4101 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4102 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4107 prev
= XWINDOW (prev
)->prev
;
4111 xassert (delta
== 0);
4113 /* Now recalculate the edge positions of all the windows affected,
4114 based on the new sizes. */
4115 first_unaffected
= next
;
4116 prev
= first_affected
;
4117 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4118 prev
= next
, next
= XWINDOW (next
)->next
)
4120 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4121 /* This does not change size of NEXT,
4122 but it propagates the new top edge to its children */
4123 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4128 register int delta1
;
4129 register int opht
= (*sizefun
) (parent
);
4131 if (opht
<= XINT (*sizep
) + delta
)
4133 /* If trying to grow this window to or beyond size of the parent,
4134 just delete all the sibling windows. */
4135 Lisp_Object start
, tem
, next
;
4137 start
= XWINDOW (parent
)->vchild
;
4139 start
= XWINDOW (parent
)->hchild
;
4141 /* Delete any siblings that come after WINDOW. */
4142 tem
= XWINDOW (window
)->next
;
4143 while (! NILP (tem
))
4145 next
= XWINDOW (tem
)->next
;
4146 delete_window (tem
);
4150 /* Delete any siblings that come after WINDOW.
4151 Note that if START is not WINDOW, then WINDOW still
4152 Fhas siblings, so WINDOW has not yet replaced its parent. */
4154 while (! EQ (tem
, window
))
4156 next
= XWINDOW (tem
)->next
;
4157 delete_window (tem
);
4163 /* Otherwise, make delta1 just right so that if we add
4164 delta1 lines to this window and to the parent, and then
4165 shrink the parent back to its original size, the new
4166 proportional size of this window will increase by delta.
4168 The function size_window will compute the new height h'
4169 of the window from delta1 as:
4172 x = delta1 - delta1/n * n for the 1st resizable child
4175 where n is the number of children that can be resized.
4176 We can ignore x by choosing a delta1 that is a multiple of
4177 n. We want the height of this window to come out as
4187 The number of children n equals the number of resizable
4188 children of this window + 1 because we know window itself
4189 is resizable (otherwise we would have signalled an error). */
4191 struct window
*w
= XWINDOW (window
);
4195 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4196 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4198 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4199 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4204 /* Add delta1 lines or columns to this window, and to the parent,
4205 keeping things consistent while not affecting siblings. */
4206 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4207 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4209 /* Squeeze out delta1 lines or columns from our parent,
4210 shriking this window and siblings proportionately.
4211 This brings parent back to correct size.
4212 Delta1 was calculated so this makes this window the desired size,
4213 taking it all out of the siblings. */
4214 (*setsizefun
) (parent
, opht
, 0);
4219 XSETFASTINT (p
->last_modified
, 0);
4220 XSETFASTINT (p
->last_overlay_modified
, 0);
4222 /* Adjust glyph matrices. */
4223 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4227 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4228 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4229 zero means adjust the height, moving the bottom edge.
4231 Following siblings of the selected window are resized to fulfill
4232 the size request. If they become too small in the process, they
4233 are not deleted; instead, we signal an error. */
4236 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4238 int delta
, horiz_flag
;
4240 Lisp_Object parent
, child
;
4242 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4243 int delcount
= window_deletion_count
;
4245 /* Check values of window_min_width and window_min_height for
4247 check_min_window_sizes ();
4250 window
= Fselected_window ();
4252 CHECK_WINDOW (window
);
4254 /* Give up if this window cannot be resized. */
4255 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4256 error ("Window is not resizable");
4260 p
= XWINDOW (window
);
4263 /* Make sure there is a following window. */
4266 : NILP (XWINDOW (window
)->next
)))
4268 Fset_window_configuration (old_config
);
4269 error ("No other window following this one");
4272 /* Don't make this window too small. */
4273 if (XINT (CURSIZE (window
)) + delta
4274 < (horiz_flag
? window_min_width
: window_min_height
))
4276 Fset_window_configuration (old_config
);
4277 error ("Cannot adjust window size as specified");
4280 /* Clear out some redisplay caches. */
4281 XSETFASTINT (p
->last_modified
, 0);
4282 XSETFASTINT (p
->last_overlay_modified
, 0);
4284 /* Adjust this window's edge. */
4285 XSETINT (CURSIZE (window
),
4286 XINT (CURSIZE (window
)) + delta
);
4288 /* If this window has following siblings in the desired dimension,
4290 (If we reach the top of the tree and can never do this,
4291 we will fail and report an error, above.) */
4293 ? !NILP (XWINDOW (parent
)->hchild
)
4294 : !NILP (XWINDOW (parent
)->vchild
))
4296 if (!NILP (XWINDOW (window
)->next
))
4298 /* This may happen for the minibuffer. In that case
4299 the window_deletion_count check below does not work. */
4300 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4302 Fset_window_configuration (old_config
);
4303 error ("Cannot adjust window size as specified");
4306 XSETINT (CURBEG (p
->next
),
4307 XINT (CURBEG (p
->next
)) + delta
);
4308 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4314 /* Here we have a chain of parallel siblings, in the other dimension.
4315 Change the size of the other siblings. */
4316 for (child
= (horiz_flag
4317 ? XWINDOW (parent
)->vchild
4318 : XWINDOW (parent
)->hchild
);
4320 child
= XWINDOW (child
)->next
)
4321 if (! EQ (child
, window
))
4322 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4328 /* If we made a window so small it got deleted,
4329 we failed. Report failure. */
4330 if (delcount
!= window_deletion_count
)
4332 Fset_window_configuration (old_config
);
4333 error ("Cannot adjust window size as specified");
4336 /* Adjust glyph matrices. */
4337 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4343 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4344 Sadjust_window_trailing_edge
, 3, 3, 0,
4345 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4346 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4347 Otherwise, adjust the height, moving the bottom edge.
4349 Following siblings of the selected window are resized to fulfill
4350 the size request. If they become too small in the process, they
4351 are not deleted; instead, we signal an error. */)
4352 (window
, delta
, horizontal
)
4353 Lisp_Object window
, delta
, horizontal
;
4355 CHECK_NUMBER (delta
);
4356 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4358 if (! NILP (Vwindow_configuration_change_hook
))
4359 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4366 /***********************************************************************
4367 Resizing Mini-Windows
4368 ***********************************************************************/
4370 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4372 enum save_restore_action
4379 static int save_restore_orig_size
P_ ((struct window
*,
4380 enum save_restore_action
));
4382 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4383 from lowest windows first. */
4386 shrink_window_lowest_first (w
, height
)
4394 xassert (!MINI_WINDOW_P (w
));
4396 /* Set redisplay hints. */
4397 XSETFASTINT (w
->last_modified
, 0);
4398 XSETFASTINT (w
->last_overlay_modified
, 0);
4399 windows_or_buffers_changed
++;
4400 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4402 old_height
= XFASTINT (w
->total_lines
);
4403 XSETFASTINT (w
->total_lines
, height
);
4405 if (!NILP (w
->hchild
))
4407 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4409 c
= XWINDOW (child
);
4410 c
->top_line
= w
->top_line
;
4411 shrink_window_lowest_first (c
, height
);
4414 else if (!NILP (w
->vchild
))
4416 Lisp_Object last_child
;
4417 int delta
= old_height
- height
;
4422 /* Find the last child. We are taking space from lowest windows
4423 first, so we iterate over children from the last child
4425 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4428 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4429 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4433 c
= XWINDOW (child
);
4434 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4436 if (this_one
> delta
)
4439 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4443 /* Compute new positions. */
4444 last_top
= XINT (w
->top_line
);
4445 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4447 c
= XWINDOW (child
);
4448 c
->top_line
= make_number (last_top
);
4449 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4450 last_top
+= XFASTINT (c
->total_lines
);
4456 /* Save, restore, or check positions and sizes in the window tree
4457 rooted at W. ACTION says what to do.
4459 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4460 orig_total_lines members are valid for all windows in the window
4461 tree. Value is non-zero if they are valid.
4463 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4464 orig_top_line and orig_total_lines for all windows in the tree.
4466 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4467 stored in orig_top_line and orig_total_lines for all windows. */
4470 save_restore_orig_size (w
, action
)
4472 enum save_restore_action action
;
4478 if (!NILP (w
->hchild
))
4480 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4483 else if (!NILP (w
->vchild
))
4485 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4491 case CHECK_ORIG_SIZES
:
4492 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4496 case SAVE_ORIG_SIZES
:
4497 w
->orig_top_line
= w
->top_line
;
4498 w
->orig_total_lines
= w
->total_lines
;
4499 XSETFASTINT (w
->last_modified
, 0);
4500 XSETFASTINT (w
->last_overlay_modified
, 0);
4503 case RESTORE_ORIG_SIZES
:
4504 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4505 w
->top_line
= w
->orig_top_line
;
4506 w
->total_lines
= w
->orig_total_lines
;
4507 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4508 XSETFASTINT (w
->last_modified
, 0);
4509 XSETFASTINT (w
->last_overlay_modified
, 0);
4516 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4523 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4524 without deleting other windows. */
4527 grow_mini_window (w
, delta
)
4531 struct frame
*f
= XFRAME (w
->frame
);
4532 struct window
*root
;
4534 xassert (MINI_WINDOW_P (w
));
4535 xassert (delta
>= 0);
4537 /* Check values of window_min_width and window_min_height for
4539 check_min_window_sizes ();
4541 /* Compute how much we can enlarge the mini-window without deleting
4543 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4546 int min_height
= window_min_size (root
, 0, 0, 0);
4547 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4548 /* Note that the root window may already be smaller than
4550 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4555 /* Save original window sizes and positions, if not already done. */
4556 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4557 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4559 /* Shrink other windows. */
4560 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4562 /* Grow the mini-window. */
4563 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4564 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4565 XSETFASTINT (w
->last_modified
, 0);
4566 XSETFASTINT (w
->last_overlay_modified
, 0);
4573 /* Shrink mini-window W. If there is recorded info about window sizes
4574 before a call to grow_mini_window, restore recorded window sizes.
4575 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4579 shrink_mini_window (w
)
4582 struct frame
*f
= XFRAME (w
->frame
);
4583 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4585 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4587 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4589 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4590 windows_or_buffers_changed
= 1;
4592 else if (XFASTINT (w
->total_lines
) > 1)
4594 /* Distribute the additional lines of the mini-window
4595 among the other windows. */
4597 XSETWINDOW (window
, w
);
4598 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4604 /* Mark window cursors off for all windows in the window tree rooted
4605 at W by setting their phys_cursor_on_p flag to zero. Called from
4606 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4607 the frame are cleared. */
4610 mark_window_cursors_off (w
)
4615 if (!NILP (w
->hchild
))
4616 mark_window_cursors_off (XWINDOW (w
->hchild
));
4617 else if (!NILP (w
->vchild
))
4618 mark_window_cursors_off (XWINDOW (w
->vchild
));
4620 w
->phys_cursor_on_p
= 0;
4622 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4627 /* Return number of lines of text (not counting mode lines) in W. */
4630 window_internal_height (w
)
4633 int ht
= XFASTINT (w
->total_lines
);
4635 if (!MINI_WINDOW_P (w
))
4637 if (!NILP (w
->parent
)
4638 || !NILP (w
->vchild
)
4639 || !NILP (w
->hchild
)
4642 || WINDOW_WANTS_MODELINE_P (w
))
4645 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4653 /* Return the number of columns in W.
4654 Don't count columns occupied by scroll bars or the vertical bar
4655 separating W from the sibling to its right. */
4658 window_box_text_cols (w
)
4661 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4662 int width
= XINT (w
->total_cols
);
4664 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4665 /* Scroll bars occupy a few columns. */
4666 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4667 else if (!FRAME_WINDOW_P (f
)
4668 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4669 /* The column of `|' characters separating side-by-side windows
4670 occupies one column only. */
4673 if (FRAME_WINDOW_P (f
))
4674 /* On window-systems, fringes and display margins cannot be
4675 used for normal text. */
4676 width
-= (WINDOW_FRINGE_COLS (w
)
4677 + WINDOW_LEFT_MARGIN_COLS (w
)
4678 + WINDOW_RIGHT_MARGIN_COLS (w
));
4684 /************************************************************************
4686 ***********************************************************************/
4688 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4689 N screen-fulls, which is defined as the height of the window minus
4690 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4691 instead. Negative values of N mean scroll down. NOERROR non-zero
4692 means don't signal an error if we try to move over BEGV or ZV,
4696 window_scroll (window
, n
, whole
, noerror
)
4704 /* If we must, use the pixel-based version which is much slower than
4705 the line-based one but can handle varying line heights. */
4706 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4707 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4709 window_scroll_line_based (window
, n
, whole
, noerror
);
4715 /* Implementation of window_scroll that works based on pixel line
4716 heights. See the comment of window_scroll for parameter
4720 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4727 struct window
*w
= XWINDOW (window
);
4728 struct text_pos start
;
4730 int this_scroll_margin
;
4731 /* True if we fiddled the window vscroll field without really scrolling. */
4734 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4736 /* If PT is not visible in WINDOW, move back one half of
4737 the screen. Allow PT to be partially visible, otherwise
4738 something like (scroll-down 1) with PT in the line before
4739 the partially visible one would recenter. */
4740 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4743 /* Move backward half the height of the window. Performance note:
4744 vmotion used here is about 10% faster, but would give wrong
4745 results for variable height lines. */
4746 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4747 it
.current_y
= it
.last_visible_y
;
4748 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4750 /* The function move_iterator_vertically may move over more than
4751 the specified y-distance. If it->w is small, e.g. a
4752 mini-buffer window, we may end up in front of the window's
4753 display area. This is the case when Start displaying at the
4754 start of the line containing PT in this case. */
4755 if (it
.current_y
<= 0)
4757 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4758 move_it_vertically_backward (&it
, 0);
4762 start
= it
.current
.pos
;
4764 else if (auto_window_vscroll_p
)
4766 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4769 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4771 dy
= max ((window_box_height (w
)
4772 - next_screen_context_lines
* dy
),
4776 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4778 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4779 Fset_window_vscroll (window
, make_number (px
), Qt
);
4782 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4784 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4785 Fset_window_vscroll (window
, make_number (px
), Qt
);
4789 Fset_window_vscroll (window
, make_number (0), Qt
);
4792 /* If scroll_preserve_screen_position is non-nil, we try to set
4793 point in the same window line as it is now, so get that line. */
4794 if (!NILP (Vscroll_preserve_screen_position
))
4796 /* We preserve the goal pixel coordinate across consecutive
4797 calls to scroll-up or scroll-down. This avoids the
4798 possibility of point becoming "stuck" on a tall line when
4799 scrolling by one line. */
4800 if (window_scroll_pixel_based_preserve_y
< 0
4801 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
4802 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
4804 start_display (&it
, w
, start
);
4805 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4806 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4810 window_scroll_pixel_based_preserve_y
= -1;
4812 /* Move iterator it from start the specified distance forward or
4813 backward. The result is the new window start. */
4814 start_display (&it
, w
, start
);
4817 int start_pos
= IT_CHARPOS (it
);
4818 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4819 dy
= max ((window_box_height (w
)
4820 - next_screen_context_lines
* dy
),
4823 /* Note that move_it_vertically always moves the iterator to the
4824 start of a line. So, if the last line doesn't have a newline,
4825 we would end up at the start of the line ending at ZV. */
4828 move_it_vertically_backward (&it
, -dy
);
4829 /* Ensure we actually does move, e.g. in case we are currently
4830 looking at an image that is taller that the window height. */
4831 while (start_pos
== IT_CHARPOS (it
)
4832 && start_pos
> BEGV
)
4833 move_it_by_lines (&it
, -1, 1);
4837 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4838 MOVE_TO_POS
| MOVE_TO_Y
);
4839 /* Ensure we actually does move, e.g. in case we are currently
4840 looking at an image that is taller that the window height. */
4841 while (start_pos
== IT_CHARPOS (it
)
4843 move_it_by_lines (&it
, 1, 1);
4847 move_it_by_lines (&it
, n
, 1);
4849 /* We failed if we find ZV is already on the screen (scrolling up,
4850 means there's nothing past the end), or if we can't start any
4851 earlier (scrolling down, means there's nothing past the top). */
4852 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4853 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4855 if (IT_CHARPOS (it
) == ZV
)
4857 if (it
.current_y
< it
.last_visible_y
4858 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4859 >= it
.last_visible_y
))
4861 /* The last line was only partially visible, make it fully
4863 w
->vscroll
= (it
.last_visible_y
4864 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4865 adjust_glyphs (it
.f
);
4870 Fsignal (Qend_of_buffer
, Qnil
);
4874 if (w
->vscroll
!= 0)
4875 /* The first line was only partially visible, make it fully
4881 Fsignal (Qbeginning_of_buffer
, Qnil
);
4884 /* If control gets here, then we vscrolled. */
4886 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4888 /* Don't try to change the window start below. */
4894 int pos
= IT_CHARPOS (it
);
4897 /* If in the middle of a multi-glyph character move forward to
4898 the next character. */
4899 if (in_display_vector_p (&it
))
4902 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4905 /* Set the window start, and set up the window for redisplay. */
4906 set_marker_restricted (w
->start
, make_number (pos
),
4908 bytepos
= XMARKER (w
->start
)->bytepos
;
4909 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4911 w
->update_mode_line
= Qt
;
4912 XSETFASTINT (w
->last_modified
, 0);
4913 XSETFASTINT (w
->last_overlay_modified
, 0);
4914 /* Set force_start so that redisplay_window will run the
4915 window-scroll-functions. */
4916 w
->force_start
= Qt
;
4919 /* The rest of this function uses current_y in a nonstandard way,
4920 not including the height of the header line if any. */
4921 it
.current_y
= it
.vpos
= 0;
4923 /* Move PT out of scroll margins.
4924 This code wants current_y to be zero at the window start position
4925 even if there is a header line. */
4926 this_scroll_margin
= max (0, scroll_margin
);
4927 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4928 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4932 /* We moved the window start towards ZV, so PT may be now
4933 in the scroll margin at the top. */
4934 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4935 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4936 && (NILP (Vscroll_preserve_screen_position
)
4937 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4938 /* We found PT at a legitimate height. Leave it alone. */
4940 else if (window_scroll_pixel_based_preserve_y
>= 0)
4942 /* If we have a header line, take account of it.
4943 This is necessary because we set it.current_y to 0, above. */
4944 move_it_to (&it
, -1, -1,
4945 window_scroll_pixel_based_preserve_y
4946 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
4948 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4952 while (it
.current_y
< this_scroll_margin
)
4954 int prev
= it
.current_y
;
4955 move_it_by_lines (&it
, 1, 1);
4956 if (prev
== it
.current_y
)
4959 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4964 int charpos
, bytepos
;
4967 /* Save our position, for the
4968 window_scroll_pixel_based_preserve_y case. */
4969 charpos
= IT_CHARPOS (it
);
4970 bytepos
= IT_BYTEPOS (it
);
4972 /* We moved the window start towards BEGV, so PT may be now
4973 in the scroll margin at the bottom. */
4974 move_it_to (&it
, PT
, -1,
4975 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4976 - this_scroll_margin
- 1),
4978 MOVE_TO_POS
| MOVE_TO_Y
);
4980 /* Save our position, in case it's correct. */
4981 charpos
= IT_CHARPOS (it
);
4982 bytepos
= IT_BYTEPOS (it
);
4984 /* See if point is on a partially visible line at the end. */
4985 if (it
.what
== IT_EOB
)
4986 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4989 move_it_by_lines (&it
, 1, 1);
4990 partial_p
= it
.current_y
> it
.last_visible_y
;
4993 if (charpos
== PT
&& !partial_p
4994 && (NILP (Vscroll_preserve_screen_position
)
4995 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4996 /* We found PT before we found the display margin, so PT is ok. */
4998 else if (window_scroll_pixel_based_preserve_y
>= 0)
5000 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5001 start_display (&it
, w
, start
);
5002 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5003 here because we called start_display again and did not
5004 alter it.current_y this time. */
5005 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5007 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5012 /* The last line was only partially visible, so back up two
5013 lines to make sure we're on a fully visible line. */
5015 move_it_by_lines (&it
, -2, 0);
5016 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5019 /* No, the position we saved is OK, so use it. */
5020 SET_PT_BOTH (charpos
, bytepos
);
5026 /* Implementation of window_scroll that works based on screen lines.
5027 See the comment of window_scroll for parameter descriptions. */
5030 window_scroll_line_based (window
, n
, whole
, noerror
)
5036 register struct window
*w
= XWINDOW (window
);
5037 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5038 register int pos
, pos_byte
;
5039 register int ht
= window_internal_height (w
);
5040 register Lisp_Object tem
;
5044 struct position posit
;
5047 /* If scrolling screen-fulls, compute the number of lines to
5048 scroll from the window's height. */
5050 n
*= max (1, ht
- next_screen_context_lines
);
5052 startpos
= marker_position (w
->start
);
5054 posit
= *compute_motion (startpos
, 0, 0, 0,
5056 -1, XINT (w
->hscroll
),
5058 original_vpos
= posit
.vpos
;
5060 XSETFASTINT (tem
, PT
);
5061 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5065 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5070 lose
= n
< 0 && PT
== BEGV
;
5071 Fvertical_motion (make_number (n
), window
);
5075 SET_PT_BOTH (opoint
, opoint_byte
);
5082 Fsignal (Qbeginning_of_buffer
, Qnil
);
5087 int this_scroll_margin
= scroll_margin
;
5089 /* Don't use a scroll margin that is negative or too large. */
5090 if (this_scroll_margin
< 0)
5091 this_scroll_margin
= 0;
5093 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5094 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5096 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5097 w
->start_at_line_beg
= bolp
;
5098 w
->update_mode_line
= Qt
;
5099 XSETFASTINT (w
->last_modified
, 0);
5100 XSETFASTINT (w
->last_overlay_modified
, 0);
5101 /* Set force_start so that redisplay_window will run
5102 the window-scroll-functions. */
5103 w
->force_start
= Qt
;
5105 if (!NILP (Vscroll_preserve_screen_position
)
5106 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5108 SET_PT_BOTH (pos
, pos_byte
);
5109 Fvertical_motion (make_number (original_vpos
), window
);
5111 /* If we scrolled forward, put point enough lines down
5112 that it is outside the scroll margin. */
5117 if (this_scroll_margin
> 0)
5119 SET_PT_BOTH (pos
, pos_byte
);
5120 Fvertical_motion (make_number (this_scroll_margin
), window
);
5126 if (top_margin
<= opoint
)
5127 SET_PT_BOTH (opoint
, opoint_byte
);
5128 else if (!NILP (Vscroll_preserve_screen_position
))
5130 SET_PT_BOTH (pos
, pos_byte
);
5131 Fvertical_motion (make_number (original_vpos
), window
);
5134 SET_PT (top_margin
);
5140 /* If we scrolled backward, put point near the end of the window
5141 but not within the scroll margin. */
5142 SET_PT_BOTH (pos
, pos_byte
);
5143 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5144 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5147 bottom_margin
= PT
+ 1;
5149 if (bottom_margin
> opoint
)
5150 SET_PT_BOTH (opoint
, opoint_byte
);
5153 if (!NILP (Vscroll_preserve_screen_position
))
5155 SET_PT_BOTH (pos
, pos_byte
);
5156 Fvertical_motion (make_number (original_vpos
), window
);
5159 Fvertical_motion (make_number (-1), window
);
5168 Fsignal (Qend_of_buffer
, Qnil
);
5173 /* Scroll selected_window up or down. If N is nil, scroll a
5174 screen-full which is defined as the height of the window minus
5175 next_screen_context_lines. If N is the symbol `-', scroll.
5176 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5177 up. This is the guts of Fscroll_up and Fscroll_down. */
5180 scroll_command (n
, direction
)
5184 int count
= SPECPDL_INDEX ();
5186 xassert (abs (direction
) == 1);
5188 /* If selected window's buffer isn't current, make it current for
5189 the moment. But don't screw up if window_scroll gets an error. */
5190 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5192 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5193 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5195 /* Make redisplay consider other windows than just selected_window. */
5196 ++windows_or_buffers_changed
;
5200 window_scroll (selected_window
, direction
, 1, 0);
5201 else if (EQ (n
, Qminus
))
5202 window_scroll (selected_window
, -direction
, 1, 0);
5205 n
= Fprefix_numeric_value (n
);
5206 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5209 unbind_to (count
, Qnil
);
5212 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5213 doc
: /* Scroll text of current window upward ARG lines.
5214 If ARG is omitted or nil, scroll upward by a near full screen.
5215 A near full screen is `next-screen-context-lines' less than a full screen.
5216 Negative ARG means scroll downward.
5217 If ARG is the atom `-', scroll downward by nearly full screen.
5218 When calling from a program, supply as argument a number, nil, or `-'. */)
5222 scroll_command (arg
, 1);
5226 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5227 doc
: /* Scroll text of current window down ARG lines.
5228 If ARG is omitted or nil, scroll down by a near full screen.
5229 A near full screen is `next-screen-context-lines' less than a full screen.
5230 Negative ARG means scroll upward.
5231 If ARG is the atom `-', scroll upward by nearly full screen.
5232 When calling from a program, supply as argument a number, nil, or `-'. */)
5236 scroll_command (arg
, -1);
5240 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5241 doc
: /* Return the other window for \"other window scroll\" commands.
5242 If `other-window-scroll-buffer' is non-nil, a window
5243 showing that buffer is used.
5244 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5245 specifies the window. This takes precedence over
5246 `other-window-scroll-buffer'. */)
5251 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5252 && !NILP (Vminibuf_scroll_window
))
5253 window
= Vminibuf_scroll_window
;
5254 /* If buffer is specified, scroll that buffer. */
5255 else if (!NILP (Vother_window_scroll_buffer
))
5257 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5259 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5263 /* Nothing specified; look for a neighboring window on the same
5265 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5267 if (EQ (window
, selected_window
))
5268 /* That didn't get us anywhere; look for a window on another
5271 window
= Fnext_window (window
, Qnil
, Qt
);
5272 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5273 && ! EQ (window
, selected_window
));
5276 CHECK_LIVE_WINDOW (window
);
5278 if (EQ (window
, selected_window
))
5279 error ("There is no other window");
5284 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5285 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5286 A near full screen is `next-screen-context-lines' less than a full screen.
5287 The next window is the one below the current one; or the one at the top
5288 if the current one is at the bottom. Negative ARG means scroll downward.
5289 If ARG is the atom `-', scroll downward by nearly full screen.
5290 When calling from a program, supply as argument a number, nil, or `-'.
5292 If `other-window-scroll-buffer' is non-nil, scroll the window
5293 showing that buffer, popping the buffer up if necessary.
5294 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5295 specifies the window to scroll. This takes precedence over
5296 `other-window-scroll-buffer'. */)
5302 int count
= SPECPDL_INDEX ();
5304 window
= Fother_window_for_scrolling ();
5305 w
= XWINDOW (window
);
5307 /* Don't screw up if window_scroll gets an error. */
5308 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5309 ++windows_or_buffers_changed
;
5311 Fset_buffer (w
->buffer
);
5312 SET_PT (marker_position (w
->pointm
));
5315 window_scroll (window
, 1, 1, 1);
5316 else if (EQ (arg
, Qminus
))
5317 window_scroll (window
, -1, 1, 1);
5323 window_scroll (window
, XINT (arg
), 0, 1);
5326 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5327 unbind_to (count
, Qnil
);
5332 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5333 doc
: /* Scroll selected window display ARG columns left.
5334 Default for ARG is window width minus 2.
5335 Value is the total amount of leftward horizontal scrolling in
5336 effect after the change.
5337 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5338 lower bound for automatic scrolling, i.e. automatic scrolling
5339 will not scroll a window to a column less than the value returned
5340 by this function. This happens in an interactive call. */)
5342 register Lisp_Object arg
, set_minimum
;
5346 struct window
*w
= XWINDOW (selected_window
);
5349 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5351 arg
= Fprefix_numeric_value (arg
);
5353 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5354 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5356 if (!NILP (set_minimum
))
5357 w
->min_hscroll
= w
->hscroll
;
5362 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5363 doc
: /* Scroll selected window display ARG columns right.
5364 Default for ARG is window width minus 2.
5365 Value is the total amount of leftward horizontal scrolling in
5366 effect after the change.
5367 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5368 lower bound for automatic scrolling, i.e. automatic scrolling
5369 will not scroll a window to a column less than the value returned
5370 by this function. This happens in an interactive call. */)
5372 register Lisp_Object arg
, set_minimum
;
5376 struct window
*w
= XWINDOW (selected_window
);
5379 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5381 arg
= Fprefix_numeric_value (arg
);
5383 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5384 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5386 if (!NILP (set_minimum
))
5387 w
->min_hscroll
= w
->hscroll
;
5392 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5393 doc
: /* Return the window which was selected when entering the minibuffer.
5394 Returns nil, if current window is not a minibuffer window. */)
5397 if (minibuf_level
> 0
5398 && MINI_WINDOW_P (XWINDOW (selected_window
))
5399 && WINDOW_LIVE_P (minibuf_selected_window
))
5400 return minibuf_selected_window
;
5405 /* Value is the number of lines actually displayed in window W,
5406 as opposed to its height. */
5409 displayed_window_lines (w
)
5413 struct text_pos start
;
5414 int height
= window_box_height (w
);
5415 struct buffer
*old_buffer
;
5418 if (XBUFFER (w
->buffer
) != current_buffer
)
5420 old_buffer
= current_buffer
;
5421 set_buffer_internal (XBUFFER (w
->buffer
));
5426 /* In case W->start is out of the accessible range, do something
5427 reasonable. This happens in Info mode when Info-scroll-down
5428 calls (recenter -1) while W->start is 1. */
5429 if (XMARKER (w
->start
)->charpos
< BEGV
)
5430 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5431 else if (XMARKER (w
->start
)->charpos
> ZV
)
5432 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5434 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5436 start_display (&it
, w
, start
);
5437 move_it_vertically (&it
, height
);
5438 bottom_y
= line_bottom_y (&it
);
5440 /* rms: On a non-window display,
5441 the value of it.vpos at the bottom of the screen
5442 seems to be 1 larger than window_box_height (w).
5443 This kludge fixes a bug whereby (move-to-window-line -1)
5444 when ZV is on the last screen line
5445 moves to the previous screen line instead of the last one. */
5446 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5449 /* Add in empty lines at the bottom of the window. */
5450 if (bottom_y
< height
)
5452 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5453 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5457 set_buffer_internal (old_buffer
);
5463 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5464 doc
: /* Center point in window and redisplay frame.
5465 With prefix argument ARG, recenter putting point on screen line ARG
5466 relative to the current window. If ARG is negative, it counts up from the
5467 bottom of the window. (ARG should be less than the height of the window.)
5469 If ARG is omitted or nil, erase the entire frame and then
5470 redraw with point in the center of the current window.
5471 Just C-u as prefix means put point in the center of the window
5472 and redisplay normally--don't erase and redraw the frame. */)
5474 register Lisp_Object arg
;
5476 struct window
*w
= XWINDOW (selected_window
);
5477 struct buffer
*buf
= XBUFFER (w
->buffer
);
5478 struct buffer
*obuf
= current_buffer
;
5480 int charpos
, bytepos
;
5482 int this_scroll_margin
;
5484 /* If redisplay is suppressed due to an error, try again. */
5485 obuf
->display_error_modiff
= 0;
5491 /* Invalidate pixel data calculated for all compositions. */
5492 for (i
= 0; i
< n_compositions
; i
++)
5493 composition_table
[i
]->font
= NULL
;
5495 Fredraw_frame (w
->frame
);
5496 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5499 else if (CONSP (arg
)) /* Just C-u. */
5503 arg
= Fprefix_numeric_value (arg
);
5508 set_buffer_internal (buf
);
5510 /* Do this after making BUF current
5511 in case scroll_margin is buffer-local. */
5512 this_scroll_margin
= max (0, scroll_margin
);
5513 this_scroll_margin
= min (this_scroll_margin
,
5514 XFASTINT (w
->total_lines
) / 4);
5516 /* Handle centering on a graphical frame specially. Such frames can
5517 have variable-height lines and centering point on the basis of
5518 line counts would lead to strange effects. */
5519 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5526 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5527 start_display (&it
, w
, pt
);
5528 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5529 charpos
= IT_CHARPOS (it
);
5530 bytepos
= IT_BYTEPOS (it
);
5537 int extra_line_spacing
;
5538 int h
= window_box_height (w
);
5540 iarg
= - max (-iarg
, this_scroll_margin
);
5542 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5543 start_display (&it
, w
, pt
);
5545 /* Be sure we have the exact height of the full line containing PT. */
5546 move_it_by_lines (&it
, 0, 1);
5548 /* The amount of pixels we have to move back is the window
5549 height minus what's displayed in the line containing PT,
5550 and the lines below. */
5553 move_it_by_lines (&it
, nlines
, 1);
5555 if (it
.vpos
== nlines
)
5559 /* Last line has no newline */
5560 h
-= line_bottom_y (&it
);
5564 /* Don't reserve space for extra line spacing of last line. */
5565 extra_line_spacing
= it
.max_extra_line_spacing
;
5567 /* If we can't move down NLINES lines because we hit
5568 the end of the buffer, count in some empty lines. */
5569 if (it
.vpos
< nlines
)
5572 extra_line_spacing
= it
.extra_line_spacing
;
5573 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5578 /* Now find the new top line (starting position) of the window. */
5579 start_display (&it
, w
, pt
);
5581 move_it_vertically_backward (&it
, h
);
5583 /* If extra line spacing is present, we may move too far
5584 back. This causes the last line to be only partially
5585 visible (which triggers redisplay to recenter that line
5586 in the middle), so move forward.
5587 But ignore extra line spacing on last line, as it is not
5588 considered to be part of the visible height of the line.
5590 h
+= extra_line_spacing
;
5591 while (-it
.current_y
> h
)
5592 move_it_by_lines (&it
, 1, 1);
5594 charpos
= IT_CHARPOS (it
);
5595 bytepos
= IT_BYTEPOS (it
);
5599 struct position pos
;
5601 iarg
= max (iarg
, this_scroll_margin
);
5603 pos
= *vmotion (PT
, -iarg
, w
);
5604 charpos
= pos
.bufpos
;
5605 bytepos
= pos
.bytepos
;
5610 struct position pos
;
5611 int ht
= window_internal_height (w
);
5618 /* Don't let it get into the margin at either top or bottom. */
5619 iarg
= max (iarg
, this_scroll_margin
);
5620 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5622 pos
= *vmotion (PT
, - iarg
, w
);
5623 charpos
= pos
.bufpos
;
5624 bytepos
= pos
.bytepos
;
5627 /* Set the new window start. */
5628 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5629 w
->window_end_valid
= Qnil
;
5631 w
->optional_new_start
= Qt
;
5633 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5634 w
->start_at_line_beg
= Qt
;
5636 w
->start_at_line_beg
= Qnil
;
5638 set_buffer_internal (obuf
);
5643 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5645 doc
: /* Return the height in lines of the text display area of WINDOW.
5646 This doesn't include the mode-line (or header-line if any) or any
5647 partial-height lines in the text display area. */)
5651 struct window
*w
= decode_window (window
);
5652 int pixel_height
= window_box_height (w
);
5653 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5654 return make_number (line_height
);
5659 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5661 doc
: /* Position point relative to window.
5662 With no argument, position point at center of window.
5663 An argument specifies vertical position within the window;
5664 zero means top of window, negative means relative to bottom of window. */)
5668 struct window
*w
= XWINDOW (selected_window
);
5672 int this_scroll_margin
;
5675 window
= selected_window
;
5676 start
= marker_position (w
->start
);
5677 if (start
< BEGV
|| start
> ZV
)
5679 int height
= window_internal_height (w
);
5680 Fvertical_motion (make_number (- (height
/ 2)), window
);
5681 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5682 w
->start_at_line_beg
= Fbolp ();
5683 w
->force_start
= Qt
;
5686 Fgoto_char (w
->start
);
5688 lines
= displayed_window_lines (w
);
5691 this_scroll_margin
= max (0, scroll_margin
);
5692 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5696 XSETFASTINT (arg
, lines
/ 2);
5699 int iarg
= XINT (Fprefix_numeric_value (arg
));
5702 iarg
= iarg
+ lines
;
5704 #if 0 /* This code would prevent move-to-window-line from moving point
5705 to a place inside the scroll margins (which would cause the
5706 next redisplay to scroll). I wrote this code, but then concluded
5707 it is probably better not to install it. However, it is here
5708 inside #if 0 so as not to lose it. -- rms. */
5710 /* Don't let it get into the margin at either top or bottom. */
5711 iarg
= max (iarg
, this_scroll_margin
);
5712 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5715 arg
= make_number (iarg
);
5718 /* Skip past a partially visible first line. */
5720 XSETINT (arg
, XINT (arg
) + 1);
5722 return Fvertical_motion (arg
, window
);
5727 /***********************************************************************
5728 Window Configuration
5729 ***********************************************************************/
5731 struct save_window_data
5733 EMACS_INT size_from_Lisp_Vector_struct
;
5734 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5735 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5736 Lisp_Object frame_tool_bar_lines
;
5737 Lisp_Object selected_frame
;
5738 Lisp_Object current_window
;
5739 Lisp_Object current_buffer
;
5740 Lisp_Object minibuf_scroll_window
;
5741 Lisp_Object minibuf_selected_window
;
5742 Lisp_Object root_window
;
5743 Lisp_Object focus_frame
;
5744 /* Record the values of window-min-width and window-min-height
5745 so that window sizes remain consistent with them. */
5746 Lisp_Object min_width
, min_height
;
5747 /* A vector, each of whose elements is a struct saved_window
5749 Lisp_Object saved_windows
;
5752 /* This is saved as a Lisp_Vector */
5755 /* these first two must agree with struct Lisp_Vector in lisp.h */
5756 EMACS_INT size_from_Lisp_Vector_struct
;
5757 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5760 Lisp_Object buffer
, start
, pointm
, mark
;
5761 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5762 Lisp_Object hscroll
, min_hscroll
;
5763 Lisp_Object parent
, prev
;
5764 Lisp_Object start_at_line_beg
;
5765 Lisp_Object display_table
;
5766 Lisp_Object orig_top_line
, orig_total_lines
;
5767 Lisp_Object left_margin_cols
, right_margin_cols
;
5768 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5769 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5772 #define SAVED_WINDOW_N(swv,n) \
5773 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5775 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5776 doc
: /* Return t if OBJECT is a window-configuration object. */)
5780 if (WINDOW_CONFIGURATIONP (object
))
5785 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5786 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5790 register struct save_window_data
*data
;
5791 struct Lisp_Vector
*saved_windows
;
5793 if (! WINDOW_CONFIGURATIONP (config
))
5794 wrong_type_argument (Qwindow_configuration_p
, config
);
5796 data
= (struct save_window_data
*) XVECTOR (config
);
5797 saved_windows
= XVECTOR (data
->saved_windows
);
5798 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5801 DEFUN ("set-window-configuration", Fset_window_configuration
,
5802 Sset_window_configuration
, 1, 1, 0,
5803 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5804 CONFIGURATION must be a value previously returned
5805 by `current-window-configuration' (which see).
5806 If CONFIGURATION was made from a frame that is now deleted,
5807 only frame-independent values can be restored. In this case,
5808 the return value is nil. Otherwise the value is t. */)
5810 Lisp_Object configuration
;
5812 register struct save_window_data
*data
;
5813 struct Lisp_Vector
*saved_windows
;
5814 Lisp_Object new_current_buffer
;
5819 while (!WINDOW_CONFIGURATIONP (configuration
))
5820 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5822 data
= (struct save_window_data
*) XVECTOR (configuration
);
5823 saved_windows
= XVECTOR (data
->saved_windows
);
5825 new_current_buffer
= data
->current_buffer
;
5826 if (NILP (XBUFFER (new_current_buffer
)->name
))
5827 new_current_buffer
= Qnil
;
5830 if (XBUFFER (new_current_buffer
) == current_buffer
)
5831 /* The code further down "preserves point" by saving here PT in
5832 old_point and then setting it later back into PT. When the
5833 current-selected-window and the final-selected-window both show
5834 the current buffer, this suffers from the problem that the
5835 current PT is the window-point of the current-selected-window,
5836 while the final PT is the point of the final-selected-window, so
5837 this copy from one PT to the other would end up moving the
5838 window-point of the final-selected-window to the window-point of
5839 the current-selected-window. So we have to be careful which
5840 point of the current-buffer we copy into old_point. */
5841 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5842 && WINDOWP (selected_window
)
5843 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5844 && !EQ (selected_window
, data
->current_window
))
5845 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5849 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5850 point in new_current_buffer as of the last time this buffer was
5851 used. This can be non-deterministic since it can be changed by
5852 things like jit-lock by mere temporary selection of some random
5853 window that happens to show this buffer.
5854 So if possible we want this arbitrary choice of "which point" to
5855 be the one from the to-be-selected-window so as to prevent this
5856 window's cursor from being copied from another window. */
5857 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5858 /* If current_window = selected_window, its point is in BUF_PT. */
5859 && !EQ (selected_window
, data
->current_window
))
5860 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5862 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5865 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5868 /* If f is a dead frame, don't bother rebuilding its window tree.
5869 However, there is other stuff we should still try to do below. */
5870 if (FRAME_LIVE_P (f
))
5872 register struct window
*w
;
5873 register struct saved_window
*p
;
5874 struct window
*root_window
;
5875 struct window
**leaf_windows
;
5879 /* If the frame has been resized since this window configuration was
5880 made, we change the frame to the size specified in the
5881 configuration, restore the configuration, and then resize it
5882 back. We keep track of the prevailing height in these variables. */
5883 int previous_frame_lines
= FRAME_LINES (f
);
5884 int previous_frame_cols
= FRAME_COLS (f
);
5885 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5886 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5888 /* The mouse highlighting code could get screwed up
5889 if it runs during this. */
5892 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5893 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5894 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5895 XFASTINT (data
->frame_cols
), 0, 0, 0);
5896 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5897 if (XFASTINT (data
->frame_menu_bar_lines
)
5898 != previous_frame_menu_bar_lines
)
5899 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5900 #ifdef HAVE_WINDOW_SYSTEM
5901 if (XFASTINT (data
->frame_tool_bar_lines
)
5902 != previous_frame_tool_bar_lines
)
5903 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5907 /* "Swap out" point from the selected window's buffer
5908 into the window itself. (Normally the pointm of the selected
5909 window holds garbage.) We do this now, before
5910 restoring the window contents, and prevent it from
5911 being done later on when we select a new window. */
5912 if (! NILP (XWINDOW (selected_window
)->buffer
))
5914 w
= XWINDOW (selected_window
);
5915 set_marker_both (w
->pointm
,
5917 BUF_PT (XBUFFER (w
->buffer
)),
5918 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5921 windows_or_buffers_changed
++;
5922 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5924 /* Problem: Freeing all matrices and later allocating them again
5925 is a serious redisplay flickering problem. What we would
5926 really like to do is to free only those matrices not reused
5928 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5930 = (struct window
**) alloca (count_windows (root_window
)
5931 * sizeof (struct window
*));
5932 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5934 /* Temporarily avoid any problems with windows that are smaller
5935 than they are supposed to be. */
5936 window_min_height
= 1;
5937 window_min_width
= 1;
5940 Mark all windows now on frame as "deleted".
5941 Restoring the new configuration "undeletes" any that are in it.
5943 Save their current buffers in their height fields, since we may
5944 need it later, if a buffer saved in the configuration is now
5946 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5948 for (k
= 0; k
< saved_windows
->size
; k
++)
5950 p
= SAVED_WINDOW_N (saved_windows
, k
);
5951 w
= XWINDOW (p
->window
);
5954 if (!NILP (p
->parent
))
5955 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5956 XFASTINT (p
->parent
))->window
;
5960 if (!NILP (p
->prev
))
5962 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5963 XFASTINT (p
->prev
))->window
;
5964 XWINDOW (w
->prev
)->next
= p
->window
;
5969 if (!NILP (w
->parent
))
5971 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5973 XWINDOW (w
->parent
)->vchild
= p
->window
;
5974 XWINDOW (w
->parent
)->hchild
= Qnil
;
5978 XWINDOW (w
->parent
)->hchild
= p
->window
;
5979 XWINDOW (w
->parent
)->vchild
= Qnil
;
5984 /* If we squirreled away the buffer in the window's height,
5986 if (BUFFERP (w
->total_lines
))
5987 w
->buffer
= w
->total_lines
;
5988 w
->left_col
= p
->left_col
;
5989 w
->top_line
= p
->top_line
;
5990 w
->total_cols
= p
->total_cols
;
5991 w
->total_lines
= p
->total_lines
;
5992 w
->hscroll
= p
->hscroll
;
5993 w
->min_hscroll
= p
->min_hscroll
;
5994 w
->display_table
= p
->display_table
;
5995 w
->orig_top_line
= p
->orig_top_line
;
5996 w
->orig_total_lines
= p
->orig_total_lines
;
5997 w
->left_margin_cols
= p
->left_margin_cols
;
5998 w
->right_margin_cols
= p
->right_margin_cols
;
5999 w
->left_fringe_width
= p
->left_fringe_width
;
6000 w
->right_fringe_width
= p
->right_fringe_width
;
6001 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6002 w
->scroll_bar_width
= p
->scroll_bar_width
;
6003 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6004 XSETFASTINT (w
->last_modified
, 0);
6005 XSETFASTINT (w
->last_overlay_modified
, 0);
6007 /* Reinstall the saved buffer and pointers into it. */
6008 if (NILP (p
->buffer
))
6009 w
->buffer
= p
->buffer
;
6012 if (!NILP (XBUFFER (p
->buffer
)->name
))
6013 /* If saved buffer is alive, install it. */
6015 w
->buffer
= p
->buffer
;
6016 w
->start_at_line_beg
= p
->start_at_line_beg
;
6017 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6018 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6019 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6020 p
->mark
, w
->buffer
);
6022 /* As documented in Fcurrent_window_configuration, don't
6023 restore the location of point in the buffer which was
6024 current when the window configuration was recorded. */
6025 if (!EQ (p
->buffer
, new_current_buffer
)
6026 && XBUFFER (p
->buffer
) == current_buffer
)
6027 Fgoto_char (w
->pointm
);
6029 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6030 /* Else unless window has a live buffer, get one. */
6032 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6033 /* This will set the markers to beginning of visible
6035 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6036 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6037 w
->start_at_line_beg
= Qt
;
6040 /* Keeping window's old buffer; make sure the markers
6043 /* Set window markers at start of visible range. */
6044 if (XMARKER (w
->start
)->buffer
== 0)
6045 set_marker_restricted (w
->start
, make_number (0),
6047 if (XMARKER (w
->pointm
)->buffer
== 0)
6048 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6049 BUF_PT (XBUFFER (w
->buffer
)),
6050 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6051 w
->start_at_line_beg
= Qt
;
6056 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6057 /* Prevent "swapping out point" in the old selected window
6058 using the buffer that has been restored into it.
6059 We already swapped out point that from that window's old buffer. */
6060 selected_window
= Qnil
;
6062 /* Arrange *not* to restore point in the buffer that was
6063 current when the window configuration was saved. */
6064 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6065 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6066 make_number (old_point
),
6067 XWINDOW (data
->current_window
)->buffer
);
6069 Fselect_window (data
->current_window
, Qnil
);
6070 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6073 if (NILP (data
->focus_frame
)
6074 || (FRAMEP (data
->focus_frame
)
6075 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6076 Fredirect_frame_focus (frame
, data
->focus_frame
);
6078 #if 0 /* I don't understand why this is needed, and it causes problems
6079 when the frame's old selected window has been deleted. */
6080 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6081 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6085 /* Set the screen height to the value it had before this function. */
6086 if (previous_frame_lines
!= FRAME_LINES (f
)
6087 || previous_frame_cols
!= FRAME_COLS (f
))
6088 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6090 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6091 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6092 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6094 #ifdef HAVE_WINDOW_SYSTEM
6095 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6096 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6101 /* Now, free glyph matrices in windows that were not reused. */
6102 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6104 if (NILP (leaf_windows
[i
]->buffer
))
6106 /* Assert it's not reused as a combination. */
6107 xassert (NILP (leaf_windows
[i
]->hchild
)
6108 && NILP (leaf_windows
[i
]->vchild
));
6109 free_window_matrices (leaf_windows
[i
]);
6111 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6119 /* Fselect_window will have made f the selected frame, so we
6120 reselect the proper frame here. Fhandle_switch_frame will change the
6121 selected window too, but that doesn't make the call to
6122 Fselect_window above totally superfluous; it still sets f's
6124 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6125 do_switch_frame (data
->selected_frame
, 0, 0);
6127 if (! NILP (Vwindow_configuration_change_hook
)
6128 && ! NILP (Vrun_hooks
))
6129 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6132 if (!NILP (new_current_buffer
))
6133 Fset_buffer (new_current_buffer
);
6135 /* Restore the minimum heights recorded in the configuration. */
6136 window_min_height
= XINT (data
->min_height
);
6137 window_min_width
= XINT (data
->min_width
);
6139 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6140 minibuf_selected_window
= data
->minibuf_selected_window
;
6142 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6145 /* Mark all windows now on frame as deleted
6146 by setting their buffers to nil. */
6149 delete_all_subwindows (w
)
6150 register struct window
*w
;
6152 if (!NILP (w
->next
))
6153 delete_all_subwindows (XWINDOW (w
->next
));
6154 if (!NILP (w
->vchild
))
6155 delete_all_subwindows (XWINDOW (w
->vchild
));
6156 if (!NILP (w
->hchild
))
6157 delete_all_subwindows (XWINDOW (w
->hchild
));
6159 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6161 if (!NILP (w
->buffer
))
6164 /* We set all three of these fields to nil, to make sure that we can
6165 distinguish this dead window from any live window. Live leaf
6166 windows will have buffer set, and combination windows will have
6167 vchild or hchild set. */
6172 Vwindow_list
= Qnil
;
6176 count_windows (window
)
6177 register struct window
*window
;
6179 register int count
= 1;
6180 if (!NILP (window
->next
))
6181 count
+= count_windows (XWINDOW (window
->next
));
6182 if (!NILP (window
->vchild
))
6183 count
+= count_windows (XWINDOW (window
->vchild
));
6184 if (!NILP (window
->hchild
))
6185 count
+= count_windows (XWINDOW (window
->hchild
));
6190 /* Fill vector FLAT with leaf windows under W, starting at index I.
6191 Value is last index + 1. */
6194 get_leaf_windows (w
, flat
, i
)
6196 struct window
**flat
;
6201 if (!NILP (w
->hchild
))
6202 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6203 else if (!NILP (w
->vchild
))
6204 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6208 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6215 /* Return a pointer to the glyph W's physical cursor is on. Value is
6216 null if W's current matrix is invalid, so that no meaningfull glyph
6220 get_phys_cursor_glyph (w
)
6223 struct glyph_row
*row
;
6224 struct glyph
*glyph
;
6226 if (w
->phys_cursor
.vpos
>= 0
6227 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6228 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6230 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6231 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6240 save_window_save (window
, vector
, i
)
6242 struct Lisp_Vector
*vector
;
6245 register struct saved_window
*p
;
6246 register struct window
*w
;
6247 register Lisp_Object tem
;
6249 for (;!NILP (window
); window
= w
->next
)
6251 p
= SAVED_WINDOW_N (vector
, i
);
6252 w
= XWINDOW (window
);
6254 XSETFASTINT (w
->temslot
, i
); i
++;
6256 p
->buffer
= w
->buffer
;
6257 p
->left_col
= w
->left_col
;
6258 p
->top_line
= w
->top_line
;
6259 p
->total_cols
= w
->total_cols
;
6260 p
->total_lines
= w
->total_lines
;
6261 p
->hscroll
= w
->hscroll
;
6262 p
->min_hscroll
= w
->min_hscroll
;
6263 p
->display_table
= w
->display_table
;
6264 p
->orig_top_line
= w
->orig_top_line
;
6265 p
->orig_total_lines
= w
->orig_total_lines
;
6266 p
->left_margin_cols
= w
->left_margin_cols
;
6267 p
->right_margin_cols
= w
->right_margin_cols
;
6268 p
->left_fringe_width
= w
->left_fringe_width
;
6269 p
->right_fringe_width
= w
->right_fringe_width
;
6270 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6271 p
->scroll_bar_width
= w
->scroll_bar_width
;
6272 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6273 if (!NILP (w
->buffer
))
6275 /* Save w's value of point in the window configuration.
6276 If w is the selected window, then get the value of point
6277 from the buffer; pointm is garbage in the selected window. */
6278 if (EQ (window
, selected_window
))
6280 p
->pointm
= Fmake_marker ();
6281 set_marker_both (p
->pointm
, w
->buffer
,
6282 BUF_PT (XBUFFER (w
->buffer
)),
6283 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6286 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6288 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6289 p
->start_at_line_beg
= w
->start_at_line_beg
;
6291 tem
= XBUFFER (w
->buffer
)->mark
;
6292 p
->mark
= Fcopy_marker (tem
, Qnil
);
6299 p
->start_at_line_beg
= Qnil
;
6302 if (NILP (w
->parent
))
6305 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6310 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6312 if (!NILP (w
->vchild
))
6313 i
= save_window_save (w
->vchild
, vector
, i
);
6314 if (!NILP (w
->hchild
))
6315 i
= save_window_save (w
->hchild
, vector
, i
);
6321 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6322 Scurrent_window_configuration
, 0, 1, 0,
6323 doc
: /* Return an object representing the current window configuration of FRAME.
6324 If FRAME is nil or omitted, use the selected frame.
6325 This describes the number of windows, their sizes and current buffers,
6326 and for each displayed buffer, where display starts, and the positions of
6327 point and mark. An exception is made for point in the current buffer:
6328 its value is -not- saved.
6329 This also records the currently selected frame, and FRAME's focus
6330 redirection (see `redirect-frame-focus'). */)
6334 register Lisp_Object tem
;
6335 register int n_windows
;
6336 register struct save_window_data
*data
;
6337 register struct Lisp_Vector
*vec
;
6342 frame
= selected_frame
;
6343 CHECK_LIVE_FRAME (frame
);
6346 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6347 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6348 data
= (struct save_window_data
*)vec
;
6350 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6351 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6352 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6353 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6354 data
->selected_frame
= selected_frame
;
6355 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6356 XSETBUFFER (data
->current_buffer
, current_buffer
);
6357 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6358 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6359 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6360 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6361 XSETINT (data
->min_height
, window_min_height
);
6362 XSETINT (data
->min_width
, window_min_width
);
6363 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6364 data
->saved_windows
= tem
;
6365 for (i
= 0; i
< n_windows
; i
++)
6366 XVECTOR (tem
)->contents
[i
]
6367 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6368 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6369 XSETWINDOW_CONFIGURATION (tem
, data
);
6373 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6375 doc
: /* Execute BODY, preserving window sizes and contents.
6376 Return the value of the last form in BODY.
6377 Restore which buffer appears in which window, where display starts,
6378 and the value of point and mark for each window.
6379 Also restore the choice of selected window.
6380 Also restore which buffer is current.
6381 Does not restore the value of point in current buffer.
6382 usage: (save-window-excursion BODY ...) */)
6386 register Lisp_Object val
;
6387 register int count
= SPECPDL_INDEX ();
6389 record_unwind_protect (Fset_window_configuration
,
6390 Fcurrent_window_configuration (Qnil
));
6391 val
= Fprogn (args
);
6392 return unbind_to (count
, val
);
6397 /***********************************************************************
6399 ***********************************************************************/
6405 Lisp_Object tail
= Qnil
;
6406 Lisp_Object result
= Qnil
;
6413 if (!NILP (w
->hchild
))
6414 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6415 window_tree (XWINDOW (w
->hchild
))));
6416 else if (!NILP (w
->vchild
))
6417 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6418 window_tree (XWINDOW (w
->vchild
))));
6422 result
= tail
= Fcons (wn
, Qnil
);
6426 XSETCDR (tail
, Fcons (wn
, Qnil
));
6430 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6438 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6440 doc
: /* Return the window tree for frame FRAME.
6442 The return value is a list of the form (ROOT MINI), where ROOT
6443 represents the window tree of the frame's root window, and MINI
6444 is the frame's minibuffer window.
6446 If the root window is not split, ROOT is the root window itself.
6447 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6448 horizontal split, and t for a vertical split, EDGES gives the combined
6449 size and position of the subwindows in the split, and the rest of the
6450 elements are the subwindows in the split. Each of the subwindows may
6451 again be a window or a list representing a window split, and so on.
6452 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6454 If FRAME is nil or omitted, return information on the currently
6462 frame
= selected_frame
;
6464 CHECK_FRAME (frame
);
6467 if (!FRAME_LIVE_P (f
))
6470 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6474 /***********************************************************************
6476 ***********************************************************************/
6478 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6480 doc
: /* Set width of marginal areas of window WINDOW.
6481 If WINDOW is nil, set margins of the currently selected window.
6482 Second arg LEFT-WIDTH specifies the number of character cells to
6483 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6484 does the same for the right marginal area. A nil width parameter
6485 means no margin. */)
6486 (window
, left_width
, right_width
)
6487 Lisp_Object window
, left_width
, right_width
;
6489 struct window
*w
= decode_window (window
);
6491 /* Translate negative or zero widths to nil.
6492 Margins that are too wide have to be checked elsewhere. */
6494 if (!NILP (left_width
))
6496 CHECK_NUMBER (left_width
);
6497 if (XINT (left_width
) <= 0)
6501 if (!NILP (right_width
))
6503 CHECK_NUMBER (right_width
);
6504 if (XINT (right_width
) <= 0)
6508 if (!EQ (w
->left_margin_cols
, left_width
)
6509 || !EQ (w
->right_margin_cols
, right_width
))
6511 w
->left_margin_cols
= left_width
;
6512 w
->right_margin_cols
= right_width
;
6514 adjust_window_margins (w
);
6516 ++windows_or_buffers_changed
;
6517 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6524 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6526 doc
: /* Get width of marginal areas of window WINDOW.
6527 If WINDOW is omitted or nil, use the currently selected window.
6528 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6529 If a marginal area does not exist, its width will be returned
6534 struct window
*w
= decode_window (window
);
6535 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6540 /***********************************************************************
6542 ***********************************************************************/
6544 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6546 doc
: /* Set the fringe widths of window WINDOW.
6547 If WINDOW is nil, set the fringe widths of the currently selected
6549 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6550 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6551 fringe width. If a fringe width arg is nil, that means to use the
6552 frame's default fringe width. Default fringe widths can be set with
6553 the command `set-fringe-style'.
6554 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6555 outside of the display margins. By default, fringes are drawn between
6556 display marginal areas and the text area. */)
6557 (window
, left_width
, right_width
, outside_margins
)
6558 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6560 struct window
*w
= decode_window (window
);
6562 if (!NILP (left_width
))
6563 CHECK_NATNUM (left_width
);
6564 if (!NILP (right_width
))
6565 CHECK_NATNUM (right_width
);
6567 if (!EQ (w
->left_fringe_width
, left_width
)
6568 || !EQ (w
->right_fringe_width
, right_width
)
6569 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6571 w
->left_fringe_width
= left_width
;
6572 w
->right_fringe_width
= right_width
;
6573 w
->fringes_outside_margins
= outside_margins
;
6575 adjust_window_margins (w
);
6577 clear_glyph_matrix (w
->current_matrix
);
6578 w
->window_end_valid
= Qnil
;
6580 ++windows_or_buffers_changed
;
6581 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6588 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6590 doc
: /* Get width of fringes of window WINDOW.
6591 If WINDOW is omitted or nil, use the currently selected window.
6592 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6596 struct window
*w
= decode_window (window
);
6597 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6598 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6599 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6600 Qt
: Qnil
), Qnil
)));
6605 /***********************************************************************
6607 ***********************************************************************/
6609 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6611 doc
: /* Set width and type of scroll bars of window WINDOW.
6612 If window is nil, set scroll bars of the currently selected window.
6613 Second parameter WIDTH specifies the pixel width for the scroll bar;
6614 this is automatically adjusted to a multiple of the frame column width.
6615 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6616 bar: left, right, or nil.
6617 If WIDTH is nil, use the frame's scroll-bar width.
6618 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6619 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6620 (window
, width
, vertical_type
, horizontal_type
)
6621 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6623 struct window
*w
= decode_window (window
);
6627 CHECK_NATNUM (width
);
6629 if (XINT (width
) == 0)
6630 vertical_type
= Qnil
;
6633 if (!(EQ (vertical_type
, Qnil
)
6634 || EQ (vertical_type
, Qleft
)
6635 || EQ (vertical_type
, Qright
)
6636 || EQ (vertical_type
, Qt
)))
6637 error ("Invalid type of vertical scroll bar");
6639 if (!EQ (w
->scroll_bar_width
, width
)
6640 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6642 w
->scroll_bar_width
= width
;
6643 w
->vertical_scroll_bar_type
= vertical_type
;
6645 adjust_window_margins (w
);
6647 clear_glyph_matrix (w
->current_matrix
);
6648 w
->window_end_valid
= Qnil
;
6650 ++windows_or_buffers_changed
;
6651 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6658 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6660 doc
: /* Get width and type of scroll bars of window WINDOW.
6661 If WINDOW is omitted or nil, use the currently selected window.
6662 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6663 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6668 struct window
*w
= decode_window (window
);
6669 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6670 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6671 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6672 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6673 Fcons (w
->vertical_scroll_bar_type
,
6674 Fcons (Qnil
, Qnil
))));
6679 /***********************************************************************
6681 ***********************************************************************/
6683 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6684 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6685 Use the selected window if WINDOW is nil or omitted.
6686 Normally, value is a multiple of the canonical character height of WINDOW;
6687 optional second arg PIXELS-P means value is measured in pixels. */)
6689 Lisp_Object window
, pixels_p
;
6696 window
= selected_window
;
6698 CHECK_WINDOW (window
);
6699 w
= XWINDOW (window
);
6700 f
= XFRAME (w
->frame
);
6702 if (FRAME_WINDOW_P (f
))
6703 result
= (NILP (pixels_p
)
6704 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6705 : make_number (-w
->vscroll
));
6707 result
= make_number (0);
6712 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6714 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6715 WINDOW nil means use the selected window. Normally, VSCROLL is a
6716 non-negative multiple of the canonical character height of WINDOW;
6717 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6718 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6719 corresponds to an integral number of pixels. The return value is the
6720 result of this rounding.
6721 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6722 (window
, vscroll
, pixels_p
)
6723 Lisp_Object window
, vscroll
, pixels_p
;
6729 window
= selected_window
;
6731 CHECK_WINDOW (window
);
6732 CHECK_NUMBER_OR_FLOAT (vscroll
);
6734 w
= XWINDOW (window
);
6735 f
= XFRAME (w
->frame
);
6737 if (FRAME_WINDOW_P (f
))
6739 int old_dy
= w
->vscroll
;
6741 w
->vscroll
= - (NILP (pixels_p
)
6742 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6743 : XFLOATINT (vscroll
));
6744 w
->vscroll
= min (w
->vscroll
, 0);
6746 if (w
->vscroll
!= old_dy
)
6748 /* Adjust glyph matrix of the frame if the virtual display
6749 area becomes larger than before. */
6750 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6753 /* Prevent redisplay shortcuts. */
6754 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6758 return Fwindow_vscroll (window
, pixels_p
);
6762 /* Call FN for all leaf windows on frame F. FN is called with the
6763 first argument being a pointer to the leaf window, and with
6764 additional argument USER_DATA. Stops when FN returns 0. */
6767 foreach_window (f
, fn
, user_data
)
6769 int (* fn
) P_ ((struct window
*, void *));
6772 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6776 /* Helper function for foreach_window. Call FN for all leaf windows
6777 reachable from W. FN is called with the first argument being a
6778 pointer to the leaf window, and with additional argument USER_DATA.
6779 Stop when FN returns 0. Value is 0 if stopped by FN. */
6782 foreach_window_1 (w
, fn
, user_data
)
6784 int (* fn
) P_ ((struct window
*, void *));
6789 for (cont
= 1; w
&& cont
;)
6791 if (!NILP (w
->hchild
))
6792 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6793 else if (!NILP (w
->vchild
))
6794 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6796 cont
= fn (w
, user_data
);
6798 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6805 /* Freeze or unfreeze the window start of W unless it is a
6806 mini-window or the selected window. FREEZE_P non-null means freeze
6807 the window start. */
6810 freeze_window_start (w
, freeze_p
)
6814 if (w
== XWINDOW (selected_window
)
6815 || MINI_WINDOW_P (w
)
6816 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6817 && ! NILP (Vminibuf_scroll_window
)
6818 && w
== XWINDOW (Vminibuf_scroll_window
)))
6821 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6826 /* Freeze or unfreeze the window starts of all leaf windows on frame
6827 F, except the selected window and a mini-window. FREEZE_P non-zero
6828 means freeze the window start. */
6831 freeze_window_starts (f
, freeze_p
)
6835 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6839 /***********************************************************************
6841 ***********************************************************************/
6843 /* Return 1 if window configurations C1 and C2
6844 describe the same state of affairs. This is used by Fequal. */
6847 compare_window_configurations (c1
, c2
, ignore_positions
)
6849 int ignore_positions
;
6851 register struct save_window_data
*d1
, *d2
;
6852 struct Lisp_Vector
*sw1
, *sw2
;
6855 if (!WINDOW_CONFIGURATIONP (c1
))
6856 wrong_type_argument (Qwindow_configuration_p
, c1
);
6857 if (!WINDOW_CONFIGURATIONP (c2
))
6858 wrong_type_argument (Qwindow_configuration_p
, c2
);
6860 d1
= (struct save_window_data
*) XVECTOR (c1
);
6861 d2
= (struct save_window_data
*) XVECTOR (c2
);
6862 sw1
= XVECTOR (d1
->saved_windows
);
6863 sw2
= XVECTOR (d2
->saved_windows
);
6865 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6867 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6869 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6871 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6873 /* Don't compare the current_window field directly.
6874 Instead see w1_is_current and w2_is_current, below. */
6875 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6877 if (! ignore_positions
)
6879 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6881 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6884 /* Don't compare the root_window field.
6885 We don't require the two configurations
6886 to use the same window object,
6887 and the two root windows must be equivalent
6888 if everything else compares equal. */
6889 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6891 if (! EQ (d1
->min_width
, d2
->min_width
))
6893 if (! EQ (d1
->min_height
, d2
->min_height
))
6896 /* Verify that the two confis have the same number of windows. */
6897 if (sw1
->size
!= sw2
->size
)
6900 for (i
= 0; i
< sw1
->size
; i
++)
6902 struct saved_window
*p1
, *p2
;
6903 int w1_is_current
, w2_is_current
;
6905 p1
= SAVED_WINDOW_N (sw1
, i
);
6906 p2
= SAVED_WINDOW_N (sw2
, i
);
6908 /* Verify that the current windows in the two
6909 configurations correspond to each other. */
6910 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6911 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6913 if (w1_is_current
!= w2_is_current
)
6916 /* Verify that the corresponding windows do match. */
6917 if (! EQ (p1
->buffer
, p2
->buffer
))
6919 if (! EQ (p1
->left_col
, p2
->left_col
))
6921 if (! EQ (p1
->top_line
, p2
->top_line
))
6923 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6925 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6927 if (! EQ (p1
->display_table
, p2
->display_table
))
6929 if (! EQ (p1
->parent
, p2
->parent
))
6931 if (! EQ (p1
->prev
, p2
->prev
))
6933 if (! ignore_positions
)
6935 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6937 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6939 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6941 if (NILP (Fequal (p1
->start
, p2
->start
)))
6943 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6945 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6948 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6950 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6952 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6954 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6956 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6958 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6960 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6967 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6968 Scompare_window_configurations
, 2, 2, 0,
6969 doc
: /* Compare two window configurations as regards the structure of windows.
6970 This function ignores details such as the values of point and mark
6971 and scrolling positions. */)
6975 if (compare_window_configurations (x
, y
, 1))
6983 struct frame
*f
= make_initial_frame ();
6984 XSETFRAME (selected_frame
, f
);
6985 Vterminal_frame
= selected_frame
;
6986 minibuf_window
= f
->minibuffer_window
;
6987 selected_window
= f
->selected_window
;
6988 last_nonminibuf_frame
= f
;
6990 window_initialized
= 1;
6996 Vwindow_list
= Qnil
;
7002 Qscroll_up
= intern ("scroll-up");
7003 staticpro (&Qscroll_up
);
7005 Qscroll_down
= intern ("scroll-down");
7006 staticpro (&Qscroll_down
);
7008 Qwindow_size_fixed
= intern ("window-size-fixed");
7009 staticpro (&Qwindow_size_fixed
);
7010 Fset (Qwindow_size_fixed
, Qnil
);
7012 staticpro (&Qwindow_configuration_change_hook
);
7013 Qwindow_configuration_change_hook
7014 = intern ("window-configuration-change-hook");
7016 Qwindowp
= intern ("windowp");
7017 staticpro (&Qwindowp
);
7019 Qwindow_configuration_p
= intern ("window-configuration-p");
7020 staticpro (&Qwindow_configuration_p
);
7022 Qwindow_live_p
= intern ("window-live-p");
7023 staticpro (&Qwindow_live_p
);
7025 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7026 staticpro (&Qtemp_buffer_show_hook
);
7028 staticpro (&Vwindow_list
);
7030 minibuf_selected_window
= Qnil
;
7031 staticpro (&minibuf_selected_window
);
7033 window_scroll_pixel_based_preserve_y
= -1;
7035 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7036 doc
: /* Non-nil means call as function to display a help buffer.
7037 The function is called with one argument, the buffer to be displayed.
7038 Used by `with-output-to-temp-buffer'.
7039 If this function is used, then it must do the entire job of showing
7040 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7041 Vtemp_buffer_show_function
= Qnil
;
7043 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7044 doc
: /* If non-nil, function to call to handle `display-buffer'.
7045 It will receive two args, the buffer and a flag which if non-nil means
7046 that the currently selected window is not acceptable.
7047 It should choose or create a window, display the specified buffer in it,
7048 and return the window.
7049 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7050 work using this function. */);
7051 Vdisplay_buffer_function
= Qnil
;
7053 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7054 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7055 If nil, `display-buffer' will leave the window configuration alone. */);
7056 Veven_window_heights
= Qt
;
7058 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7059 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7060 Vminibuf_scroll_window
= Qnil
;
7062 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7063 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7064 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7065 is displayed in the `mode-line' face. */);
7066 mode_line_in_non_selected_windows
= 1;
7068 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7069 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7070 Vother_window_scroll_buffer
= Qnil
;
7072 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7073 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7076 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7077 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7078 auto_window_vscroll_p
= 1;
7080 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7081 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7082 If the buffer in question is already displayed in a frame, raise that frame. */);
7083 display_buffer_reuse_frames
= 0;
7085 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7086 doc
: /* Function to call to handle automatic new frame creation.
7087 It is called with no arguments and should return a newly created frame.
7089 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7090 where `pop-up-frame-alist' would hold the default frame parameters. */);
7091 Vpop_up_frame_function
= Qnil
;
7093 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7094 doc
: /* *List of buffer names that should have their own special frames.
7095 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7096 if its name is in this list, makes a special frame for it
7097 using `special-display-function'. See also `special-display-regexps'.
7099 An element of the list can be a list instead of just a string.
7100 There are two ways to use a list as an element:
7101 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7102 In the first case, the FRAME-PARAMETERS are pairs of the form
7103 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7104 In the second case, FUNCTION is called with BUFFER as the first argument,
7105 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7106 All this is done by the function found in `special-display-function'.
7108 If the specified frame parameters include (same-buffer . t), the
7109 buffer is displayed in the currently selected window. Otherwise, if
7110 they include (same-frame . t), the buffer is displayed in a new window
7111 in the currently selected frame.
7113 If this variable appears \"not to work\", because you add a name to it
7114 but that buffer still appears in the selected window, look at the
7115 values of `same-window-buffer-names' and `same-window-regexps'.
7116 Those variables take precedence over this one. */);
7117 Vspecial_display_buffer_names
= Qnil
;
7119 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7120 doc
: /* *List of regexps saying which buffers should have their own special frames.
7121 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7122 if any regexp in this list matches the buffer name, it makes a
7123 special frame for the buffer by calling `special-display-function'.
7125 An element of the list can be a list instead of just a string.
7126 There are two ways to use a list as an element:
7127 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7128 In the first case, the FRAME-PARAMETERS are pairs of the form
7129 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7130 In the second case, FUNCTION is called with BUFFER as the first argument,
7131 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7132 All this is done by the function found in `special-display-function'.
7134 If the specified frame parameters include (same-buffer . t), the
7135 buffer is displayed in the currently selected window. Otherwise, if
7136 they include (same-frame . t), the buffer is displayed in a new window
7137 in the currently selected frame.
7139 If this variable appears \"not to work\", because you add a regexp to it
7140 but the matching buffers still appear in the selected window, look at the
7141 values of `same-window-buffer-names' and `same-window-regexps'.
7142 Those variables take precedence over this one. */);
7143 Vspecial_display_regexps
= Qnil
;
7145 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7146 doc
: /* Function to call to make a new frame for a special buffer.
7147 It is called with two arguments, the buffer and optional buffer specific
7148 data, and should return a window displaying that buffer.
7149 The default value normally makes a separate frame for the buffer,
7150 using `special-display-frame-alist' to specify the frame parameters.
7151 But if the buffer specific data includes (same-buffer . t) then the
7152 buffer is displayed in the current selected window.
7153 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7154 a new window in the currently selected frame.
7156 A buffer is special if it is listed in `special-display-buffer-names'
7157 or matches a regexp in `special-display-regexps'. */);
7158 Vspecial_display_function
= Qnil
;
7160 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7161 doc
: /* *List of buffer names that should appear in the selected window.
7162 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7163 switches to it in the selected window, rather than making it appear
7164 in some other window.
7166 An element of the list can be a cons cell instead of just a string.
7167 Then the car must be a string, which specifies the buffer name.
7168 This is for compatibility with `special-display-buffer-names';
7169 the cdr of the cons cell is ignored.
7171 See also `same-window-regexps'. */);
7172 Vsame_window_buffer_names
= Qnil
;
7174 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7175 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7176 If a buffer name matches one of these regexps, then displaying it
7177 using `display-buffer' or `pop-to-buffer' switches to it
7178 in the selected window, rather than making it appear in some other window.
7180 An element of the list can be a cons cell instead of just a string.
7181 Then the car must be a string, which specifies the buffer name.
7182 This is for compatibility with `special-display-buffer-names';
7183 the cdr of the cons cell is ignored.
7185 See also `same-window-buffer-names'. */);
7186 Vsame_window_regexps
= Qnil
;
7188 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7189 doc
: /* *Non-nil means display-buffer should make new windows. */);
7192 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7193 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7194 next_screen_context_lines
= 2;
7196 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7197 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
7198 If there is only one window, it is split regardless of this value. */);
7199 split_height_threshold
= 500;
7201 DEFVAR_INT ("window-min-height", &window_min_height
,
7202 doc
: /* *Delete any window less than this tall (including its mode line). */);
7203 window_min_height
= 4;
7205 DEFVAR_INT ("window-min-width", &window_min_width
,
7206 doc
: /* *Delete any window less than this wide. */);
7207 window_min_width
= 10;
7209 DEFVAR_LISP ("scroll-preserve-screen-position",
7210 &Vscroll_preserve_screen_position
,
7211 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7212 A value of nil means point does not keep its screen position except
7213 at the scroll margin or window boundary respectively.
7214 A value of t means point keeps its screen position if the scroll
7215 command moved it vertically out of the window, e.g. when scrolling
7217 Any other value means point always keeps its screen position. */);
7218 Vscroll_preserve_screen_position
= Qnil
;
7220 DEFVAR_LISP ("window-configuration-change-hook",
7221 &Vwindow_configuration_change_hook
,
7222 doc
: /* Functions to call when window configuration changes.
7223 The selected frame is the one whose configuration has changed. */);
7224 Vwindow_configuration_change_hook
= Qnil
;
7226 defsubr (&Sselected_window
);
7227 defsubr (&Sminibuffer_window
);
7228 defsubr (&Swindow_minibuffer_p
);
7229 defsubr (&Swindowp
);
7230 defsubr (&Swindow_live_p
);
7231 defsubr (&Spos_visible_in_window_p
);
7232 defsubr (&Swindow_buffer
);
7233 defsubr (&Swindow_height
);
7234 defsubr (&Swindow_width
);
7235 defsubr (&Swindow_hscroll
);
7236 defsubr (&Sset_window_hscroll
);
7237 defsubr (&Swindow_redisplay_end_trigger
);
7238 defsubr (&Sset_window_redisplay_end_trigger
);
7239 defsubr (&Swindow_edges
);
7240 defsubr (&Swindow_pixel_edges
);
7241 defsubr (&Swindow_inside_edges
);
7242 defsubr (&Swindow_inside_pixel_edges
);
7243 defsubr (&Scoordinates_in_window_p
);
7244 defsubr (&Swindow_at
);
7245 defsubr (&Swindow_point
);
7246 defsubr (&Swindow_start
);
7247 defsubr (&Swindow_end
);
7248 defsubr (&Sset_window_point
);
7249 defsubr (&Sset_window_start
);
7250 defsubr (&Swindow_dedicated_p
);
7251 defsubr (&Sset_window_dedicated_p
);
7252 defsubr (&Swindow_display_table
);
7253 defsubr (&Sset_window_display_table
);
7254 defsubr (&Snext_window
);
7255 defsubr (&Sprevious_window
);
7256 defsubr (&Sother_window
);
7257 defsubr (&Sget_lru_window
);
7258 defsubr (&Sget_largest_window
);
7259 defsubr (&Sget_buffer_window
);
7260 defsubr (&Sdelete_other_windows
);
7261 defsubr (&Sdelete_windows_on
);
7262 defsubr (&Sreplace_buffer_in_windows
);
7263 defsubr (&Sdelete_window
);
7264 defsubr (&Sset_window_buffer
);
7265 defsubr (&Sselect_window
);
7266 defsubr (&Sspecial_display_p
);
7267 defsubr (&Ssame_window_p
);
7268 defsubr (&Sdisplay_buffer
);
7269 defsubr (&Sforce_window_update
);
7270 defsubr (&Ssplit_window
);
7271 defsubr (&Senlarge_window
);
7272 defsubr (&Sshrink_window
);
7273 defsubr (&Sadjust_window_trailing_edge
);
7274 defsubr (&Sscroll_up
);
7275 defsubr (&Sscroll_down
);
7276 defsubr (&Sscroll_left
);
7277 defsubr (&Sscroll_right
);
7278 defsubr (&Sother_window_for_scrolling
);
7279 defsubr (&Sscroll_other_window
);
7280 defsubr (&Sminibuffer_selected_window
);
7281 defsubr (&Srecenter
);
7282 defsubr (&Swindow_text_height
);
7283 defsubr (&Smove_to_window_line
);
7284 defsubr (&Swindow_configuration_p
);
7285 defsubr (&Swindow_configuration_frame
);
7286 defsubr (&Sset_window_configuration
);
7287 defsubr (&Scurrent_window_configuration
);
7288 defsubr (&Ssave_window_excursion
);
7289 defsubr (&Swindow_tree
);
7290 defsubr (&Sset_window_margins
);
7291 defsubr (&Swindow_margins
);
7292 defsubr (&Sset_window_fringes
);
7293 defsubr (&Swindow_fringes
);
7294 defsubr (&Sset_window_scroll_bars
);
7295 defsubr (&Swindow_scroll_bars
);
7296 defsubr (&Swindow_vscroll
);
7297 defsubr (&Sset_window_vscroll
);
7298 defsubr (&Scompare_window_configurations
);
7299 defsubr (&Swindow_list
);
7305 initial_define_key (control_x_map
, '1', "delete-other-windows");
7306 initial_define_key (control_x_map
, '2', "split-window");
7307 initial_define_key (control_x_map
, '0', "delete-window");
7308 initial_define_key (control_x_map
, 'o', "other-window");
7309 initial_define_key (control_x_map
, '^', "enlarge-window");
7310 initial_define_key (control_x_map
, '<', "scroll-left");
7311 initial_define_key (control_x_map
, '>', "scroll-right");
7313 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7314 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7315 initial_define_key (meta_map
, 'v', "scroll-down");
7317 initial_define_key (global_map
, Ctl('L'), "recenter");
7318 initial_define_key (meta_map
, 'r', "move-to-window-line");
7321 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7322 (do not change this comment) */