1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
52 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
53 Lisp_Object Qwindow_size_fixed
;
54 extern Lisp_Object Qleft_margin
, Qright_margin
;
56 static int displayed_window_lines
P_ ((struct window
*));
57 static struct window
*decode_window
P_ ((Lisp_Object
));
58 static int count_windows
P_ ((struct window
*));
59 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
60 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
61 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
62 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
63 static int window_min_size_1
P_ ((struct window
*, int));
64 static int window_min_size
P_ ((struct window
*, int, int, int *));
65 static void size_window
P_ ((Lisp_Object
, int, int, int));
66 static int freeze_window_start
P_ ((struct window
*, void *));
67 static int window_fixed_size_p
P_ ((struct window
*, int, int));
68 static void enlarge_window
P_ ((Lisp_Object
, int, int));
69 static Lisp_Object window_list
P_ ((void));
70 static int add_window_to_list
P_ ((struct window
*, void *));
71 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
73 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
75 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
77 static int foreach_window_1
P_ ((struct window
*,
78 int (* fn
) (struct window
*, void *),
80 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
82 /* This is the window in which the terminal's cursor should
83 be left when nothing is being done with it. This must
84 always be a leaf window, and its buffer is selected by
85 the top level editing loop at the end of each command.
87 This value is always the same as
88 FRAME_SELECTED_WINDOW (selected_frame). */
90 Lisp_Object selected_window
;
92 /* A list of all windows for use by next_window and Fwindow_list.
93 Functions creating or deleting windows should invalidate this cache
94 by setting it to nil. */
96 Lisp_Object Vwindow_list
;
98 /* The mini-buffer window of the selected frame.
99 Note that you cannot test for mini-bufferness of an arbitrary window
100 by comparing against this; but you can test for mini-bufferness of
101 the selected window. */
103 Lisp_Object minibuf_window
;
105 /* Non-nil means it is the window whose mode line should be
106 shown as the selected window when the minibuffer is selected. */
108 Lisp_Object minibuf_selected_window
;
110 /* Non-nil means it is the window for C-M-v to scroll
111 when the mini-buffer is selected. */
113 Lisp_Object Vminibuf_scroll_window
;
115 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
117 Lisp_Object Vother_window_scroll_buffer
;
119 /* Non-nil means it's function to call to display temp buffers. */
121 Lisp_Object Vtemp_buffer_show_function
;
123 /* Non-zero means line and page scrolling on tall lines (with images)
124 does partial scrolling by modifying window-vscroll. */
126 int auto_window_vscroll_p
;
128 /* Non-zero means to use mode-line-inactive face in all windows but the
129 selected-window and the minibuffer-scroll-window when the
130 minibuffer is active. */
131 int mode_line_in_non_selected_windows
;
133 /* If a window gets smaller than either of these, it is removed. */
135 EMACS_INT window_min_height
;
136 EMACS_INT window_min_width
;
138 /* Nonzero implies Fdisplay_buffer should create windows. */
142 /* Nonzero implies make new frames for Fdisplay_buffer. */
146 /* Nonzero means reuse existing frames for displaying buffers. */
148 int display_buffer_reuse_frames
;
150 /* Non-nil means use this function instead of default */
152 Lisp_Object Vpop_up_frame_function
;
154 /* Function to call to handle Fdisplay_buffer. */
156 Lisp_Object Vdisplay_buffer_function
;
158 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
160 Lisp_Object Veven_window_heights
;
162 /* List of buffer *names* for buffers that should have their own frames. */
164 Lisp_Object Vspecial_display_buffer_names
;
166 /* List of regexps for buffer names that should have their own frames. */
168 Lisp_Object Vspecial_display_regexps
;
170 /* Function to pop up a special frame. */
172 Lisp_Object Vspecial_display_function
;
174 /* List of buffer *names* for buffers to appear in selected window. */
176 Lisp_Object Vsame_window_buffer_names
;
178 /* List of regexps for buffer names to appear in selected window. */
180 Lisp_Object Vsame_window_regexps
;
182 /* Hook run at end of temp_output_buffer_show. */
184 Lisp_Object Qtemp_buffer_show_hook
;
186 /* Fdisplay_buffer always splits the largest window
187 if that window is more than this high. */
189 EMACS_INT split_height_threshold
;
191 /* Number of lines of continuity in scrolling by screenfuls. */
193 EMACS_INT next_screen_context_lines
;
195 /* Incremented for each window created. */
197 static int sequence_number
;
199 /* Nonzero after init_window_once has finished. */
201 static int window_initialized
;
203 /* Hook to run when window config changes. */
205 Lisp_Object Qwindow_configuration_change_hook
;
206 Lisp_Object Vwindow_configuration_change_hook
;
208 /* Non-nil means scroll commands try to put point
209 at the same screen height as previously. */
211 Lisp_Object Vscroll_preserve_screen_position
;
213 /* Incremented by 1 whenever a window is deleted. */
215 int window_deletion_count
;
217 #if 0 /* This isn't used anywhere. */
218 /* Nonzero means we can split a frame even if it is "unsplittable". */
219 static int inhibit_frame_unsplittable
;
222 extern EMACS_INT scroll_margin
;
224 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
226 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
227 doc
: /* Returns t if OBJECT is a window. */)
231 return WINDOWP (object
) ? Qt
: Qnil
;
234 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
235 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
239 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
246 register struct window
*p
;
248 p
= allocate_window ();
250 XSETFASTINT (p
->sequence_number
, sequence_number
);
251 XSETFASTINT (p
->left_col
, 0);
252 XSETFASTINT (p
->top_line
, 0);
253 XSETFASTINT (p
->total_lines
, 0);
254 XSETFASTINT (p
->total_cols
, 0);
255 XSETFASTINT (p
->hscroll
, 0);
256 XSETFASTINT (p
->min_hscroll
, 0);
257 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
258 p
->start
= Fmake_marker ();
259 p
->pointm
= Fmake_marker ();
260 XSETFASTINT (p
->use_time
, 0);
262 p
->display_table
= Qnil
;
264 p
->pseudo_window_p
= 0;
265 bzero (&p
->cursor
, sizeof (p
->cursor
));
266 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
267 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
268 p
->desired_matrix
= p
->current_matrix
= 0;
269 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
270 p
->phys_cursor_type
= -1;
271 p
->phys_cursor_width
= -1;
272 p
->must_be_updated_p
= 0;
273 XSETFASTINT (p
->window_end_vpos
, 0);
274 XSETFASTINT (p
->window_end_pos
, 0);
275 p
->window_end_valid
= Qnil
;
278 XSETFASTINT (p
->last_point
, 0);
279 p
->frozen_window_start_p
= 0;
280 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
281 p
->left_margin_cols
= Qnil
;
282 p
->right_margin_cols
= Qnil
;
283 p
->left_fringe_width
= Qnil
;
284 p
->right_fringe_width
= Qnil
;
285 p
->fringes_outside_margins
= Qnil
;
286 p
->scroll_bar_width
= Qnil
;
287 p
->vertical_scroll_bar_type
= Qt
;
293 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
294 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
297 return selected_window
;
300 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
301 doc
: /* Return the window used now for minibuffers.
302 If the optional argument FRAME is specified, return the minibuffer window
303 used by that frame. */)
308 frame
= selected_frame
;
309 CHECK_LIVE_FRAME (frame
);
310 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
313 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
314 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
315 WINDOW defaults to the selected window. */)
319 struct window
*w
= decode_window (window
);
320 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
324 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
325 Spos_visible_in_window_p
, 0, 3, 0,
326 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
327 Return nil if that position is scrolled vertically out of view.
328 If a character is only partially visible, nil is returned, unless the
329 optional argument PARTIALLY is non-nil.
330 If POS is only out of view because of horizontal scrolling, return non-nil.
331 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
333 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
334 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
335 relative to the top left corner of the window. PARTIAL is nil if the character
336 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
337 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
338 (pos
, window
, partially
)
339 Lisp_Object pos
, window
, partially
;
341 register struct window
*w
;
343 register struct buffer
*buf
;
345 Lisp_Object in_window
= Qnil
;
346 int rtop
, rbot
, fully_p
= 1;
349 w
= decode_window (window
);
350 buf
= XBUFFER (w
->buffer
);
351 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
355 CHECK_NUMBER_COERCE_MARKER (pos
);
358 else if (w
== XWINDOW (selected_window
))
361 posint
= XMARKER (w
->pointm
)->charpos
;
363 /* If position is above window start or outside buffer boundaries,
364 or if window start is out of range, position is not visible. */
365 if (posint
>= CHARPOS (top
)
366 && posint
<= BUF_ZV (buf
)
367 && CHARPOS (top
) >= BUF_BEGV (buf
)
368 && CHARPOS (top
) <= BUF_ZV (buf
)
369 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
370 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
373 if (!NILP (in_window
) && !NILP (partially
))
374 in_window
= Fcons (make_number (x
),
375 Fcons (make_number (y
),
376 Fcons ((fully_p
? Qnil
377 : Fcons (make_number (rtop
),
378 make_number (rbot
))),
384 static struct window
*
385 decode_window (window
)
386 register Lisp_Object window
;
389 return XWINDOW (selected_window
);
391 CHECK_LIVE_WINDOW (window
);
392 return XWINDOW (window
);
395 static struct window
*
396 decode_any_window (window
)
397 register Lisp_Object window
;
400 return XWINDOW (selected_window
);
402 CHECK_WINDOW (window
);
403 return XWINDOW (window
);
406 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
407 doc
: /* Return the buffer that WINDOW is displaying.
408 WINDOW defaults to the selected window. */)
412 return decode_window (window
)->buffer
;
415 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
416 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
420 return decode_any_window (window
)->total_lines
;
423 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
424 doc
: /* Return the number of display columns in WINDOW.
425 This is the width that is usable columns available for text in WINDOW.
426 If you want to find out how many columns WINDOW takes up,
427 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
431 return make_number (window_box_text_cols (decode_any_window (window
)));
434 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
435 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
439 return decode_window (window
)->hscroll
;
442 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
443 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
444 Return NCOL. NCOL should be zero or positive.
446 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
447 window so that the location of point becomes invisible. */)
449 Lisp_Object window
, ncol
;
451 struct window
*w
= decode_window (window
);
455 hscroll
= max (0, XINT (ncol
));
457 /* Prevent redisplay shortcuts when changing the hscroll. */
458 if (XINT (w
->hscroll
) != hscroll
)
459 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
461 w
->hscroll
= make_number (hscroll
);
465 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
466 Swindow_redisplay_end_trigger
, 0, 1, 0,
467 doc
: /* Return WINDOW's redisplay end trigger value.
468 See `set-window-redisplay-end-trigger' for more information. */)
472 return decode_window (window
)->redisplay_end_trigger
;
475 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
476 Sset_window_redisplay_end_trigger
, 2, 2, 0,
477 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
478 VALUE should be a buffer position (typically a marker) or nil.
479 If it is a buffer position, then if redisplay in WINDOW reaches a position
480 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
481 with two arguments: WINDOW, and the end trigger value.
482 Afterwards the end-trigger value is reset to nil. */)
484 register Lisp_Object window
, value
;
486 register struct window
*w
;
488 w
= decode_window (window
);
489 w
->redisplay_end_trigger
= value
;
493 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
494 doc
: /* Return a list of the edge coordinates of WINDOW.
495 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
496 RIGHT is one more than the rightmost column occupied by WINDOW,
497 and BOTTOM is one more than the bottommost row occupied by WINDOW.
498 The edges include the space used by the window's scroll bar,
499 display margins, fringes, header line, and mode line, if it has them.
500 To get the edges of the actual text area, use `window-inside-edges'. */)
504 register struct window
*w
= decode_any_window (window
);
506 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
507 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
508 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
509 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
513 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
514 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
515 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
516 RIGHT is one more than the rightmost x position occupied by WINDOW,
517 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
518 The pixel edges include the space used by the window's scroll bar,
519 display margins, fringes, header line, and mode line, if it has them.
520 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
524 register struct window
*w
= decode_any_window (window
);
526 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
527 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
528 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
529 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
533 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
534 doc
: /* Return a list of the edge coordinates of WINDOW.
535 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
536 RIGHT is one more than the rightmost column used by text in WINDOW,
537 and BOTTOM is one more than the bottommost row used by text in WINDOW.
538 The inside edges do not include the space used by the window's scroll bar,
539 display margins, fringes, header line, and/or mode line. */)
543 register struct window
*w
= decode_any_window (window
);
545 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
546 + WINDOW_LEFT_MARGIN_COLS (w
)
547 + WINDOW_LEFT_FRINGE_COLS (w
)),
548 make_number (WINDOW_TOP_EDGE_LINE (w
)
549 + WINDOW_HEADER_LINE_LINES (w
)),
550 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
551 - WINDOW_RIGHT_MARGIN_COLS (w
)
552 - WINDOW_RIGHT_FRINGE_COLS (w
)),
553 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
554 - WINDOW_MODE_LINE_LINES (w
)));
557 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
558 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
559 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
560 RIGHT is one more than the rightmost x position used by text in WINDOW,
561 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
562 The inside edges do not include the space used by the window's scroll bar,
563 display margins, fringes, header line, and/or mode line. */)
567 register struct window
*w
= decode_any_window (window
);
569 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
570 + WINDOW_LEFT_MARGIN_WIDTH (w
)
571 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
572 make_number (WINDOW_TOP_EDGE_Y (w
)
573 + WINDOW_HEADER_LINE_HEIGHT (w
)),
574 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
575 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
576 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
577 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
578 - WINDOW_MODE_LINE_HEIGHT (w
)));
581 /* Test if the character at column *X, row *Y is within window W.
582 If it is not, return ON_NOTHING;
583 if it is in the window's text area,
584 set *x and *y to its location relative to the upper left corner
587 if it is on the window's modeline, return ON_MODE_LINE;
588 if it is on the border between the window and its right sibling,
589 return ON_VERTICAL_BORDER.
590 if it is on a scroll bar,
591 return ON_SCROLL_BAR.
592 if it is on the window's top line, return ON_HEADER_LINE;
593 if it is in left or right fringe of the window,
594 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
595 to window-relative coordinates;
596 if it is in the marginal area to the left/right of the window,
597 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
598 to window-relative coordinates.
600 X and Y are frame relative pixel coordinates. */
602 static enum window_part
603 coordinates_in_window (w
, x
, y
)
604 register struct window
*w
;
607 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
608 int left_x
, right_x
, top_y
, bottom_y
;
609 enum window_part part
;
610 int ux
= FRAME_COLUMN_WIDTH (f
);
611 int x0
= WINDOW_LEFT_EDGE_X (w
);
612 int x1
= WINDOW_RIGHT_EDGE_X (w
);
613 /* The width of the area where the vertical line can be dragged.
614 (Between mode lines for instance. */
615 int grabbable_width
= ux
;
616 int lmargin_width
, rmargin_width
, text_left
, text_right
;
618 /* In what's below, we subtract 1 when computing right_x because we
619 want the rightmost pixel, which is given by left_pixel+width-1. */
620 if (w
->pseudo_window_p
)
623 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
624 top_y
= WINDOW_TOP_EDGE_Y (w
);
625 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
629 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
630 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
631 top_y
= WINDOW_TOP_EDGE_Y (w
);
632 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
635 /* Outside any interesting row? */
636 if (*y
< top_y
|| *y
>= bottom_y
)
639 /* On the mode line or header line? If it's near the start of
640 the mode or header line of window that's has a horizontal
641 sibling, say it's on the vertical line. That's to be able
642 to resize windows horizontally in case we're using toolkit
645 if (WINDOW_WANTS_MODELINE_P (w
)
646 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
650 header_vertical_border_check
:
651 /* We're somewhere on the mode line. We consider the place
652 between mode lines of horizontally adjacent mode lines
653 as the vertical border. If scroll bars on the left,
654 return the right window. */
655 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
656 || WINDOW_RIGHTMOST_P (w
))
658 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
659 return ON_VERTICAL_BORDER
;
663 if (abs (*x
- x1
) < grabbable_width
)
664 return ON_VERTICAL_BORDER
;
667 if (*x
< x0
|| *x
>= x1
)
670 /* Convert X and Y to window relative coordinates.
671 Mode line starts at left edge of window. */
677 if (WINDOW_WANTS_HEADER_LINE_P (w
)
678 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
680 part
= ON_HEADER_LINE
;
681 goto header_vertical_border_check
;
684 if (*x
< x0
|| *x
>= x1
)
687 /* Outside any interesting column? */
688 if (*x
< left_x
|| *x
> right_x
)
691 return ON_SCROLL_BAR
;
694 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
695 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
697 text_left
= window_box_left (w
, TEXT_AREA
);
698 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
700 if (FRAME_WINDOW_P (f
))
702 if (!w
->pseudo_window_p
703 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
704 && !WINDOW_RIGHTMOST_P (w
)
705 && (abs (*x
- right_x
) < grabbable_width
))
706 return ON_VERTICAL_BORDER
;
710 /* Need to say "*x > right_x" rather than >=, since on character
711 terminals, the vertical line's x coordinate is right_x. */
712 if (!w
->pseudo_window_p
713 && !WINDOW_RIGHTMOST_P (w
)
714 && *x
> right_x
- ux
)
716 /* On the border on the right side of the window? Assume that
717 this area begins at RIGHT_X minus a canonical char width. */
718 return ON_VERTICAL_BORDER
;
724 if (lmargin_width
> 0
725 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
726 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
727 : (*x
< left_x
+ lmargin_width
)))
730 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
731 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
733 return ON_LEFT_MARGIN
;
736 /* Convert X and Y to window-relative pixel coordinates. */
739 return ON_LEFT_FRINGE
;
742 if (*x
>= text_right
)
744 if (rmargin_width
> 0
745 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
746 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
747 : (*x
>= right_x
- rmargin_width
)))
749 *x
-= right_x
- rmargin_width
;
750 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
751 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
753 return ON_RIGHT_MARGIN
;
756 /* Convert X and Y to window-relative pixel coordinates. */
757 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
759 return ON_RIGHT_FRINGE
;
762 /* Everything special ruled out - must be on text area */
769 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
770 Scoordinates_in_window_p
, 2, 2, 0,
771 doc
: /* Return non-nil if COORDINATES are in WINDOW.
772 COORDINATES is a cons of the form (X . Y), X and Y being distances
773 measured in characters from the upper-left corner of the frame.
774 \(0 . 0) denotes the character in the upper left corner of the
776 If COORDINATES are in the text portion of WINDOW,
777 the coordinates relative to the window are returned.
778 If they are in the mode line of WINDOW, `mode-line' is returned.
779 If they are in the top mode line of WINDOW, `header-line' is returned.
780 If they are in the left fringe of WINDOW, `left-fringe' is returned.
781 If they are in the right fringe of WINDOW, `right-fringe' is returned.
782 If they are on the border between WINDOW and its right sibling,
783 `vertical-line' is returned.
784 If they are in the windows's left or right marginal areas, `left-margin'\n\
785 or `right-margin' is returned. */)
786 (coordinates
, window
)
787 register Lisp_Object coordinates
, window
;
794 CHECK_WINDOW (window
);
795 w
= XWINDOW (window
);
796 f
= XFRAME (w
->frame
);
797 CHECK_CONS (coordinates
);
798 lx
= Fcar (coordinates
);
799 ly
= Fcdr (coordinates
);
800 CHECK_NUMBER_OR_FLOAT (lx
);
801 CHECK_NUMBER_OR_FLOAT (ly
);
802 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
803 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
805 switch (coordinates_in_window (w
, &x
, &y
))
811 /* X and Y are now window relative pixel coordinates. Convert
812 them to canonical char units before returning them. */
813 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
814 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
819 case ON_VERTICAL_BORDER
:
820 return Qvertical_line
;
828 case ON_RIGHT_FRINGE
:
829 return Qright_fringe
;
834 case ON_RIGHT_MARGIN
:
835 return Qright_margin
;
838 /* Historically we are supposed to return nil in this case. */
847 /* Callback for foreach_window, used in window_from_coordinates.
848 Check if window W contains coordinates specified by USER_DATA which
849 is actually a pointer to a struct check_window_data CW.
851 Check if window W contains coordinates *CW->x and *CW->y. If it
852 does, return W in *CW->window, as Lisp_Object, and return in
853 *CW->part the part of the window under coordinates *X,*Y. Return
854 zero from this function to stop iterating over windows. */
856 struct check_window_data
860 enum window_part
*part
;
864 check_window_containing (w
, user_data
)
868 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
869 enum window_part found
;
872 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
873 if (found
!= ON_NOTHING
)
876 XSETWINDOW (*cw
->window
, w
);
884 /* Find the window containing frame-relative pixel position X/Y and
885 return it as a Lisp_Object.
887 If X, Y is on one of the window's special `window_part' elements,
888 set *PART to the id of that element, and return X and Y converted
889 to window relative coordinates in WX and WY.
891 If there is no window under X, Y return nil and leave *PART
892 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
894 This function was previously implemented with a loop cycling over
895 windows with Fnext_window, and starting with the frame's selected
896 window. It turned out that this doesn't work with an
897 implementation of next_window using Vwindow_list, because
898 FRAME_SELECTED_WINDOW (F) is not always contained in the window
899 tree of F when this function is called asynchronously from
900 note_mouse_highlight. The original loop didn't terminate in this
904 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
907 enum window_part
*part
;
912 struct check_window_data cw
;
913 enum window_part dummy
;
919 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
920 foreach_window (f
, check_window_containing
, &cw
);
922 /* If not found above, see if it's in the tool bar window, if a tool
926 && WINDOWP (f
->tool_bar_window
)
927 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
928 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
932 window
= f
->tool_bar_window
;
941 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
942 doc
: /* Return window containing coordinates X and Y on FRAME.
943 If omitted, FRAME defaults to the currently selected frame.
944 The top left corner of the frame is considered to be row 0,
947 Lisp_Object x
, y
, frame
;
952 frame
= selected_frame
;
953 CHECK_LIVE_FRAME (frame
);
956 /* Check that arguments are integers or floats. */
957 CHECK_NUMBER_OR_FLOAT (x
);
958 CHECK_NUMBER_OR_FLOAT (y
);
960 return window_from_coordinates (f
,
961 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
962 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
963 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
964 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
968 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
969 doc
: /* Return current value of point in WINDOW.
970 For a nonselected window, this is the value point would have
971 if that window were selected.
973 Note that, when WINDOW is the selected window and its buffer
974 is also currently selected, the value returned is the same as (point).
975 It would be more strictly correct to return the `top-level' value
976 of point, outside of any save-excursion forms.
977 But that is hard to define. */)
981 register struct window
*w
= decode_window (window
);
983 if (w
== XWINDOW (selected_window
)
984 && current_buffer
== XBUFFER (w
->buffer
))
986 return Fmarker_position (w
->pointm
);
989 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
990 doc
: /* Return position at which display currently starts in WINDOW.
991 This is updated by redisplay or by calling `set-window-start'. */)
995 return Fmarker_position (decode_window (window
)->start
);
998 /* This is text temporarily removed from the doc string below.
1000 This function returns nil if the position is not currently known.
1001 That happens when redisplay is preempted and doesn't finish.
1002 If in that case you want to compute where the end of the window would
1003 have been if redisplay had finished, do this:
1005 (goto-char (window-start window))
1006 (vertical-motion (1- (window-height window)) window)
1009 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1010 doc
: /* Return position at which display currently ends in WINDOW.
1011 This is updated by redisplay, when it runs to completion.
1012 Simply changing the buffer text or setting `window-start'
1013 does not update this value.
1014 Return nil if there is no recorded value. \(This can happen if the
1015 last redisplay of WINDOW was preempted, and did not finish.)
1016 If UPDATE is non-nil, compute the up-to-date position
1017 if it isn't already recorded. */)
1019 Lisp_Object window
, update
;
1022 struct window
*w
= decode_window (window
);
1028 #if 0 /* This change broke some things. We should make it later. */
1029 /* If we don't know the end position, return nil.
1030 The user can compute it with vertical-motion if he wants to.
1031 It would be nicer to do it automatically,
1032 but that's so slow that it would probably bother people. */
1033 if (NILP (w
->window_end_valid
))
1038 && ! (! NILP (w
->window_end_valid
)
1039 && XFASTINT (w
->last_modified
) >= MODIFF
)
1042 struct text_pos startp
;
1044 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1046 /* In case W->start is out of the range, use something
1047 reasonable. This situation occurred when loading a file with
1048 `-l' containing a call to `rmail' with subsequent other
1049 commands. At the end, W->start happened to be BEG, while
1050 rmail had already narrowed the buffer. */
1051 if (XMARKER (w
->start
)->charpos
< BEGV
)
1052 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1053 else if (XMARKER (w
->start
)->charpos
> ZV
)
1054 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1056 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1058 /* Cannot use Fvertical_motion because that function doesn't
1059 cope with variable-height lines. */
1060 if (b
!= current_buffer
)
1062 old_buffer
= current_buffer
;
1063 set_buffer_internal (b
);
1066 start_display (&it
, w
, startp
);
1067 move_it_vertically (&it
, window_box_height (w
));
1068 if (it
.current_y
< it
.last_visible_y
)
1069 move_it_past_eol (&it
);
1070 value
= make_number (IT_CHARPOS (it
));
1073 set_buffer_internal (old_buffer
);
1076 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1081 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1082 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1085 Lisp_Object window
, pos
;
1087 register struct window
*w
= decode_window (window
);
1089 CHECK_NUMBER_COERCE_MARKER (pos
);
1090 if (w
== XWINDOW (selected_window
)
1091 && XBUFFER (w
->buffer
) == current_buffer
)
1094 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1096 /* We have to make sure that redisplay updates the window to show
1097 the new value of point. */
1098 if (!EQ (window
, selected_window
))
1099 ++windows_or_buffers_changed
;
1104 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1105 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1107 Optional third arg NOFORCE non-nil inhibits next redisplay
1108 from overriding motion of point in order to display at this exact start. */)
1109 (window
, pos
, noforce
)
1110 Lisp_Object window
, pos
, noforce
;
1112 register struct window
*w
= decode_window (window
);
1114 CHECK_NUMBER_COERCE_MARKER (pos
);
1115 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1116 /* this is not right, but much easier than doing what is right. */
1117 w
->start_at_line_beg
= Qnil
;
1119 w
->force_start
= Qt
;
1120 w
->update_mode_line
= Qt
;
1121 XSETFASTINT (w
->last_modified
, 0);
1122 XSETFASTINT (w
->last_overlay_modified
, 0);
1123 if (!EQ (window
, selected_window
))
1124 windows_or_buffers_changed
++;
1129 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1131 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1132 See also `set-window-dedicated-p'. */)
1136 return decode_window (window
)->dedicated
;
1139 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1140 Sset_window_dedicated_p
, 2, 2, 0,
1141 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1142 If it is dedicated, Emacs will not automatically change
1143 which buffer appears in it.
1144 The second argument is the new value for the dedication flag;
1145 non-nil means yes. */)
1147 Lisp_Object window
, arg
;
1149 register struct window
*w
= decode_window (window
);
1153 return w
->dedicated
;
1156 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1158 doc
: /* Return the display-table that WINDOW is using. */)
1162 return decode_window (window
)->display_table
;
1165 /* Get the display table for use on window W. This is either W's
1166 display table or W's buffer's display table. Ignore the specified
1167 tables if they are not valid; if no valid table is specified,
1170 struct Lisp_Char_Table
*
1171 window_display_table (w
)
1174 struct Lisp_Char_Table
*dp
= NULL
;
1176 if (DISP_TABLE_P (w
->display_table
))
1177 dp
= XCHAR_TABLE (w
->display_table
);
1178 else if (BUFFERP (w
->buffer
))
1180 struct buffer
*b
= XBUFFER (w
->buffer
);
1182 if (DISP_TABLE_P (b
->display_table
))
1183 dp
= XCHAR_TABLE (b
->display_table
);
1184 else if (DISP_TABLE_P (Vstandard_display_table
))
1185 dp
= XCHAR_TABLE (Vstandard_display_table
);
1191 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1192 doc
: /* Set WINDOW's display-table to TABLE. */)
1194 register Lisp_Object window
, table
;
1196 register struct window
*w
;
1198 w
= decode_window (window
);
1199 w
->display_table
= table
;
1203 /* Record info on buffer window w is displaying
1204 when it is about to cease to display that buffer. */
1207 register struct window
*w
;
1214 if (b
!= XMARKER (w
->pointm
)->buffer
)
1218 if (w
== XWINDOW (selected_window
)
1219 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1220 /* Do this except when the selected window's buffer
1221 is being removed from some other window. */
1223 /* last_window_start records the start position that this buffer
1224 had in the last window to be disconnected from it.
1225 Now that this statement is unconditional,
1226 it is possible for the buffer to be displayed in the
1227 selected window, while last_window_start reflects another
1228 window which was recently showing the same buffer.
1229 Some people might say that might be a good thing. Let's see. */
1230 b
->last_window_start
= marker_position (w
->start
);
1232 /* Point in the selected window's buffer
1233 is actually stored in that buffer, and the window's pointm isn't used.
1234 So don't clobber point in that buffer. */
1235 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1236 /* This line helps to fix Horsley's testbug.el bug. */
1237 && !(WINDOWP (b
->last_selected_window
)
1238 && w
!= XWINDOW (b
->last_selected_window
)
1239 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1240 temp_set_point_both (b
,
1241 clip_to_bounds (BUF_BEGV (b
),
1242 XMARKER (w
->pointm
)->charpos
,
1244 clip_to_bounds (BUF_BEGV_BYTE (b
),
1245 marker_byte_position (w
->pointm
),
1248 if (WINDOWP (b
->last_selected_window
)
1249 && w
== XWINDOW (b
->last_selected_window
))
1250 b
->last_selected_window
= Qnil
;
1253 /* Put replacement into the window structure in place of old. */
1255 replace_window (old
, replacement
)
1256 Lisp_Object old
, replacement
;
1258 register Lisp_Object tem
;
1259 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1261 /* If OLD is its frame's root_window, then replacement is the new
1262 root_window for that frame. */
1264 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1265 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1267 p
->left_col
= o
->left_col
;
1268 p
->top_line
= o
->top_line
;
1269 p
->total_cols
= o
->total_cols
;
1270 p
->total_lines
= o
->total_lines
;
1271 p
->desired_matrix
= p
->current_matrix
= 0;
1273 bzero (&p
->cursor
, sizeof (p
->cursor
));
1274 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1275 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1276 p
->phys_cursor_type
= -1;
1277 p
->phys_cursor_width
= -1;
1278 p
->must_be_updated_p
= 0;
1279 p
->pseudo_window_p
= 0;
1280 XSETFASTINT (p
->window_end_vpos
, 0);
1281 XSETFASTINT (p
->window_end_pos
, 0);
1282 p
->window_end_valid
= Qnil
;
1283 p
->frozen_window_start_p
= 0;
1284 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1286 p
->next
= tem
= o
->next
;
1288 XWINDOW (tem
)->prev
= replacement
;
1290 p
->prev
= tem
= o
->prev
;
1292 XWINDOW (tem
)->next
= replacement
;
1294 p
->parent
= tem
= o
->parent
;
1297 if (EQ (XWINDOW (tem
)->vchild
, old
))
1298 XWINDOW (tem
)->vchild
= replacement
;
1299 if (EQ (XWINDOW (tem
)->hchild
, old
))
1300 XWINDOW (tem
)->hchild
= replacement
;
1303 /*** Here, if replacement is a vertical combination
1304 and so is its new parent, we should make replacement's
1305 children be children of that parent instead. ***/
1308 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1309 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1311 register Lisp_Object window
;
1313 delete_window (window
);
1315 if (! NILP (Vwindow_configuration_change_hook
)
1316 && ! NILP (Vrun_hooks
))
1317 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1323 delete_window (window
)
1324 register Lisp_Object window
;
1326 register Lisp_Object tem
, parent
, sib
;
1327 register struct window
*p
;
1328 register struct window
*par
;
1331 /* Because this function is called by other C code on non-leaf
1332 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1333 so we can't decode_window here. */
1335 window
= selected_window
;
1337 CHECK_WINDOW (window
);
1338 p
= XWINDOW (window
);
1340 /* It's a no-op to delete an already-deleted window. */
1341 if (NILP (p
->buffer
)
1343 && NILP (p
->vchild
))
1348 error ("Attempt to delete minibuffer or sole ordinary window");
1349 par
= XWINDOW (parent
);
1351 windows_or_buffers_changed
++;
1352 Vwindow_list
= Qnil
;
1353 f
= XFRAME (WINDOW_FRAME (p
));
1354 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1356 /* Are we trying to delete any frame's selected window? */
1358 Lisp_Object swindow
, pwindow
;
1360 /* See if the frame's selected window is either WINDOW
1361 or any subwindow of it, by finding all that window's parents
1362 and comparing each one with WINDOW. */
1363 swindow
= FRAME_SELECTED_WINDOW (f
);
1368 while (!NILP (pwindow
))
1370 if (EQ (window
, pwindow
))
1372 pwindow
= XWINDOW (pwindow
)->parent
;
1375 /* If the window being deleted is not a parent of SWINDOW,
1376 then SWINDOW is ok as the new selected window. */
1377 if (!EQ (window
, pwindow
))
1379 /* Otherwise, try another window for SWINDOW. */
1380 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1382 /* If we get back to the frame's selected window,
1383 it means there was no acceptable alternative,
1384 so we cannot delete. */
1385 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1386 error ("Cannot delete window");
1389 /* If we need to change SWINDOW, do it. */
1390 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1392 /* If we're about to delete the selected window on the
1393 selected frame, then we should use Fselect_window to select
1394 the new window. On the other hand, if we're about to
1395 delete the selected window on any other frame, we shouldn't do
1396 anything but set the frame's selected_window slot. */
1397 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1398 Fselect_window (swindow
, Qnil
);
1400 FRAME_SELECTED_WINDOW (f
) = swindow
;
1404 /* Now we know we can delete this one. */
1405 window_deletion_count
++;
1408 /* tem is null for dummy parent windows
1409 (which have inferiors but not any contents themselves) */
1413 unchain_marker (XMARKER (p
->pointm
));
1414 unchain_marker (XMARKER (p
->start
));
1417 /* Free window glyph matrices. It is sure that they are allocated
1418 again when ADJUST_GLYPHS is called. Block input so that expose
1419 events and other events that access glyph matrices are not
1420 processed while we are changing them. */
1422 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1426 XWINDOW (tem
)->prev
= p
->prev
;
1430 XWINDOW (tem
)->next
= p
->next
;
1432 if (EQ (window
, par
->hchild
))
1433 par
->hchild
= p
->next
;
1434 if (EQ (window
, par
->vchild
))
1435 par
->vchild
= p
->next
;
1437 /* Find one of our siblings to give our space to. */
1441 /* If p gives its space to its next sibling, that sibling needs
1442 to have its top/left side pulled back to where p's is.
1443 set_window_{height,width} will re-position the sibling's
1446 XWINDOW (sib
)->top_line
= p
->top_line
;
1447 XWINDOW (sib
)->left_col
= p
->left_col
;
1450 /* Stretch that sibling. */
1451 if (!NILP (par
->vchild
))
1452 set_window_height (sib
,
1453 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1455 if (!NILP (par
->hchild
))
1456 set_window_width (sib
,
1457 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1460 /* If parent now has only one child,
1461 put the child into the parent's place. */
1465 if (NILP (XWINDOW (tem
)->next
)) {
1466 replace_window (parent
, tem
);
1467 par
= XWINDOW (tem
);
1470 /* Since we may be deleting combination windows, we must make sure that
1471 not only p but all its children have been marked as deleted. */
1472 if (! NILP (p
->hchild
))
1473 delete_all_subwindows (XWINDOW (p
->hchild
));
1474 else if (! NILP (p
->vchild
))
1475 delete_all_subwindows (XWINDOW (p
->vchild
));
1477 /* Mark this window as deleted. */
1478 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1480 if (! NILP (par
->parent
))
1481 par
= XWINDOW (par
->parent
);
1483 /* Check if we have a v/hchild with a v/hchild. In that case remove
1486 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1488 p
= XWINDOW (par
->vchild
);
1489 par
->vchild
= p
->vchild
;
1492 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1494 p
= XWINDOW (par
->hchild
);
1495 par
->hchild
= p
->hchild
;
1503 while (! NILP (tem
)) {
1504 XWINDOW (tem
)->parent
= p
->parent
;
1505 if (NILP (XWINDOW (tem
)->next
))
1507 tem
= XWINDOW (tem
)->next
;
1510 /* The next of the v/hchild we are removing is now the next of the
1511 last child for the v/hchild:
1512 Before v/hchild -> v/hchild -> next1 -> next2
1515 After: v/hchild -> next1 -> next2 -> next3
1517 XWINDOW (tem
)->next
= p
->next
;
1518 if (! NILP (p
->next
))
1519 XWINDOW (p
->next
)->prev
= tem
;
1521 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1525 /* Adjust glyph matrices. */
1532 /***********************************************************************
1534 ***********************************************************************/
1536 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1537 pointer. This is a callback function for foreach_window, used in
1538 function window_list. */
1541 add_window_to_list (w
, user_data
)
1545 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1547 XSETWINDOW (window
, w
);
1548 *list
= Fcons (window
, *list
);
1553 /* Return a list of all windows, for use by next_window. If
1554 Vwindow_list is a list, return that list. Otherwise, build a new
1555 list, cache it in Vwindow_list, and return that. */
1560 if (!CONSP (Vwindow_list
))
1564 Vwindow_list
= Qnil
;
1565 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1567 Lisp_Object args
[2];
1569 /* We are visiting windows in canonical order, and add
1570 new windows at the front of args[1], which means we
1571 have to reverse this list at the end. */
1573 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1574 args
[0] = Vwindow_list
;
1575 args
[1] = Fnreverse (args
[1]);
1576 Vwindow_list
= Fnconc (2, args
);
1580 return Vwindow_list
;
1584 /* Value is non-zero if WINDOW satisfies the constraints given by
1585 OWINDOW, MINIBUF and ALL_FRAMES.
1587 MINIBUF t means WINDOW may be minibuffer windows.
1588 `lambda' means WINDOW may not be a minibuffer window.
1589 a window means a specific minibuffer window
1591 ALL_FRAMES t means search all frames,
1592 nil means search just current frame,
1593 `visible' means search just visible frames,
1594 0 means search visible and iconified frames,
1595 a window means search the frame that window belongs to,
1596 a frame means consider windows on that frame, only. */
1599 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1600 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1602 struct window
*w
= XWINDOW (window
);
1603 struct frame
*f
= XFRAME (w
->frame
);
1604 int candidate_p
= 1;
1606 if (!BUFFERP (w
->buffer
))
1608 else if (MINI_WINDOW_P (w
)
1609 && (EQ (minibuf
, Qlambda
)
1610 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1612 /* If MINIBUF is `lambda' don't consider any mini-windows.
1613 If it is a window, consider only that one. */
1616 else if (EQ (all_frames
, Qt
))
1618 else if (NILP (all_frames
))
1620 xassert (WINDOWP (owindow
));
1621 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1623 else if (EQ (all_frames
, Qvisible
))
1625 FRAME_SAMPLE_VISIBILITY (f
);
1626 candidate_p
= FRAME_VISIBLE_P (f
);
1628 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1630 FRAME_SAMPLE_VISIBILITY (f
);
1631 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1633 else if (WINDOWP (all_frames
))
1634 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1635 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1636 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1637 else if (FRAMEP (all_frames
))
1638 candidate_p
= EQ (all_frames
, w
->frame
);
1644 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1645 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1649 decode_next_window_args (window
, minibuf
, all_frames
)
1650 Lisp_Object
*window
, *minibuf
, *all_frames
;
1653 *window
= selected_window
;
1655 CHECK_LIVE_WINDOW (*window
);
1657 /* MINIBUF nil may or may not include minibuffers. Decide if it
1659 if (NILP (*minibuf
))
1660 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1661 else if (!EQ (*minibuf
, Qt
))
1664 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1665 => count none of them, or a specific minibuffer window (the
1666 active one) to count. */
1668 /* ALL_FRAMES nil doesn't specify which frames to include. */
1669 if (NILP (*all_frames
))
1670 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1671 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1673 else if (EQ (*all_frames
, Qvisible
))
1675 else if (EQ (*all_frames
, make_number (0)))
1677 else if (FRAMEP (*all_frames
))
1679 else if (!EQ (*all_frames
, Qt
))
1682 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1683 search just current frame, `visible' meaning search just visible
1684 frames, 0 meaning search visible and iconified frames, or a
1685 window, meaning search the frame that window belongs to, or a
1686 frame, meaning consider windows on that frame, only. */
1690 /* Return the next or previous window of WINDOW in canonical ordering
1691 of windows. NEXT_P non-zero means return the next window. See the
1692 documentation string of next-window for the meaning of MINIBUF and
1696 next_window (window
, minibuf
, all_frames
, next_p
)
1697 Lisp_Object window
, minibuf
, all_frames
;
1700 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1702 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1703 return the first window on the frame. */
1704 if (FRAMEP (all_frames
)
1705 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1706 return Fframe_first_window (all_frames
);
1712 /* Find WINDOW in the list of all windows. */
1713 list
= Fmemq (window
, window_list ());
1715 /* Scan forward from WINDOW to the end of the window list. */
1717 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1718 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1721 /* Scan from the start of the window list up to WINDOW. */
1723 for (list
= Vwindow_list
;
1724 CONSP (list
) && !EQ (XCAR (list
), window
);
1726 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1730 window
= XCAR (list
);
1734 Lisp_Object candidate
, list
;
1736 /* Scan through the list of windows for candidates. If there are
1737 candidate windows in front of WINDOW, the last one of these
1738 is the one we want. If there are candidates following WINDOW
1739 in the list, again the last one of these is the one we want. */
1741 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1743 if (EQ (XCAR (list
), window
))
1745 if (WINDOWP (candidate
))
1748 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1750 candidate
= XCAR (list
);
1753 if (WINDOWP (candidate
))
1761 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1762 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1763 If omitted, WINDOW defaults to the selected window.
1765 Optional second arg MINIBUF t means count the minibuffer window even
1766 if not active. MINIBUF nil or omitted means count the minibuffer iff
1767 it is active. MINIBUF neither t nor nil means not to count the
1768 minibuffer even if it is active.
1770 Several frames may share a single minibuffer; if the minibuffer
1771 counts, all windows on all frames that share that minibuffer count
1772 too. Therefore, `next-window' can be used to iterate through the
1773 set of windows even when the minibuffer is on another frame. If the
1774 minibuffer does not count, only windows from WINDOW's frame count.
1776 Optional third arg ALL-FRAMES t means include windows on all frames.
1777 ALL-FRAMES nil or omitted means cycle within the frames as specified
1778 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1779 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1780 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1781 Anything else means restrict to WINDOW's frame.
1783 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1784 `next-window' to iterate through the entire cycle of acceptable
1785 windows, eventually ending up back at the window you started with.
1786 `previous-window' traverses the same cycle, in the reverse order. */)
1787 (window
, minibuf
, all_frames
)
1788 Lisp_Object window
, minibuf
, all_frames
;
1790 return next_window (window
, minibuf
, all_frames
, 1);
1794 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1795 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1796 If omitted, WINDOW defaults to the selected window.
1798 Optional second arg MINIBUF t means count the minibuffer window even
1799 if not active. MINIBUF nil or omitted means count the minibuffer iff
1800 it is active. MINIBUF neither t nor nil means not to count the
1801 minibuffer even if it is active.
1803 Several frames may share a single minibuffer; if the minibuffer
1804 counts, all windows on all frames that share that minibuffer count
1805 too. Therefore, `previous-window' can be used to iterate through
1806 the set of windows even when the minibuffer is on another frame. If
1807 the minibuffer does not count, only windows from WINDOW's frame count
1809 Optional third arg ALL-FRAMES t means include windows on all frames.
1810 ALL-FRAMES nil or omitted means cycle within the frames as specified
1811 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1812 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1813 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1814 Anything else means restrict to WINDOW's frame.
1816 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1817 `previous-window' to iterate through the entire cycle of acceptable
1818 windows, eventually ending up back at the window you started with.
1819 `next-window' traverses the same cycle, in the reverse order. */)
1820 (window
, minibuf
, all_frames
)
1821 Lisp_Object window
, minibuf
, all_frames
;
1823 return next_window (window
, minibuf
, all_frames
, 0);
1827 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1828 doc
: /* Select the ARG'th different window on this frame.
1829 All windows on current frame are arranged in a cyclic order.
1830 This command selects the window ARG steps away in that order.
1831 A negative ARG moves in the opposite order. The optional second
1832 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1834 Lisp_Object arg
, all_frames
;
1840 window
= selected_window
;
1842 for (i
= XINT (arg
); i
> 0; --i
)
1843 window
= Fnext_window (window
, Qnil
, all_frames
);
1845 window
= Fprevious_window (window
, Qnil
, all_frames
);
1847 Fselect_window (window
, Qnil
);
1852 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1853 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1854 FRAME nil or omitted means use the selected frame.
1855 WINDOW nil or omitted means use the selected window.
1856 MINIBUF t means include the minibuffer window, even if it isn't active.
1857 MINIBUF nil or omitted means include the minibuffer window only
1859 MINIBUF neither nil nor t means never include the minibuffer window. */)
1860 (frame
, minibuf
, window
)
1861 Lisp_Object frame
, minibuf
, window
;
1864 window
= selected_window
;
1866 frame
= selected_frame
;
1868 if (!EQ (frame
, XWINDOW (window
)->frame
))
1869 error ("Window is on a different frame");
1871 return window_list_1 (window
, minibuf
, frame
);
1875 /* Return a list of windows in canonical ordering. Arguments are like
1876 for `next-window'. */
1879 window_list_1 (window
, minibuf
, all_frames
)
1880 Lisp_Object window
, minibuf
, all_frames
;
1882 Lisp_Object tail
, list
, rest
;
1884 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1887 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1888 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1889 list
= Fcons (XCAR (tail
), list
);
1891 /* Rotate the list to start with WINDOW. */
1892 list
= Fnreverse (list
);
1893 rest
= Fmemq (window
, list
);
1894 if (!NILP (rest
) && !EQ (rest
, list
))
1896 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1898 XSETCDR (tail
, Qnil
);
1899 list
= nconc2 (rest
, list
);
1906 /* Look at all windows, performing an operation specified by TYPE
1908 If FRAMES is Qt, look at all frames;
1909 Qnil, look at just the selected frame;
1910 Qvisible, look at visible frames;
1911 a frame, just look at windows on that frame.
1912 If MINI is non-zero, perform the operation on minibuffer windows too. */
1917 GET_BUFFER_WINDOW
, /* Arg is buffer */
1918 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1919 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1920 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1922 UNSHOW_BUFFER
, /* Arg is buffer */
1923 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1928 window_loop (type
, obj
, mini
, frames
)
1929 enum window_loop type
;
1930 Lisp_Object obj
, frames
;
1933 Lisp_Object window
, windows
, best_window
, frame_arg
;
1935 struct gcpro gcpro1
;
1937 /* If we're only looping through windows on a particular frame,
1938 frame points to that frame. If we're looping through windows
1939 on all frames, frame is 0. */
1940 if (FRAMEP (frames
))
1941 f
= XFRAME (frames
);
1942 else if (NILP (frames
))
1943 f
= SELECTED_FRAME ();
1948 frame_arg
= Qlambda
;
1949 else if (EQ (frames
, make_number (0)))
1951 else if (EQ (frames
, Qvisible
))
1956 /* frame_arg is Qlambda to stick to one frame,
1957 Qvisible to consider all visible frames,
1960 /* Pick a window to start with. */
1964 window
= FRAME_SELECTED_WINDOW (f
);
1966 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1968 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1972 for (; CONSP (windows
); windows
= XCDR (windows
))
1976 window
= XCAR (windows
);
1977 w
= XWINDOW (window
);
1979 /* Note that we do not pay attention here to whether the frame
1980 is visible, since Fwindow_list skips non-visible frames if
1981 that is desired, under the control of frame_arg. */
1982 if (!MINI_WINDOW_P (w
)
1983 /* For UNSHOW_BUFFER, we must always consider all windows. */
1984 || type
== UNSHOW_BUFFER
1985 || (mini
&& minibuf_level
> 0))
1988 case GET_BUFFER_WINDOW
:
1989 if (EQ (w
->buffer
, obj
)
1990 /* Don't find any minibuffer window
1991 except the one that is currently in use. */
1992 && (MINI_WINDOW_P (w
)
1993 ? EQ (window
, minibuf_window
)
1996 if (NILP (best_window
))
1997 best_window
= window
;
1998 else if (EQ (window
, selected_window
))
1999 /* For compatibility with 20.x, prefer to return
2001 best_window
= window
;
2005 case GET_LRU_WINDOW
:
2006 /* `obj' is an integer encoding a bitvector.
2007 `obj & 1' means consider only full-width windows.
2008 `obj & 2' means consider also dedicated windows. */
2009 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2010 || (!(XINT (obj
) & 2) && EQ (w
->dedicated
, Qt
))
2011 /* Minibuffer windows are always ignored. */
2012 || MINI_WINDOW_P (w
))
2014 if (NILP (best_window
)
2015 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2016 > XFASTINT (w
->use_time
)))
2017 best_window
= window
;
2020 case DELETE_OTHER_WINDOWS
:
2021 if (!EQ (window
, obj
))
2022 Fdelete_window (window
);
2025 case DELETE_BUFFER_WINDOWS
:
2026 if (EQ (w
->buffer
, obj
))
2028 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2030 /* If this window is dedicated, and in a frame of its own,
2032 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2033 && !NILP (w
->dedicated
)
2034 && other_visible_frames (f
))
2036 /* Skip the other windows on this frame.
2037 There might be one, the minibuffer! */
2038 while (CONSP (XCDR (windows
))
2039 && EQ (XWINDOW (XCAR (windows
))->frame
,
2040 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2041 windows
= XCDR (windows
);
2043 /* Now we can safely delete the frame. */
2044 Fdelete_frame (w
->frame
, Qnil
);
2046 else if (NILP (w
->parent
))
2048 /* If we're deleting the buffer displayed in the
2049 only window on the frame, find a new buffer to
2052 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2053 Fset_window_buffer (window
, buffer
, Qnil
);
2054 if (EQ (window
, selected_window
))
2055 Fset_buffer (w
->buffer
);
2058 Fdelete_window (window
);
2062 case GET_LARGEST_WINDOW
:
2063 { /* nil `obj' means to ignore dedicated windows. */
2064 /* Ignore dedicated windows and minibuffers. */
2065 if (MINI_WINDOW_P (w
) || (NILP (obj
) && EQ (w
->dedicated
, Qt
)))
2068 if (NILP (best_window
))
2069 best_window
= window
;
2072 struct window
*b
= XWINDOW (best_window
);
2073 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2074 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2075 best_window
= window
;
2081 if (EQ (w
->buffer
, obj
))
2084 struct frame
*f
= XFRAME (w
->frame
);
2086 /* Find another buffer to show in this window. */
2087 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2089 /* If this window is dedicated, and in a frame of its own,
2091 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2092 && !NILP (w
->dedicated
)
2093 && other_visible_frames (f
))
2095 /* Skip the other windows on this frame.
2096 There might be one, the minibuffer! */
2097 while (CONSP (XCDR (windows
))
2098 && EQ (XWINDOW (XCAR (windows
))->frame
,
2099 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2100 windows
= XCDR (windows
);
2102 /* Now we can safely delete the frame. */
2103 Fdelete_frame (w
->frame
, Qnil
);
2105 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2108 XSETWINDOW (window
, w
);
2109 /* If this window is dedicated and not the only window
2110 in its frame, then kill it. */
2111 Fdelete_window (window
);
2115 /* Otherwise show a different buffer in the window. */
2116 w
->dedicated
= Qnil
;
2117 Fset_window_buffer (window
, buffer
, Qnil
);
2118 if (EQ (window
, selected_window
))
2119 Fset_buffer (w
->buffer
);
2124 case REDISPLAY_BUFFER_WINDOWS
:
2125 if (EQ (w
->buffer
, obj
))
2127 mark_window_display_accurate (window
, 0);
2128 w
->update_mode_line
= Qt
;
2129 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2130 ++update_mode_lines
;
2131 best_window
= window
;
2135 /* Check for a window that has a killed buffer. */
2136 case CHECK_ALL_WINDOWS
:
2137 if (! NILP (w
->buffer
)
2138 && NILP (XBUFFER (w
->buffer
)->name
))
2142 case WINDOW_LOOP_UNUSED
:
2151 /* Used for debugging. Abort if any window has a dead buffer. */
2154 check_all_windows ()
2156 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2159 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2160 doc
: /* Return the window least recently selected or used for display.
2161 Return a full-width window if possible.
2162 A minibuffer window is never a candidate.
2163 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2164 so if all windows are dedicated, the value is nil.
2165 If optional argument FRAME is `visible', search all visible frames.
2166 If FRAME is 0, search all visible and iconified frames.
2167 If FRAME is t, search all frames.
2168 If FRAME is nil, search only the selected frame.
2169 If FRAME is a frame, search only that frame. */)
2171 Lisp_Object frame
, dedicated
;
2173 register Lisp_Object w
;
2174 /* First try for a window that is full-width */
2175 w
= window_loop (GET_LRU_WINDOW
,
2176 NILP (dedicated
) ? make_number (1) : make_number (3),
2178 if (!NILP (w
) && !EQ (w
, selected_window
))
2180 /* If none of them, try the rest */
2181 return window_loop (GET_LRU_WINDOW
,
2182 NILP (dedicated
) ? make_number (0) : make_number (2),
2186 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2187 doc
: /* Return the largest window in area.
2188 A minibuffer window is never a candidate.
2189 A dedicated window is never a candidate unless DEDICATED is non-nil,
2190 so if all windows are dedicated, the value is nil.
2191 If optional argument FRAME is `visible', search all visible frames.
2192 If FRAME is 0, search all visible and iconified frames.
2193 If FRAME is t, search all frames.
2194 If FRAME is nil, search only the selected frame.
2195 If FRAME is a frame, search only that frame. */)
2197 Lisp_Object frame
, dedicated
;
2199 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2203 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2204 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2205 BUFFER can be a buffer or a buffer name.
2206 If optional argument FRAME is `visible', search all visible frames.
2207 If optional argument FRAME is 0, search all visible and iconified frames.
2208 If FRAME is t, search all frames.
2209 If FRAME is nil, search only the selected frame.
2210 If FRAME is a frame, search only that frame. */)
2212 Lisp_Object buffer
, frame
;
2214 buffer
= Fget_buffer (buffer
);
2215 if (BUFFERP (buffer
))
2216 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2221 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2223 doc
: /* Make WINDOW (or the selected window) fill its frame.
2224 Only the frame WINDOW is on is affected.
2225 This function tries to reduce display jumps
2226 by keeping the text previously visible in WINDOW
2227 in the same place on the frame. Doing this depends on
2228 the value of (window-start WINDOW), so if calling this function
2229 in a program gives strange scrolling, make sure the window-start
2230 value is reasonable when this function is called. */)
2239 window
= selected_window
;
2241 CHECK_LIVE_WINDOW (window
);
2242 w
= XWINDOW (window
);
2244 startpos
= marker_position (w
->start
);
2245 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2247 if (MINI_WINDOW_P (w
) && top
> 0)
2248 error ("Can't expand minibuffer to full frame");
2250 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2252 /* Try to minimize scrolling, by setting the window start to the point
2253 will cause the text at the old window start to be at the same place
2254 on the frame. But don't try to do this if the window start is
2255 outside the visible portion (as might happen when the display is
2256 not current, due to typeahead). */
2257 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2259 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2260 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2262 struct position pos
;
2263 struct buffer
*obuf
= current_buffer
;
2265 Fset_buffer (w
->buffer
);
2266 /* This computation used to temporarily move point, but that can
2267 have unwanted side effects due to text properties. */
2268 pos
= *vmotion (startpos
, -top
, w
);
2270 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2271 w
->window_end_valid
= Qnil
;
2272 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2273 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2275 /* We need to do this, so that the window-scroll-functions
2277 w
->optional_new_start
= Qt
;
2279 set_buffer_internal (obuf
);
2285 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2286 1, 2, "bDelete windows on (buffer): ",
2287 doc
: /* Delete all windows showing BUFFER.
2288 BUFFER must be a buffer or the name of an existing buffer.
2289 Optional second argument FRAME controls which frames are affected.
2290 If optional argument FRAME is `visible', search all visible frames.
2291 If FRAME is 0, search all visible and iconified frames.
2292 If FRAME is nil, search all frames.
2293 If FRAME is t, search only the selected frame.
2294 If FRAME is a frame, search only that frame. */)
2296 Lisp_Object buffer
, frame
;
2298 /* FRAME uses t and nil to mean the opposite of what window_loop
2302 else if (EQ (frame
, Qt
))
2307 buffer
= Fget_buffer (buffer
);
2308 CHECK_BUFFER (buffer
);
2309 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2315 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2316 Sreplace_buffer_in_windows
,
2317 1, 1, "bReplace buffer in windows: ",
2318 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2319 BUFFER may be a buffer or the name of an existing buffer. */)
2325 buffer
= Fget_buffer (buffer
);
2326 CHECK_BUFFER (buffer
);
2327 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2332 /* Replace BUFFER with some other buffer in all windows
2333 of all frames, even those on other keyboards. */
2336 replace_buffer_in_all_windows (buffer
)
2340 Lisp_Object tail
, frame
;
2342 /* A single call to window_loop won't do the job
2343 because it only considers frames on the current keyboard.
2344 So loop manually over frames, and handle each one. */
2345 FOR_EACH_FRAME (tail
, frame
)
2346 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2348 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2352 /* Set the height of WINDOW and all its inferiors. */
2354 /* The smallest acceptable dimensions for a window. Anything smaller
2355 might crash Emacs. */
2357 #define MIN_SAFE_WINDOW_WIDTH (2)
2358 #define MIN_SAFE_WINDOW_HEIGHT (1)
2360 /* Make sure that window_min_height and window_min_width are
2361 not too small; if they are, set them to safe minima. */
2364 check_min_window_sizes ()
2366 /* Smaller values might permit a crash. */
2367 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2368 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2369 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2370 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2373 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2374 minimum allowable size. */
2377 check_frame_size (frame
, rows
, cols
)
2381 /* For height, we have to see:
2382 how many windows the frame has at minimum (one or two),
2383 and whether it has a menu bar or other special stuff at the top. */
2385 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2386 ? MIN_SAFE_WINDOW_HEIGHT
2387 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2389 if (FRAME_TOP_MARGIN (frame
) > 0)
2390 min_height
+= FRAME_TOP_MARGIN (frame
);
2392 if (*rows
< min_height
)
2394 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2395 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2399 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2400 check if W's width can be changed, otherwise check W's height.
2401 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2402 siblings, too. If none of the siblings is resizable, WINDOW isn't
2406 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2408 int width_p
, check_siblings_p
;
2413 if (!NILP (w
->hchild
))
2415 c
= XWINDOW (w
->hchild
);
2419 /* A horiz. combination is fixed-width if all of if its
2421 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2422 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2423 fixed_p
= c
== NULL
;
2427 /* A horiz. combination is fixed-height if one 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
;
2434 else if (!NILP (w
->vchild
))
2436 c
= XWINDOW (w
->vchild
);
2440 /* A vert. combination is fixed-width if one of if its
2442 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2443 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2444 fixed_p
= c
!= NULL
;
2448 /* A vert. combination is fixed-height if all 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
;
2455 else if (BUFFERP (w
->buffer
))
2457 struct buffer
*old
= current_buffer
;
2460 current_buffer
= XBUFFER (w
->buffer
);
2461 val
= find_symbol_value (Qwindow_size_fixed
);
2462 current_buffer
= old
;
2465 if (!EQ (val
, Qunbound
))
2467 fixed_p
= !NILP (val
);
2470 && ((EQ (val
, Qheight
) && width_p
)
2471 || (EQ (val
, Qwidth
) && !width_p
)))
2475 /* Can't tell if this one is resizable without looking at
2476 siblings. If all siblings are fixed-size this one is too. */
2477 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2481 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2482 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2486 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2487 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2501 /* Return the minimum size of window W, not taking fixed-width windows
2502 into account. WIDTH_P non-zero means return the minimum width,
2503 otherwise return the minimum height. If W is a combination window,
2504 compute the minimum size from the minimum sizes of W's children. */
2507 window_min_size_1 (w
, width_p
)
2514 if (!NILP (w
->hchild
))
2516 c
= XWINDOW (w
->hchild
);
2521 /* The min width of a horizontal combination is
2522 the sum of the min widths of its children. */
2525 size
+= window_min_size_1 (c
, width_p
);
2526 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2531 /* The min height a horizontal combination equals
2532 the maximum of all min height of its children. */
2535 int min_size
= window_min_size_1 (c
, width_p
);
2536 size
= max (min_size
, size
);
2537 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2541 else if (!NILP (w
->vchild
))
2543 c
= XWINDOW (w
->vchild
);
2548 /* The min width of a vertical combination is
2549 the maximum of the min widths of its children. */
2552 int min_size
= window_min_size_1 (c
, width_p
);
2553 size
= max (min_size
, size
);
2554 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2559 /* The min height of a vertical combination equals
2560 the sum of the min height of its children. */
2563 size
+= window_min_size_1 (c
, width_p
);
2564 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2571 size
= window_min_width
;
2574 if (MINI_WINDOW_P (w
)
2575 || (!WINDOW_WANTS_MODELINE_P (w
)
2576 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2579 size
= window_min_height
;
2587 /* Return the minimum size of window W, taking fixed-size windows into
2588 account. WIDTH_P non-zero means return the minimum width,
2589 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2590 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2591 unless FIXED is null. */
2594 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2596 int width_p
, ignore_fixed_p
, *fixed
;
2603 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2609 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2611 size
= window_min_size_1 (w
, width_p
);
2617 /* Adjust the margins of window W if text area is too small.
2618 Return 1 if window width is ok after adjustment; 0 if window
2619 is still too narrow. */
2622 adjust_window_margins (w
)
2625 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2626 - WINDOW_FRINGE_COLS (w
)
2627 - WINDOW_SCROLL_BAR_COLS (w
));
2628 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2629 + WINDOW_RIGHT_MARGIN_COLS (w
));
2631 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2634 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2637 /* Window's text area is too narrow, but reducing the window
2638 margins will fix that. */
2639 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2640 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2642 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2643 w
->left_margin_cols
= w
->right_margin_cols
2644 = make_number (margin_cols
/2);
2646 w
->right_margin_cols
= make_number (margin_cols
);
2649 w
->left_margin_cols
= make_number (margin_cols
);
2653 /* Calculate new sizes for windows in the list FORWARD when the window size
2654 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2655 The number of windows in FORWARD is NCHILDREN, and the number that
2656 can shrink is SHRINKABLE.
2657 The minimum size a window can have is MIN_SIZE.
2658 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2659 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2662 This function returns an allocated array of new sizes that the caller
2663 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2664 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2665 the second, and so on.
2667 This function tries to keep windows at least at the minimum size
2668 and resize other windows before it resizes any window to zero (i.e.
2669 delete that window).
2671 Windows are resized proportional to their size, so bigger windows
2672 shrink more than smaller windows. */
2674 shrink_windows (total
, size
, nchildren
, shrinkable
,
2675 min_size
, resize_fixed_p
, forward
, width_p
)
2676 int total
, size
, nchildren
, shrinkable
, min_size
;
2677 int resize_fixed_p
, width_p
;
2678 Lisp_Object forward
;
2680 int available_resize
= 0;
2684 int smallest
= total
;
2685 int total_removed
= 0;
2686 int total_shrink
= total
- size
;
2689 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2691 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2695 c
= XWINDOW (child
);
2696 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2698 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2702 new_sizes
[i
] = child_size
;
2703 if (child_size
> min_size
)
2704 available_resize
+= child_size
- min_size
;
2707 /* We might need to shrink some windows to zero. Find the smallest
2708 windows and set them to 0 until we can fulfil the new size. */
2710 while (shrinkable
> 1 && size
+ available_resize
< total
)
2712 for (i
= 0; i
< nchildren
; ++i
)
2713 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2714 smallest
= new_sizes
[i
];
2716 for (i
= 0; i
< nchildren
; ++i
)
2717 if (new_sizes
[i
] == smallest
)
2719 /* Resize this window down to zero. */
2721 if (smallest
> min_size
)
2722 available_resize
-= smallest
- min_size
;
2723 available_resize
+= smallest
;
2725 total_removed
+= smallest
;
2727 /* We don't know what the smallest is now. */
2730 /* Out of for, just remove one window at the time and
2731 check again if we have enough space. */
2736 /* Now, calculate the new sizes. Try to shrink each window
2737 proportional to its size. */
2738 for (i
= 0; i
< nchildren
; ++i
)
2740 if (new_sizes
[i
] > min_size
)
2742 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2743 if (new_sizes
[i
] - to_shrink
< min_size
)
2744 to_shrink
= new_sizes
[i
] - min_size
;
2745 new_sizes
[i
] -= to_shrink
;
2746 total_removed
+= to_shrink
;
2750 /* Any reminder due to rounding, we just subtract from windows
2751 that are left and still can be shrunk. */
2752 while (total_shrink
> total_removed
)
2754 int nonzero_sizes
= 0;
2755 int nonzero_idx
= -1;
2757 for (i
= 0; i
< nchildren
; ++i
)
2758 if (new_sizes
[i
] > 0)
2764 for (i
= 0; i
< nchildren
; ++i
)
2765 if (new_sizes
[i
] > min_size
)
2770 /* Out of for, just shrink one window at the time and
2771 check again if we have enough space. */
2776 /* Special case, only one window left. */
2777 if (nonzero_sizes
== 1)
2781 /* Any surplus due to rounding, we add to windows that are left. */
2782 while (total_shrink
< total_removed
)
2784 for (i
= 0; i
< nchildren
; ++i
)
2786 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2798 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2799 WINDOW's width. Resize WINDOW's children, if any, so that they
2800 keep their proportionate size relative to WINDOW. Propagate
2801 WINDOW's top or left edge position to children. Delete windows
2802 that become too small unless NODELETE_P is non-zero.
2804 If NODELETE_P is 2, that means we do delete windows that are
2805 too small, even if they were too small before! */
2808 size_window (window
, size
, width_p
, nodelete_p
)
2810 int size
, width_p
, nodelete_p
;
2812 struct window
*w
= XWINDOW (window
);
2814 Lisp_Object child
, *forward
, *sideward
;
2815 int old_size
, min_size
, safe_min_size
;
2817 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2818 seems like it's too soon to do this here. ++KFS. */
2819 if (nodelete_p
== 2)
2822 check_min_window_sizes ();
2823 size
= max (0, size
);
2825 /* If the window has been "too small" at one point,
2826 don't delete it for being "too small" in the future.
2827 Preserve it as long as that is at all possible. */
2830 old_size
= WINDOW_TOTAL_COLS (w
);
2831 min_size
= window_min_width
;
2832 /* Ensure that there is room for the scroll bar and fringes!
2833 We may reduce display margins though. */
2834 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2835 + WINDOW_FRINGE_COLS (w
)
2836 + WINDOW_SCROLL_BAR_COLS (w
));
2840 old_size
= XINT (w
->total_lines
);
2841 min_size
= window_min_height
;
2842 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2845 if (old_size
< min_size
&& nodelete_p
!= 2)
2846 w
->too_small_ok
= Qt
;
2848 /* Maybe delete WINDOW if it's too small. */
2849 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2851 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2852 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2853 if (min_size
< safe_min_size
)
2854 min_size
= safe_min_size
;
2855 if (size
< min_size
)
2857 delete_window (window
);
2862 /* Set redisplay hints. */
2863 w
->last_modified
= make_number (0);
2864 w
->last_overlay_modified
= make_number (0);
2865 windows_or_buffers_changed
++;
2866 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2870 sideward
= &w
->vchild
;
2871 forward
= &w
->hchild
;
2872 w
->total_cols
= make_number (size
);
2873 adjust_window_margins (w
);
2877 sideward
= &w
->hchild
;
2878 forward
= &w
->vchild
;
2879 w
->total_lines
= make_number (size
);
2880 w
->orig_total_lines
= Qnil
;
2883 if (!NILP (*sideward
))
2885 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2887 c
= XWINDOW (child
);
2889 c
->left_col
= w
->left_col
;
2891 c
->top_line
= w
->top_line
;
2892 size_window (child
, size
, width_p
, nodelete_p
);
2895 else if (!NILP (*forward
))
2897 int fixed_size
, each
, extra
, n
;
2898 int resize_fixed_p
, nfixed
;
2899 int last_pos
, first_pos
, nchildren
, total
;
2900 int *new_sizes
= NULL
;
2902 /* Determine the fixed-size portion of the this window, and the
2903 number of child windows. */
2904 fixed_size
= nchildren
= nfixed
= total
= 0;
2905 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2909 c
= XWINDOW (child
);
2910 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2911 total
+= child_size
;
2913 if (window_fixed_size_p (c
, width_p
, 0))
2915 fixed_size
+= child_size
;
2920 /* If the new size is smaller than fixed_size, or if there
2921 aren't any resizable windows, allow resizing fixed-size
2923 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2925 /* Compute how many lines/columns to add/remove to each child. The
2926 value of extra takes care of rounding errors. */
2927 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2928 if (size
< total
&& n
> 1)
2929 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2930 resize_fixed_p
, *forward
, width_p
);
2933 each
= (size
- total
) / n
;
2934 extra
= (size
- total
) - n
* each
;
2937 /* Compute new children heights and edge positions. */
2938 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2939 last_pos
= first_pos
;
2940 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2942 int new_size
, old_size
;
2944 c
= XWINDOW (child
);
2945 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2946 new_size
= old_size
;
2948 /* The top or left edge position of this child equals the
2949 bottom or right edge of its predecessor. */
2951 c
->left_col
= make_number (last_pos
);
2953 c
->top_line
= make_number (last_pos
);
2955 /* If this child can be resized, do it. */
2956 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2958 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2962 /* Set new height. Note that size_window also propagates
2963 edge positions to children, so it's not a no-op if we
2964 didn't change the child's size. */
2965 size_window (child
, new_size
, width_p
, 1);
2967 /* Remember the bottom/right edge position of this child; it
2968 will be used to set the top/left edge of the next child. */
2969 last_pos
+= new_size
;
2972 if (new_sizes
) xfree (new_sizes
);
2974 /* We should have covered the parent exactly with child windows. */
2975 xassert (size
== last_pos
- first_pos
);
2977 /* Now delete any children that became too small. */
2979 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2982 c
= XWINDOW (child
);
2983 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2984 size_window (child
, child_size
, width_p
, 2);
2989 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2990 WINDOW's children. NODELETE non-zero means don't delete windows
2991 that become too small in the process. (The caller should check
2992 later and do so if appropriate.) */
2995 set_window_height (window
, height
, nodelete
)
3000 size_window (window
, height
, 0, nodelete
);
3004 /* Set WINDOW's width to WIDTH, and recursively change the width of
3005 WINDOW's children. NODELETE non-zero means don't delete windows
3006 that become too small in the process. (The caller should check
3007 later and do so if appropriate.) */
3010 set_window_width (window
, width
, nodelete
)
3015 size_window (window
, width
, 1, nodelete
);
3018 /* Change window heights in windows rooted in WINDOW by N lines. */
3021 change_window_heights (window
, n
)
3025 struct window
*w
= XWINDOW (window
);
3027 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3028 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3030 if (INTEGERP (w
->orig_top_line
))
3031 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3032 if (INTEGERP (w
->orig_total_lines
))
3033 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3035 /* Handle just the top child in a vertical split. */
3036 if (!NILP (w
->vchild
))
3037 change_window_heights (w
->vchild
, n
);
3039 /* Adjust all children in a horizontal split. */
3040 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3042 w
= XWINDOW (window
);
3043 change_window_heights (window
, n
);
3048 int window_select_count
;
3051 Fset_window_buffer_unwind (obuf
)
3058 EXFUN (Fset_window_fringes
, 4);
3059 EXFUN (Fset_window_scroll_bars
, 4);
3061 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3062 means it's allowed to run hooks. See make_frame for a case where
3063 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3064 margins, fringes, and scroll-bar settings of the window are not
3065 reset from the buffer's local settings. */
3068 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3069 Lisp_Object window
, buffer
;
3070 int run_hooks_p
, keep_margins_p
;
3072 struct window
*w
= XWINDOW (window
);
3073 struct buffer
*b
= XBUFFER (buffer
);
3074 int count
= SPECPDL_INDEX ();
3078 if (EQ (window
, selected_window
))
3079 b
->last_selected_window
= window
;
3081 /* Let redisplay errors through. */
3082 b
->display_error_modiff
= 0;
3084 /* Update time stamps of buffer display. */
3085 if (INTEGERP (b
->display_count
))
3086 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3087 b
->display_time
= Fcurrent_time ();
3089 XSETFASTINT (w
->window_end_pos
, 0);
3090 XSETFASTINT (w
->window_end_vpos
, 0);
3091 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3092 w
->window_end_valid
= Qnil
;
3093 w
->hscroll
= w
->min_hscroll
= make_number (0);
3095 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3096 set_marker_restricted (w
->start
,
3097 make_number (b
->last_window_start
),
3099 w
->start_at_line_beg
= Qnil
;
3100 w
->force_start
= Qnil
;
3101 XSETFASTINT (w
->last_modified
, 0);
3102 XSETFASTINT (w
->last_overlay_modified
, 0);
3103 windows_or_buffers_changed
++;
3105 /* We must select BUFFER for running the window-scroll-functions.
3106 If WINDOW is selected, switch permanently.
3107 Otherwise, switch but go back to the ambient buffer afterward. */
3108 if (EQ (window
, selected_window
))
3109 Fset_buffer (buffer
);
3110 /* We can't check ! NILP (Vwindow_scroll_functions) here
3111 because that might itself be a local variable. */
3112 else if (window_initialized
)
3114 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3115 Fset_buffer (buffer
);
3118 if (!keep_margins_p
)
3120 /* Set left and right marginal area width etc. from buffer. */
3122 /* This may call adjust_window_margins three times, so
3123 temporarily disable window margins. */
3124 Lisp_Object save_left
= w
->left_margin_cols
;
3125 Lisp_Object save_right
= w
->right_margin_cols
;
3127 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3129 Fset_window_fringes (window
,
3130 b
->left_fringe_width
, b
->right_fringe_width
,
3131 b
->fringes_outside_margins
);
3133 Fset_window_scroll_bars (window
,
3134 b
->scroll_bar_width
,
3135 b
->vertical_scroll_bar_type
, Qnil
);
3137 w
->left_margin_cols
= save_left
;
3138 w
->right_margin_cols
= save_right
;
3140 Fset_window_margins (window
,
3141 b
->left_margin_cols
, b
->right_margin_cols
);
3146 if (! NILP (Vwindow_scroll_functions
))
3147 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3148 Fmarker_position (w
->start
));
3150 if (! NILP (Vwindow_configuration_change_hook
)
3151 && ! NILP (Vrun_hooks
))
3152 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3155 unbind_to (count
, Qnil
);
3159 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3160 doc
: /* Make WINDOW display BUFFER as its contents.
3161 BUFFER can be a buffer or the name of an existing buffer.
3162 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3163 display margins, fringe widths, and scroll bar settings are maintained;
3164 the default is to reset these from BUFFER's local settings or the frame
3167 This function runs the hook `window-scroll-functions'. */)
3168 (window
, buffer
, keep_margins
)
3169 register Lisp_Object window
, buffer
, keep_margins
;
3171 register Lisp_Object tem
;
3172 register struct window
*w
= decode_window (window
);
3174 XSETWINDOW (window
, w
);
3175 buffer
= Fget_buffer (buffer
);
3176 CHECK_BUFFER (buffer
);
3178 if (NILP (XBUFFER (buffer
)->name
))
3179 error ("Attempt to display deleted buffer");
3183 error ("Window is deleted");
3184 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3185 is first being set up. */
3187 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3188 error ("Window is dedicated to `%s'",
3189 SDATA (XBUFFER (tem
)->name
));
3194 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3198 /* Note that selected_window can be nil
3199 when this is called from Fset_window_configuration. */
3201 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3202 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3203 If WINDOW is not already selected, make WINDOW's buffer current
3204 and make WINDOW the frame's selected window. Return WINDOW.
3205 Optional second arg NORECORD non-nil means
3206 do not put this buffer at the front of the list of recently selected ones.
3208 Note that the main editor command loop
3209 selects the buffer of the selected window before each command. */)
3211 register Lisp_Object window
, norecord
;
3213 register struct window
*w
;
3214 register struct window
*ow
;
3217 CHECK_LIVE_WINDOW (window
);
3219 w
= XWINDOW (window
);
3220 w
->frozen_window_start_p
= 0;
3222 ++window_select_count
;
3223 XSETFASTINT (w
->use_time
, window_select_count
);
3224 if (EQ (window
, selected_window
))
3227 /* Store the current buffer's actual point into the
3228 old selected window. It belongs to that window,
3229 and when the window is not selected, must be in the window. */
3230 if (!NILP (selected_window
))
3232 ow
= XWINDOW (selected_window
);
3233 if (! NILP (ow
->buffer
))
3234 set_marker_both (ow
->pointm
, ow
->buffer
,
3235 BUF_PT (XBUFFER (ow
->buffer
)),
3236 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3239 selected_window
= window
;
3240 sf
= SELECTED_FRAME ();
3241 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3243 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3244 /* Use this rather than Fhandle_switch_frame
3245 so that FRAME_FOCUS_FRAME is moved appropriately as we
3246 move around in the state where a minibuffer in a separate
3248 Fselect_frame (WINDOW_FRAME (w
));
3251 sf
->selected_window
= window
;
3253 if (NILP (norecord
))
3254 record_buffer (w
->buffer
);
3255 Fset_buffer (w
->buffer
);
3257 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3259 /* Go to the point recorded in the window.
3260 This is important when the buffer is in more
3261 than one window. It also matters when
3262 redisplay_window has altered point after scrolling,
3263 because it makes the change only in the window. */
3265 register int new_point
= marker_position (w
->pointm
);
3266 if (new_point
< BEGV
)
3268 else if (new_point
> ZV
)
3274 windows_or_buffers_changed
++;
3279 select_window_norecord (window
)
3282 return Fselect_window (window
, Qt
);
3285 /* Deiconify the frame containing the window WINDOW,
3286 unless it is the selected frame;
3289 The reason for the exception for the selected frame
3290 is that it seems better not to change the selected frames visibility
3291 merely because of displaying a different buffer in it.
3292 The deiconification is useful when a buffer gets shown in
3293 another frame that you were not using lately. */
3296 display_buffer_1 (window
)
3299 Lisp_Object frame
= XWINDOW (window
)->frame
;
3300 FRAME_PTR f
= XFRAME (frame
);
3302 FRAME_SAMPLE_VISIBILITY (f
);
3304 if (EQ (frame
, selected_frame
))
3305 ; /* Assume the selected frame is already visible enough. */
3306 else if (minibuf_level
> 0
3307 && MINI_WINDOW_P (XWINDOW (selected_window
))
3308 && WINDOW_LIVE_P (minibuf_selected_window
)
3309 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3310 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3313 if (FRAME_ICONIFIED_P (f
))
3314 Fmake_frame_visible (frame
);
3315 else if (FRAME_VISIBLE_P (f
))
3316 Fraise_frame (frame
);
3322 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3323 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3324 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3325 special frame for that buffer using the default frame parameters.
3327 If the value is a list, it is a list of frame parameters that would be used
3328 to make a frame for that buffer.
3329 The variables `special-display-buffer-names'
3330 and `special-display-regexps' control this. */)
3332 Lisp_Object buffer_name
;
3336 CHECK_STRING (buffer_name
);
3338 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3342 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3346 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3348 Lisp_Object car
= XCAR (tem
);
3350 && fast_string_match (car
, buffer_name
) >= 0)
3352 else if (CONSP (car
)
3353 && STRINGP (XCAR (car
))
3354 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3360 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3361 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3362 More precisely, if `display-buffer' or `pop-to-buffer' would display
3363 that buffer in the selected window rather than (as usual) in some other window.
3364 See `same-window-buffer-names' and `same-window-regexps'. */)
3366 Lisp_Object buffer_name
;
3370 CHECK_STRING (buffer_name
);
3372 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3376 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3380 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3382 Lisp_Object car
= XCAR (tem
);
3384 && fast_string_match (car
, buffer_name
) >= 0)
3386 else if (CONSP (car
)
3387 && STRINGP (XCAR (car
))
3388 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3394 /* Use B so the default is (other-buffer). */
3395 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3396 "BDisplay buffer: \nP",
3397 doc
: /* Make BUFFER appear in some window but don't select it.
3398 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3400 If BUFFER is shown already in some window, just use that one,
3401 unless the window is the selected window and the optional second
3402 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3403 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3404 Returns the window displaying BUFFER.
3405 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3406 displaying BUFFER, then simply raise that frame.
3408 The variables `special-display-buffer-names',
3409 `special-display-regexps', `same-window-buffer-names', and
3410 `same-window-regexps' customize how certain buffer names are handled.
3411 The latter two take effect only if NOT-THIS-WINDOW is t.
3413 If optional argument FRAME is `visible', search all visible frames.
3414 If FRAME is 0, search all visible and iconified frames.
3415 If FRAME is t, search all frames.
3416 If FRAME is a frame, search only that frame.
3417 If FRAME is nil, search only the selected frame
3418 (actually the last nonminibuffer frame),
3419 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3420 which means search visible and iconified frames.
3422 If a full-width window on a splittable frame is available to display
3423 the buffer, it may be split, subject to the value of the variable
3424 `split-height-threshold'.
3426 If `even-window-heights' is non-nil, window heights will be evened out
3427 if displaying the buffer causes two vertically adjacent windows to be
3429 (buffer
, not_this_window
, frame
)
3430 register Lisp_Object buffer
, not_this_window
, frame
;
3432 register Lisp_Object window
, tem
, swp
;
3436 buffer
= Fget_buffer (buffer
);
3437 CHECK_BUFFER (buffer
);
3439 if (!NILP (Vdisplay_buffer_function
))
3440 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3442 if (NILP (not_this_window
)
3443 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3444 return display_buffer_1 (selected_window
);
3446 /* See if the user has specified this buffer should appear
3447 in the selected window. */
3448 if (NILP (not_this_window
))
3450 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3451 if (!NILP (swp
) && !no_switch_window (selected_window
))
3453 Fswitch_to_buffer (buffer
, Qnil
);
3454 return display_buffer_1 (selected_window
);
3458 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3459 look for a window showing BUFFER on any visible or iconified frame.
3460 Otherwise search only the current frame. */
3463 else if (pop_up_frames
3464 || display_buffer_reuse_frames
3465 || last_nonminibuf_frame
== 0)
3466 XSETFASTINT (tem
, 0);
3468 XSETFRAME (tem
, last_nonminibuf_frame
);
3470 window
= Fget_buffer_window (buffer
, tem
);
3472 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3473 return display_buffer_1 (window
);
3475 /* Certain buffer names get special handling. */
3476 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3478 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3480 return call1 (Vspecial_display_function
, buffer
);
3482 return call2 (Vspecial_display_function
, buffer
, tem
);
3485 /* If there are no frames open that have more than a minibuffer,
3486 we need to create a new frame. */
3487 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3489 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3490 Fset_window_buffer (window
, buffer
, Qnil
);
3491 return display_buffer_1 (window
);
3494 f
= SELECTED_FRAME ();
3496 || FRAME_MINIBUF_ONLY_P (f
)
3497 /* If the current frame is a special display frame,
3498 don't try to reuse its windows. */
3499 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3504 if (FRAME_MINIBUF_ONLY_P (f
))
3505 XSETFRAME (frames
, last_nonminibuf_frame
);
3506 /* Don't try to create a window if we would get an error. */
3507 if (split_height_threshold
< window_min_height
<< 1)
3508 split_height_threshold
= window_min_height
<< 1;
3510 /* Note that both Fget_largest_window and Fget_lru_window
3511 ignore minibuffers and dedicated windows.
3512 This means they can return nil. */
3514 /* If the frame we would try to split cannot be split,
3515 try other frames. */
3516 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3518 /* Try visible frames first. */
3519 window
= Fget_largest_window (Qvisible
, Qt
);
3520 /* If that didn't work, try iconified frames. */
3522 window
= Fget_largest_window (make_number (0), Qt
);
3523 #if 0 /* Don't try windows on other displays. */
3525 window
= Fget_largest_window (Qt
, Qt
);
3529 window
= Fget_largest_window (frames
, Qt
);
3531 /* If we got a tall enough full-width window that can be split,
3534 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3535 && window_height (window
) >= split_height_threshold
3536 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3537 window
= Fsplit_window (window
, Qnil
, Qnil
);
3540 Lisp_Object upper
, lower
, other
;
3542 window
= Fget_lru_window (frames
, Qt
);
3543 /* If the LRU window is selected, and big enough,
3544 and can be split, split it. */
3546 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3547 && (EQ (window
, selected_window
)
3548 || EQ (XWINDOW (window
)->parent
, Qnil
))
3549 && window_height (window
) >= window_min_height
<< 1)
3550 window
= Fsplit_window (window
, Qnil
, Qnil
);
3552 window
= Fget_lru_window (frames
, Qnil
);
3553 /* If Fget_lru_window returned nil, try other approaches. */
3555 /* Try visible frames first. */
3557 window
= Fget_buffer_window (buffer
, Qvisible
);
3559 window
= Fget_largest_window (Qvisible
, Qnil
);
3560 /* If that didn't work, try iconified frames. */
3562 window
= Fget_buffer_window (buffer
, make_number (0));
3564 window
= Fget_largest_window (make_number (0), Qnil
);
3566 #if 0 /* Don't try frames on other displays. */
3568 window
= Fget_buffer_window (buffer
, Qt
);
3570 window
= Fget_largest_window (Qt
, Qnil
);
3572 /* As a last resort, make a new frame. */
3574 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3575 /* If window appears above or below another,
3576 even out their heights. */
3577 other
= upper
= lower
= Qnil
;
3578 if (!NILP (XWINDOW (window
)->prev
))
3579 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3580 if (!NILP (XWINDOW (window
)->next
))
3581 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3583 && !NILP (Veven_window_heights
)
3584 /* Check that OTHER and WINDOW are vertically arrayed. */
3585 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3586 && (XFASTINT (XWINDOW (other
)->total_lines
)
3587 > XFASTINT (XWINDOW (window
)->total_lines
)))
3589 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3590 + XFASTINT (XWINDOW (window
)->total_lines
));
3591 enlarge_window (upper
,
3592 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3598 window
= Fget_lru_window (Qnil
, Qnil
);
3600 Fset_window_buffer (window
, buffer
, Qnil
);
3601 return display_buffer_1 (window
);
3605 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3607 doc
: /* Force redisplay of all windows.
3608 If optional arg OBJECT is a window, force redisplay of that window only.
3609 If OBJECT is a buffer or buffer name, force redisplay of all windows
3610 displaying that buffer. */)
3616 windows_or_buffers_changed
++;
3617 update_mode_lines
++;
3621 if (WINDOWP (object
))
3623 struct window
*w
= XWINDOW (object
);
3624 mark_window_display_accurate (object
, 0);
3625 w
->update_mode_line
= Qt
;
3626 if (BUFFERP (w
->buffer
))
3627 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3628 ++update_mode_lines
;
3632 if (STRINGP (object
))
3633 object
= Fget_buffer (object
);
3634 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3636 /* Walk all windows looking for buffer, and force update
3637 of each of those windows. */
3639 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3640 return NILP (object
) ? Qnil
: Qt
;
3643 /* If nothing suitable was found, just return.
3644 We could signal an error, but this feature will typically be used
3645 asynchronously in timers or process sentinels, so we don't. */
3651 temp_output_buffer_show (buf
)
3652 register Lisp_Object buf
;
3654 register struct buffer
*old
= current_buffer
;
3655 register Lisp_Object window
;
3656 register struct window
*w
;
3658 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3661 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3665 #if 0 /* rms: there should be no reason for this. */
3666 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3668 set_buffer_internal (old
);
3670 if (!NILP (Vtemp_buffer_show_function
))
3671 call1 (Vtemp_buffer_show_function
, buf
);
3674 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3676 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3677 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3678 Vminibuf_scroll_window
= window
;
3679 w
= XWINDOW (window
);
3680 XSETFASTINT (w
->hscroll
, 0);
3681 XSETFASTINT (w
->min_hscroll
, 0);
3682 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3683 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3685 /* Run temp-buffer-show-hook, with the chosen window selected
3686 and its buffer current. */
3688 if (!NILP (Vrun_hooks
)
3689 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3690 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3692 int count
= SPECPDL_INDEX ();
3693 Lisp_Object prev_window
, prev_buffer
;
3694 prev_window
= selected_window
;
3695 XSETBUFFER (prev_buffer
, old
);
3697 /* Select the window that was chosen, for running the hook.
3698 Note: Both Fselect_window and select_window_norecord may
3699 set-buffer to the buffer displayed in the window,
3700 so we need to save the current buffer. --stef */
3701 record_unwind_protect (Fset_buffer
, prev_buffer
);
3702 record_unwind_protect (select_window_norecord
, prev_window
);
3703 Fselect_window (window
, Qt
);
3704 Fset_buffer (w
->buffer
);
3705 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3706 unbind_to (count
, Qnil
);
3712 make_dummy_parent (window
)
3716 register struct window
*o
, *p
;
3719 o
= XWINDOW (window
);
3720 p
= allocate_window ();
3721 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3722 ((struct Lisp_Vector
*) p
)->contents
[i
]
3723 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3724 XSETWINDOW (new, p
);
3727 XSETFASTINT (p
->sequence_number
, sequence_number
);
3729 /* Put new into window structure in place of window */
3730 replace_window (window
, new);
3743 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3744 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3745 WINDOW defaults to selected one and SIZE to half its size.
3746 If optional third arg HORFLAG is non-nil, split side by side
3747 and put SIZE columns in the first of the pair. In that case,
3748 SIZE includes that window's scroll bar, or the divider column to its right.
3749 Interactively, all arguments are nil.
3751 Returns the newly created window (which is the lower or rightmost one).
3752 The upper or leftmost window is the original one and remains selected.
3753 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3754 (window
, size
, horflag
)
3755 Lisp_Object window
, size
, horflag
;
3757 register Lisp_Object
new;
3758 register struct window
*o
, *p
;
3760 register int size_int
;
3763 window
= selected_window
;
3765 CHECK_LIVE_WINDOW (window
);
3767 o
= XWINDOW (window
);
3768 fo
= XFRAME (WINDOW_FRAME (o
));
3772 if (!NILP (horflag
))
3773 /* Calculate the size of the left-hand window, by dividing
3774 the usable space in columns by two.
3775 We round up, since the left-hand window may include
3776 a dividing line, while the right-hand may not. */
3777 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3779 size_int
= XFASTINT (o
->total_lines
) >> 1;
3783 CHECK_NUMBER (size
);
3784 size_int
= XINT (size
);
3787 if (MINI_WINDOW_P (o
))
3788 error ("Attempt to split minibuffer window");
3789 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3790 error ("Attempt to split fixed-size window");
3792 check_min_window_sizes ();
3796 if (size_int
< window_min_height
)
3797 error ("Window height %d too small (after splitting)", size_int
);
3798 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3799 error ("Window height %d too small (after splitting)",
3800 XFASTINT (o
->total_lines
) - size_int
);
3801 if (NILP (o
->parent
)
3802 || NILP (XWINDOW (o
->parent
)->vchild
))
3804 make_dummy_parent (window
);
3806 XWINDOW (new)->vchild
= window
;
3811 if (size_int
< window_min_width
)
3812 error ("Window width %d too small (after splitting)", size_int
);
3814 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3815 error ("Window width %d too small (after splitting)",
3816 XFASTINT (o
->total_cols
) - size_int
);
3817 if (NILP (o
->parent
)
3818 || NILP (XWINDOW (o
->parent
)->hchild
))
3820 make_dummy_parent (window
);
3822 XWINDOW (new)->hchild
= window
;
3826 /* Now we know that window's parent is a vertical combination
3827 if we are dividing vertically, or a horizontal combination
3828 if we are making side-by-side windows */
3830 windows_or_buffers_changed
++;
3831 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3832 new = make_window ();
3835 p
->frame
= o
->frame
;
3837 if (!NILP (p
->next
))
3838 XWINDOW (p
->next
)->prev
= new;
3841 p
->parent
= o
->parent
;
3843 p
->window_end_valid
= Qnil
;
3844 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3846 /* Duplicate special geometry settings. */
3848 p
->left_margin_cols
= o
->left_margin_cols
;
3849 p
->right_margin_cols
= o
->right_margin_cols
;
3850 p
->left_fringe_width
= o
->left_fringe_width
;
3851 p
->right_fringe_width
= o
->right_fringe_width
;
3852 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3853 p
->scroll_bar_width
= o
->scroll_bar_width
;
3854 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3856 /* Apportion the available frame space among the two new windows */
3858 if (!NILP (horflag
))
3860 p
->total_lines
= o
->total_lines
;
3861 p
->top_line
= o
->top_line
;
3862 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3863 XSETFASTINT (o
->total_cols
, size_int
);
3864 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3865 adjust_window_margins (p
);
3866 adjust_window_margins (o
);
3870 p
->left_col
= o
->left_col
;
3871 p
->total_cols
= o
->total_cols
;
3872 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3873 XSETFASTINT (o
->total_lines
, size_int
);
3874 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3877 /* Adjust glyph matrices. */
3880 Fset_window_buffer (new, o
->buffer
, Qt
);
3884 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3885 doc
: /* Make current window ARG lines bigger.
3886 From program, optional second arg non-nil means grow sideways ARG columns.
3887 Interactively, if an argument is not given, make the window one line bigger.
3888 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
3889 This function can delete windows, even the second window, if they get
3892 Lisp_Object arg
, horizontal
;
3895 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
3897 if (! NILP (Vwindow_configuration_change_hook
))
3898 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3903 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3904 doc
: /* Make current window ARG lines smaller.
3905 From program, optional second arg non-nil means shrink sideways arg columns.
3906 Interactively, if an argument is not given, make the window one line smaller. Only
3907 siblings to the right or below are changed. */)
3909 Lisp_Object arg
, side
;
3912 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3914 if (! NILP (Vwindow_configuration_change_hook
))
3915 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3921 window_height (window
)
3924 register struct window
*p
= XWINDOW (window
);
3925 return WINDOW_TOTAL_LINES (p
);
3929 window_width (window
)
3932 register struct window
*p
= XWINDOW (window
);
3933 return WINDOW_TOTAL_COLS (p
);
3938 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3940 #define CURSIZE(w) \
3941 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3944 /* Enlarge WINDOW by DELTA.
3945 HORIZ_FLAG nonzero means enlarge it horizontally;
3946 zero means do it vertically.
3948 Siblings of the selected window are resized to fulfill the size
3949 request. If they become too small in the process, they will be
3953 enlarge_window (window
, delta
, horiz_flag
)
3955 int delta
, horiz_flag
;
3957 Lisp_Object parent
, next
, prev
;
3961 int (*sizefun
) P_ ((Lisp_Object
))
3962 = horiz_flag
? window_width
: window_height
;
3963 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3964 = (horiz_flag
? set_window_width
: set_window_height
);
3966 /* Check values of window_min_width and window_min_height for
3968 check_min_window_sizes ();
3970 /* Give up if this window cannot be resized. */
3971 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3972 error ("Window is not resizable");
3974 /* Find the parent of the selected window. */
3977 p
= XWINDOW (window
);
3983 error ("No other window to side of this one");
3988 ? !NILP (XWINDOW (parent
)->hchild
)
3989 : !NILP (XWINDOW (parent
)->vchild
))
3995 sizep
= &CURSIZE (window
);
3998 register int maxdelta
;
4000 /* Compute the maximum size increment this window can have. */
4002 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4003 /* This is a main window followed by a minibuffer. */
4004 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4005 - window_min_size (XWINDOW (p
->next
),
4007 /* This is a minibuffer following a main window. */
4008 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4009 - window_min_size (XWINDOW (p
->prev
),
4011 /* This is a frame with only one window, a minibuffer-only
4012 or a minibufferless frame. */
4015 if (delta
> maxdelta
)
4016 /* This case traps trying to make the minibuffer
4017 the full frame, or make the only window aside from the
4018 minibuffer the full frame. */
4022 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4024 delete_window (window
);
4031 /* Find the total we can get from other siblings without deleting them. */
4033 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4034 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4036 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4037 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4040 /* If we can get it all from them without deleting them, do so. */
4041 if (delta
<= maximum
)
4043 Lisp_Object first_unaffected
;
4044 Lisp_Object first_affected
;
4049 first_affected
= window
;
4050 /* Look at one sibling at a time,
4051 moving away from this window in both directions alternately,
4052 and take as much as we can get without deleting that sibling. */
4054 && (!NILP (next
) || !NILP (prev
)))
4058 int this_one
= ((*sizefun
) (next
)
4059 - window_min_size (XWINDOW (next
),
4060 horiz_flag
, 0, &fixed_p
));
4063 if (this_one
> delta
)
4066 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4067 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4072 next
= XWINDOW (next
)->next
;
4080 int this_one
= ((*sizefun
) (prev
)
4081 - window_min_size (XWINDOW (prev
),
4082 horiz_flag
, 0, &fixed_p
));
4085 if (this_one
> delta
)
4088 first_affected
= prev
;
4090 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4091 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4096 prev
= XWINDOW (prev
)->prev
;
4100 xassert (delta
== 0);
4102 /* Now recalculate the edge positions of all the windows affected,
4103 based on the new sizes. */
4104 first_unaffected
= next
;
4105 prev
= first_affected
;
4106 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4107 prev
= next
, next
= XWINDOW (next
)->next
)
4109 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4110 /* This does not change size of NEXT,
4111 but it propagates the new top edge to its children */
4112 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4117 register int delta1
;
4118 register int opht
= (*sizefun
) (parent
);
4120 if (opht
<= XINT (*sizep
) + delta
)
4122 /* If trying to grow this window to or beyond size of the parent,
4123 just delete all the sibling windows. */
4124 Lisp_Object start
, tem
, next
;
4126 start
= XWINDOW (parent
)->vchild
;
4128 start
= XWINDOW (parent
)->hchild
;
4130 /* Delete any siblings that come after WINDOW. */
4131 tem
= XWINDOW (window
)->next
;
4132 while (! NILP (tem
))
4134 next
= XWINDOW (tem
)->next
;
4135 delete_window (tem
);
4139 /* Delete any siblings that come after WINDOW.
4140 Note that if START is not WINDOW, then WINDOW still
4141 Fhas siblings, so WINDOW has not yet replaced its parent. */
4143 while (! EQ (tem
, window
))
4145 next
= XWINDOW (tem
)->next
;
4146 delete_window (tem
);
4152 /* Otherwise, make delta1 just right so that if we add
4153 delta1 lines to this window and to the parent, and then
4154 shrink the parent back to its original size, the new
4155 proportional size of this window will increase by delta.
4157 The function size_window will compute the new height h'
4158 of the window from delta1 as:
4161 x = delta1 - delta1/n * n for the 1st resizable child
4164 where n is the number of children that can be resized.
4165 We can ignore x by choosing a delta1 that is a multiple of
4166 n. We want the height of this window to come out as
4176 The number of children n equals the number of resizable
4177 children of this window + 1 because we know window itself
4178 is resizable (otherwise we would have signalled an error). */
4180 struct window
*w
= XWINDOW (window
);
4184 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4185 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4187 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4188 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4193 /* Add delta1 lines or columns to this window, and to the parent,
4194 keeping things consistent while not affecting siblings. */
4195 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4196 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4198 /* Squeeze out delta1 lines or columns from our parent,
4199 shriking this window and siblings proportionately.
4200 This brings parent back to correct size.
4201 Delta1 was calculated so this makes this window the desired size,
4202 taking it all out of the siblings. */
4203 (*setsizefun
) (parent
, opht
, 0);
4208 XSETFASTINT (p
->last_modified
, 0);
4209 XSETFASTINT (p
->last_overlay_modified
, 0);
4211 /* Adjust glyph matrices. */
4212 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4216 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4217 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4218 zero means adjust the height, moving the bottom edge.
4220 Following siblings of the selected window are resized to fulfill
4221 the size request. If they become too small in the process, they
4222 are not deleted; instead, we signal an error. */
4225 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4227 int delta
, horiz_flag
;
4229 Lisp_Object parent
, child
;
4231 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4232 int delcount
= window_deletion_count
;
4234 /* Check values of window_min_width and window_min_height for
4236 check_min_window_sizes ();
4239 window
= Fselected_window ();
4241 CHECK_WINDOW (window
);
4243 /* Give up if this window cannot be resized. */
4244 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4245 error ("Window is not resizable");
4249 p
= XWINDOW (window
);
4252 /* Make sure there is a following window. */
4255 : NILP (XWINDOW (window
)->next
)))
4257 Fset_window_configuration (old_config
);
4258 error ("No other window following this one");
4261 /* Don't make this window too small. */
4262 if (XINT (CURSIZE (window
)) + delta
4263 < (horiz_flag
? window_min_width
: window_min_height
))
4265 Fset_window_configuration (old_config
);
4266 error ("Cannot adjust window size as specified");
4269 /* Clear out some redisplay caches. */
4270 XSETFASTINT (p
->last_modified
, 0);
4271 XSETFASTINT (p
->last_overlay_modified
, 0);
4273 /* Adjust this window's edge. */
4274 XSETINT (CURSIZE (window
),
4275 XINT (CURSIZE (window
)) + delta
);
4277 /* If this window has following siblings in the desired dimension,
4279 (If we reach the top of the tree and can never do this,
4280 we will fail and report an error, above.) */
4282 ? !NILP (XWINDOW (parent
)->hchild
)
4283 : !NILP (XWINDOW (parent
)->vchild
))
4285 if (!NILP (XWINDOW (window
)->next
))
4287 /* This may happen for the minibuffer. In that case
4288 the window_deletion_count check below does not work. */
4289 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4291 Fset_window_configuration (old_config
);
4292 error ("Cannot adjust window size as specified");
4295 XSETINT (CURBEG (p
->next
),
4296 XINT (CURBEG (p
->next
)) + delta
);
4297 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4303 /* Here we have a chain of parallel siblings, in the other dimension.
4304 Change the size of the other siblings. */
4305 for (child
= (horiz_flag
4306 ? XWINDOW (parent
)->vchild
4307 : XWINDOW (parent
)->hchild
);
4309 child
= XWINDOW (child
)->next
)
4310 if (! EQ (child
, window
))
4311 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4317 /* If we made a window so small it got deleted,
4318 we failed. Report failure. */
4319 if (delcount
!= window_deletion_count
)
4321 Fset_window_configuration (old_config
);
4322 error ("Cannot adjust window size as specified");
4325 /* Adjust glyph matrices. */
4326 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4332 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4333 Sadjust_window_trailing_edge
, 3, 3, 0,
4334 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4335 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4336 Otherwise, adjust the height, moving the bottom edge.
4338 Following siblings of the selected window are resized to fulfill
4339 the size request. If they become too small in the process, they
4340 are not deleted; instead, we signal an error. */)
4341 (window
, delta
, horizontal
)
4342 Lisp_Object window
, delta
, horizontal
;
4344 CHECK_NUMBER (delta
);
4345 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4347 if (! NILP (Vwindow_configuration_change_hook
))
4348 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4355 /***********************************************************************
4356 Resizing Mini-Windows
4357 ***********************************************************************/
4359 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4361 enum save_restore_action
4368 static int save_restore_orig_size
P_ ((struct window
*,
4369 enum save_restore_action
));
4371 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4372 from lowest windows first. */
4375 shrink_window_lowest_first (w
, height
)
4383 xassert (!MINI_WINDOW_P (w
));
4385 /* Set redisplay hints. */
4386 XSETFASTINT (w
->last_modified
, 0);
4387 XSETFASTINT (w
->last_overlay_modified
, 0);
4388 windows_or_buffers_changed
++;
4389 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4391 old_height
= XFASTINT (w
->total_lines
);
4392 XSETFASTINT (w
->total_lines
, height
);
4394 if (!NILP (w
->hchild
))
4396 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4398 c
= XWINDOW (child
);
4399 c
->top_line
= w
->top_line
;
4400 shrink_window_lowest_first (c
, height
);
4403 else if (!NILP (w
->vchild
))
4405 Lisp_Object last_child
;
4406 int delta
= old_height
- height
;
4411 /* Find the last child. We are taking space from lowest windows
4412 first, so we iterate over children from the last child
4414 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4417 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4418 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4422 c
= XWINDOW (child
);
4423 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4425 if (this_one
> delta
)
4428 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4432 /* Compute new positions. */
4433 last_top
= XINT (w
->top_line
);
4434 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4436 c
= XWINDOW (child
);
4437 c
->top_line
= make_number (last_top
);
4438 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4439 last_top
+= XFASTINT (c
->total_lines
);
4445 /* Save, restore, or check positions and sizes in the window tree
4446 rooted at W. ACTION says what to do.
4448 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4449 orig_total_lines members are valid for all windows in the window
4450 tree. Value is non-zero if they are valid.
4452 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4453 orig_top_line and orig_total_lines for all windows in the tree.
4455 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4456 stored in orig_top_line and orig_total_lines for all windows. */
4459 save_restore_orig_size (w
, action
)
4461 enum save_restore_action action
;
4467 if (!NILP (w
->hchild
))
4469 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4472 else if (!NILP (w
->vchild
))
4474 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4480 case CHECK_ORIG_SIZES
:
4481 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4485 case SAVE_ORIG_SIZES
:
4486 w
->orig_top_line
= w
->top_line
;
4487 w
->orig_total_lines
= w
->total_lines
;
4488 XSETFASTINT (w
->last_modified
, 0);
4489 XSETFASTINT (w
->last_overlay_modified
, 0);
4492 case RESTORE_ORIG_SIZES
:
4493 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4494 w
->top_line
= w
->orig_top_line
;
4495 w
->total_lines
= w
->orig_total_lines
;
4496 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4497 XSETFASTINT (w
->last_modified
, 0);
4498 XSETFASTINT (w
->last_overlay_modified
, 0);
4505 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4512 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4513 without deleting other windows. */
4516 grow_mini_window (w
, delta
)
4520 struct frame
*f
= XFRAME (w
->frame
);
4521 struct window
*root
;
4523 xassert (MINI_WINDOW_P (w
));
4524 xassert (delta
>= 0);
4526 /* Check values of window_min_width and window_min_height for
4528 check_min_window_sizes ();
4530 /* Compute how much we can enlarge the mini-window without deleting
4532 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4535 int min_height
= window_min_size (root
, 0, 0, 0);
4536 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4537 /* Note that the root window may already be smaller than
4539 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4544 /* Save original window sizes and positions, if not already done. */
4545 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4546 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4548 /* Shrink other windows. */
4549 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4551 /* Grow the mini-window. */
4552 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4553 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4554 XSETFASTINT (w
->last_modified
, 0);
4555 XSETFASTINT (w
->last_overlay_modified
, 0);
4562 /* Shrink mini-window W. If there is recorded info about window sizes
4563 before a call to grow_mini_window, restore recorded window sizes.
4564 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4568 shrink_mini_window (w
)
4571 struct frame
*f
= XFRAME (w
->frame
);
4572 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4574 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4576 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4578 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4579 windows_or_buffers_changed
= 1;
4581 else if (XFASTINT (w
->total_lines
) > 1)
4583 /* Distribute the additional lines of the mini-window
4584 among the other windows. */
4586 XSETWINDOW (window
, w
);
4587 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4593 /* Mark window cursors off for all windows in the window tree rooted
4594 at W by setting their phys_cursor_on_p flag to zero. Called from
4595 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4596 the frame are cleared. */
4599 mark_window_cursors_off (w
)
4604 if (!NILP (w
->hchild
))
4605 mark_window_cursors_off (XWINDOW (w
->hchild
));
4606 else if (!NILP (w
->vchild
))
4607 mark_window_cursors_off (XWINDOW (w
->vchild
));
4609 w
->phys_cursor_on_p
= 0;
4611 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4616 /* Return number of lines of text (not counting mode lines) in W. */
4619 window_internal_height (w
)
4622 int ht
= XFASTINT (w
->total_lines
);
4624 if (!MINI_WINDOW_P (w
))
4626 if (!NILP (w
->parent
)
4627 || !NILP (w
->vchild
)
4628 || !NILP (w
->hchild
)
4631 || WINDOW_WANTS_MODELINE_P (w
))
4634 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4642 /* Return the number of columns in W.
4643 Don't count columns occupied by scroll bars or the vertical bar
4644 separating W from the sibling to its right. */
4647 window_box_text_cols (w
)
4650 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4651 int width
= XINT (w
->total_cols
);
4653 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4654 /* Scroll bars occupy a few columns. */
4655 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4656 else if (!FRAME_WINDOW_P (f
)
4657 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4658 /* The column of `|' characters separating side-by-side windows
4659 occupies one column only. */
4662 if (FRAME_WINDOW_P (f
))
4663 /* On window-systems, fringes and display margins cannot be
4664 used for normal text. */
4665 width
-= (WINDOW_FRINGE_COLS (w
)
4666 + WINDOW_LEFT_MARGIN_COLS (w
)
4667 + WINDOW_RIGHT_MARGIN_COLS (w
));
4673 /************************************************************************
4675 ***********************************************************************/
4677 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4678 N screen-fulls, which is defined as the height of the window minus
4679 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4680 instead. Negative values of N mean scroll down. NOERROR non-zero
4681 means don't signal an error if we try to move over BEGV or ZV,
4685 window_scroll (window
, n
, whole
, noerror
)
4693 /* If we must, use the pixel-based version which is much slower than
4694 the line-based one but can handle varying line heights. */
4695 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4696 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4698 window_scroll_line_based (window
, n
, whole
, noerror
);
4704 /* Implementation of window_scroll that works based on pixel line
4705 heights. See the comment of window_scroll for parameter
4709 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4716 struct window
*w
= XWINDOW (window
);
4717 struct text_pos start
;
4719 int this_scroll_margin
;
4721 /* True if we fiddled the window vscroll field without really scrolling. */
4724 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4726 /* If PT is not visible in WINDOW, move back one half of
4727 the screen. Allow PT to be partially visible, otherwise
4728 something like (scroll-down 1) with PT in the line before
4729 the partially visible one would recenter. */
4730 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4733 /* Move backward half the height of the window. Performance note:
4734 vmotion used here is about 10% faster, but would give wrong
4735 results for variable height lines. */
4736 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4737 it
.current_y
= it
.last_visible_y
;
4738 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4740 /* The function move_iterator_vertically may move over more than
4741 the specified y-distance. If it->w is small, e.g. a
4742 mini-buffer window, we may end up in front of the window's
4743 display area. This is the case when Start displaying at the
4744 start of the line containing PT in this case. */
4745 if (it
.current_y
<= 0)
4747 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4748 move_it_vertically_backward (&it
, 0);
4752 start
= it
.current
.pos
;
4754 else if (auto_window_vscroll_p
)
4756 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4759 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4761 dy
= max ((window_box_height (w
)
4762 - next_screen_context_lines
* dy
),
4766 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4768 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4769 Fset_window_vscroll (window
, make_number (px
), Qt
);
4772 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4774 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4775 Fset_window_vscroll (window
, make_number (px
), Qt
);
4779 Fset_window_vscroll (window
, make_number (0), Qt
);
4782 /* If scroll_preserve_screen_position is non-nil, we try to set
4783 point in the same window line as it is now, so get that line. */
4784 if (!NILP (Vscroll_preserve_screen_position
))
4786 start_display (&it
, w
, start
);
4787 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4788 preserve_y
= it
.current_y
;
4793 /* Move iterator it from start the specified distance forward or
4794 backward. The result is the new window start. */
4795 start_display (&it
, w
, start
);
4798 int start_pos
= IT_CHARPOS (it
);
4799 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4800 dy
= max ((window_box_height (w
)
4801 - next_screen_context_lines
* dy
),
4804 /* Note that move_it_vertically always moves the iterator to the
4805 start of a line. So, if the last line doesn't have a newline,
4806 we would end up at the start of the line ending at ZV. */
4809 move_it_vertically_backward (&it
, -dy
);
4810 /* Ensure we actually does move, e.g. in case we are currently
4811 looking at an image that is taller that the window height. */
4812 while (start_pos
== IT_CHARPOS (it
)
4813 && start_pos
> BEGV
)
4814 move_it_by_lines (&it
, -1, 1);
4818 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4819 MOVE_TO_POS
| MOVE_TO_Y
);
4820 /* Ensure we actually does move, e.g. in case we are currently
4821 looking at an image that is taller that the window height. */
4822 while (start_pos
== IT_CHARPOS (it
)
4824 move_it_by_lines (&it
, 1, 1);
4828 move_it_by_lines (&it
, n
, 1);
4830 /* We failed if we find ZV is already on the screen (scrolling up,
4831 means there's nothing past the end), or if we can't start any
4832 earlier (scrolling down, means there's nothing past the top). */
4833 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4834 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4836 if (IT_CHARPOS (it
) == ZV
)
4838 if (it
.current_y
< it
.last_visible_y
4839 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4840 >= it
.last_visible_y
))
4842 /* The last line was only partially visible, make it fully
4844 w
->vscroll
= (it
.last_visible_y
4845 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4846 adjust_glyphs (it
.f
);
4851 Fsignal (Qend_of_buffer
, Qnil
);
4855 if (w
->vscroll
!= 0)
4856 /* The first line was only partially visible, make it fully
4862 Fsignal (Qbeginning_of_buffer
, Qnil
);
4865 /* If control gets here, then we vscrolled. */
4867 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4869 /* Don't try to change the window start below. */
4875 int pos
= IT_CHARPOS (it
);
4878 /* If in the middle of a multi-glyph character move forward to
4879 the next character. */
4880 if (in_display_vector_p (&it
))
4883 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4886 /* Set the window start, and set up the window for redisplay. */
4887 set_marker_restricted (w
->start
, make_number (pos
),
4889 bytepos
= XMARKER (w
->start
)->bytepos
;
4890 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4892 w
->update_mode_line
= Qt
;
4893 XSETFASTINT (w
->last_modified
, 0);
4894 XSETFASTINT (w
->last_overlay_modified
, 0);
4895 /* Set force_start so that redisplay_window will run the
4896 window-scroll-functions. */
4897 w
->force_start
= Qt
;
4900 /* The rest of this function uses current_y in a nonstandard way,
4901 not including the height of the header line if any. */
4902 it
.current_y
= it
.vpos
= 0;
4904 /* Move PT out of scroll margins.
4905 This code wants current_y to be zero at the window start position
4906 even if there is a header line. */
4907 this_scroll_margin
= max (0, scroll_margin
);
4908 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4909 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4913 /* We moved the window start towards ZV, so PT may be now
4914 in the scroll margin at the top. */
4915 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4916 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4917 && (NILP (Vscroll_preserve_screen_position
)
4918 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4919 /* We found PT at a legitimate height. Leave it alone. */
4921 else if (preserve_y
>= 0)
4923 /* If we have a header line, take account of it.
4924 This is necessary because we set it.current_y to 0, above. */
4925 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4926 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4928 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4929 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4933 while (it
.current_y
< this_scroll_margin
)
4935 int prev
= it
.current_y
;
4936 move_it_by_lines (&it
, 1, 1);
4937 if (prev
== it
.current_y
)
4940 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4945 int charpos
, bytepos
;
4948 /* Save our position, for the preserve_y case. */
4949 charpos
= IT_CHARPOS (it
);
4950 bytepos
= IT_BYTEPOS (it
);
4952 /* We moved the window start towards BEGV, so PT may be now
4953 in the scroll margin at the bottom. */
4954 move_it_to (&it
, PT
, -1,
4955 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4956 - this_scroll_margin
- 1),
4958 MOVE_TO_POS
| MOVE_TO_Y
);
4960 /* Save our position, in case it's correct. */
4961 charpos
= IT_CHARPOS (it
);
4962 bytepos
= IT_BYTEPOS (it
);
4964 /* See if point is on a partially visible line at the end. */
4965 if (it
.what
== IT_EOB
)
4966 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4969 move_it_by_lines (&it
, 1, 1);
4970 partial_p
= it
.current_y
> it
.last_visible_y
;
4973 if (charpos
== PT
&& !partial_p
4974 && (NILP (Vscroll_preserve_screen_position
)
4975 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4976 /* We found PT before we found the display margin, so PT is ok. */
4978 else if (preserve_y
>= 0)
4980 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4981 start_display (&it
, w
, start
);
4982 #if 0 /* It's wrong to subtract this here
4983 because we called start_display again
4984 and did not alter it.current_y this time. */
4986 /* If we have a header line, take account of it. */
4987 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4988 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4991 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4992 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4997 /* The last line was only partially visible, so back up two
4998 lines to make sure we're on a fully visible line. */
5000 move_it_by_lines (&it
, -2, 0);
5001 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5004 /* No, the position we saved is OK, so use it. */
5005 SET_PT_BOTH (charpos
, bytepos
);
5011 /* Implementation of window_scroll that works based on screen lines.
5012 See the comment of window_scroll for parameter descriptions. */
5015 window_scroll_line_based (window
, n
, whole
, noerror
)
5021 register struct window
*w
= XWINDOW (window
);
5022 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5023 register int pos
, pos_byte
;
5024 register int ht
= window_internal_height (w
);
5025 register Lisp_Object tem
;
5029 struct position posit
;
5032 /* If scrolling screen-fulls, compute the number of lines to
5033 scroll from the window's height. */
5035 n
*= max (1, ht
- next_screen_context_lines
);
5037 startpos
= marker_position (w
->start
);
5039 posit
= *compute_motion (startpos
, 0, 0, 0,
5041 -1, XINT (w
->hscroll
),
5043 original_vpos
= posit
.vpos
;
5045 XSETFASTINT (tem
, PT
);
5046 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5050 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5055 lose
= n
< 0 && PT
== BEGV
;
5056 Fvertical_motion (make_number (n
), window
);
5060 SET_PT_BOTH (opoint
, opoint_byte
);
5067 Fsignal (Qbeginning_of_buffer
, Qnil
);
5072 int this_scroll_margin
= scroll_margin
;
5074 /* Don't use a scroll margin that is negative or too large. */
5075 if (this_scroll_margin
< 0)
5076 this_scroll_margin
= 0;
5078 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5079 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5081 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5082 w
->start_at_line_beg
= bolp
;
5083 w
->update_mode_line
= Qt
;
5084 XSETFASTINT (w
->last_modified
, 0);
5085 XSETFASTINT (w
->last_overlay_modified
, 0);
5086 /* Set force_start so that redisplay_window will run
5087 the window-scroll-functions. */
5088 w
->force_start
= Qt
;
5090 if (!NILP (Vscroll_preserve_screen_position
)
5091 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5093 SET_PT_BOTH (pos
, pos_byte
);
5094 Fvertical_motion (make_number (original_vpos
), window
);
5096 /* If we scrolled forward, put point enough lines down
5097 that it is outside the scroll margin. */
5102 if (this_scroll_margin
> 0)
5104 SET_PT_BOTH (pos
, pos_byte
);
5105 Fvertical_motion (make_number (this_scroll_margin
), window
);
5111 if (top_margin
<= opoint
)
5112 SET_PT_BOTH (opoint
, opoint_byte
);
5113 else if (!NILP (Vscroll_preserve_screen_position
))
5115 SET_PT_BOTH (pos
, pos_byte
);
5116 Fvertical_motion (make_number (original_vpos
), window
);
5119 SET_PT (top_margin
);
5125 /* If we scrolled backward, put point near the end of the window
5126 but not within the scroll margin. */
5127 SET_PT_BOTH (pos
, pos_byte
);
5128 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5129 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5132 bottom_margin
= PT
+ 1;
5134 if (bottom_margin
> opoint
)
5135 SET_PT_BOTH (opoint
, opoint_byte
);
5138 if (!NILP (Vscroll_preserve_screen_position
))
5140 SET_PT_BOTH (pos
, pos_byte
);
5141 Fvertical_motion (make_number (original_vpos
), window
);
5144 Fvertical_motion (make_number (-1), window
);
5153 Fsignal (Qend_of_buffer
, Qnil
);
5158 /* Scroll selected_window up or down. If N is nil, scroll a
5159 screen-full which is defined as the height of the window minus
5160 next_screen_context_lines. If N is the symbol `-', scroll.
5161 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5162 up. This is the guts of Fscroll_up and Fscroll_down. */
5165 scroll_command (n
, direction
)
5169 int count
= SPECPDL_INDEX ();
5171 xassert (abs (direction
) == 1);
5173 /* If selected window's buffer isn't current, make it current for
5174 the moment. But don't screw up if window_scroll gets an error. */
5175 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5177 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5178 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5180 /* Make redisplay consider other windows than just selected_window. */
5181 ++windows_or_buffers_changed
;
5185 window_scroll (selected_window
, direction
, 1, 0);
5186 else if (EQ (n
, Qminus
))
5187 window_scroll (selected_window
, -direction
, 1, 0);
5190 n
= Fprefix_numeric_value (n
);
5191 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5194 unbind_to (count
, Qnil
);
5197 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5198 doc
: /* Scroll text of current window upward ARG lines.
5199 If ARG is omitted or nil, scroll upward by a near full screen.
5200 A near full screen is `next-screen-context-lines' less than a full screen.
5201 Negative ARG means scroll downward.
5202 If ARG is the atom `-', scroll downward by nearly full screen.
5203 When calling from a program, supply as argument a number, nil, or `-'. */)
5207 scroll_command (arg
, 1);
5211 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5212 doc
: /* Scroll text of current window down ARG lines.
5213 If ARG is omitted or nil, scroll down by a near full screen.
5214 A near full screen is `next-screen-context-lines' less than a full screen.
5215 Negative ARG means scroll upward.
5216 If ARG is the atom `-', scroll upward by nearly full screen.
5217 When calling from a program, supply as argument a number, nil, or `-'. */)
5221 scroll_command (arg
, -1);
5225 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5226 doc
: /* Return the other window for \"other window scroll\" commands.
5227 If `other-window-scroll-buffer' is non-nil, a window
5228 showing that buffer is used.
5229 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5230 specifies the window. This takes precedence over
5231 `other-window-scroll-buffer'. */)
5236 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5237 && !NILP (Vminibuf_scroll_window
))
5238 window
= Vminibuf_scroll_window
;
5239 /* If buffer is specified, scroll that buffer. */
5240 else if (!NILP (Vother_window_scroll_buffer
))
5242 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5244 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5248 /* Nothing specified; look for a neighboring window on the same
5250 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5252 if (EQ (window
, selected_window
))
5253 /* That didn't get us anywhere; look for a window on another
5256 window
= Fnext_window (window
, Qnil
, Qt
);
5257 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5258 && ! EQ (window
, selected_window
));
5261 CHECK_LIVE_WINDOW (window
);
5263 if (EQ (window
, selected_window
))
5264 error ("There is no other window");
5269 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5270 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5271 A near full screen is `next-screen-context-lines' less than a full screen.
5272 The next window is the one below the current one; or the one at the top
5273 if the current one is at the bottom. Negative ARG means scroll downward.
5274 If ARG is the atom `-', scroll downward by nearly full screen.
5275 When calling from a program, supply as argument a number, nil, or `-'.
5277 If `other-window-scroll-buffer' is non-nil, scroll the window
5278 showing that buffer, popping the buffer up if necessary.
5279 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5280 specifies the window to scroll. This takes precedence over
5281 `other-window-scroll-buffer'. */)
5287 int count
= SPECPDL_INDEX ();
5289 window
= Fother_window_for_scrolling ();
5290 w
= XWINDOW (window
);
5292 /* Don't screw up if window_scroll gets an error. */
5293 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5294 ++windows_or_buffers_changed
;
5296 Fset_buffer (w
->buffer
);
5297 SET_PT (marker_position (w
->pointm
));
5300 window_scroll (window
, 1, 1, 1);
5301 else if (EQ (arg
, Qminus
))
5302 window_scroll (window
, -1, 1, 1);
5308 window_scroll (window
, XINT (arg
), 0, 1);
5311 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5312 unbind_to (count
, Qnil
);
5317 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5318 doc
: /* Scroll selected window display ARG columns left.
5319 Default for ARG is window width minus 2.
5320 Value is the total amount of leftward horizontal scrolling in
5321 effect after the change.
5322 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5323 lower bound for automatic scrolling, i.e. automatic scrolling
5324 will not scroll a window to a column less than the value returned
5325 by this function. This happens in an interactive call. */)
5327 register Lisp_Object arg
, set_minimum
;
5331 struct window
*w
= XWINDOW (selected_window
);
5334 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5336 arg
= Fprefix_numeric_value (arg
);
5338 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5339 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5341 if (!NILP (set_minimum
))
5342 w
->min_hscroll
= w
->hscroll
;
5347 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5348 doc
: /* Scroll selected window display ARG columns right.
5349 Default for ARG is window width minus 2.
5350 Value is the total amount of leftward horizontal scrolling in
5351 effect after the change.
5352 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5353 lower bound for automatic scrolling, i.e. automatic scrolling
5354 will not scroll a window to a column less than the value returned
5355 by this function. This happens in an interactive call. */)
5357 register Lisp_Object arg
, set_minimum
;
5361 struct window
*w
= XWINDOW (selected_window
);
5364 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5366 arg
= Fprefix_numeric_value (arg
);
5368 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5369 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5371 if (!NILP (set_minimum
))
5372 w
->min_hscroll
= w
->hscroll
;
5377 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5378 doc
: /* Return the window which was selected when entering the minibuffer.
5379 Returns nil, if current window is not a minibuffer window. */)
5382 if (minibuf_level
> 0
5383 && MINI_WINDOW_P (XWINDOW (selected_window
))
5384 && WINDOW_LIVE_P (minibuf_selected_window
))
5385 return minibuf_selected_window
;
5390 /* Value is the number of lines actually displayed in window W,
5391 as opposed to its height. */
5394 displayed_window_lines (w
)
5398 struct text_pos start
;
5399 int height
= window_box_height (w
);
5400 struct buffer
*old_buffer
;
5403 if (XBUFFER (w
->buffer
) != current_buffer
)
5405 old_buffer
= current_buffer
;
5406 set_buffer_internal (XBUFFER (w
->buffer
));
5411 /* In case W->start is out of the accessible range, do something
5412 reasonable. This happens in Info mode when Info-scroll-down
5413 calls (recenter -1) while W->start is 1. */
5414 if (XMARKER (w
->start
)->charpos
< BEGV
)
5415 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5416 else if (XMARKER (w
->start
)->charpos
> ZV
)
5417 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5419 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5421 start_display (&it
, w
, start
);
5422 move_it_vertically (&it
, height
);
5423 bottom_y
= line_bottom_y (&it
);
5425 /* rms: On a non-window display,
5426 the value of it.vpos at the bottom of the screen
5427 seems to be 1 larger than window_box_height (w).
5428 This kludge fixes a bug whereby (move-to-window-line -1)
5429 when ZV is on the last screen line
5430 moves to the previous screen line instead of the last one. */
5431 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5434 /* Add in empty lines at the bottom of the window. */
5435 if (bottom_y
< height
)
5437 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5438 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5442 set_buffer_internal (old_buffer
);
5448 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5449 doc
: /* Center point in window and redisplay frame.
5450 With prefix argument ARG, recenter putting point on screen line ARG
5451 relative to the current window. If ARG is negative, it counts up from the
5452 bottom of the window. (ARG should be less than the height of the window.)
5454 If ARG is omitted or nil, erase the entire frame and then
5455 redraw with point in the center of the current window.
5456 Just C-u as prefix means put point in the center of the window
5457 and redisplay normally--don't erase and redraw the frame. */)
5459 register Lisp_Object arg
;
5461 struct window
*w
= XWINDOW (selected_window
);
5462 struct buffer
*buf
= XBUFFER (w
->buffer
);
5463 struct buffer
*obuf
= current_buffer
;
5465 int charpos
, bytepos
;
5467 int this_scroll_margin
;
5469 /* If redisplay is suppressed due to an error, try again. */
5470 obuf
->display_error_modiff
= 0;
5476 /* Invalidate pixel data calculated for all compositions. */
5477 for (i
= 0; i
< n_compositions
; i
++)
5478 composition_table
[i
]->font
= NULL
;
5480 Fredraw_frame (w
->frame
);
5481 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5484 else if (CONSP (arg
)) /* Just C-u. */
5488 arg
= Fprefix_numeric_value (arg
);
5493 set_buffer_internal (buf
);
5495 /* Do this after making BUF current
5496 in case scroll_margin is buffer-local. */
5497 this_scroll_margin
= max (0, scroll_margin
);
5498 this_scroll_margin
= min (this_scroll_margin
,
5499 XFASTINT (w
->total_lines
) / 4);
5501 /* Handle centering on a graphical frame specially. Such frames can
5502 have variable-height lines and centering point on the basis of
5503 line counts would lead to strange effects. */
5504 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5511 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5512 start_display (&it
, w
, pt
);
5513 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5514 charpos
= IT_CHARPOS (it
);
5515 bytepos
= IT_BYTEPOS (it
);
5522 int extra_line_spacing
;
5523 int h
= window_box_height (w
);
5525 iarg
= - max (-iarg
, this_scroll_margin
);
5527 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5528 start_display (&it
, w
, pt
);
5530 /* Be sure we have the exact height of the full line containing PT. */
5531 move_it_by_lines (&it
, 0, 1);
5533 /* The amount of pixels we have to move back is the window
5534 height minus what's displayed in the line containing PT,
5535 and the lines below. */
5538 move_it_by_lines (&it
, nlines
, 1);
5540 if (it
.vpos
== nlines
)
5544 /* Last line has no newline */
5545 h
-= line_bottom_y (&it
);
5549 /* Don't reserve space for extra line spacing of last line. */
5550 extra_line_spacing
= it
.max_extra_line_spacing
;
5552 /* If we can't move down NLINES lines because we hit
5553 the end of the buffer, count in some empty lines. */
5554 if (it
.vpos
< nlines
)
5557 extra_line_spacing
= it
.extra_line_spacing
;
5558 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5563 /* Now find the new top line (starting position) of the window. */
5564 start_display (&it
, w
, pt
);
5566 move_it_vertically_backward (&it
, h
);
5568 /* If extra line spacing is present, we may move too far
5569 back. This causes the last line to be only partially
5570 visible (which triggers redisplay to recenter that line
5571 in the middle), so move forward.
5572 But ignore extra line spacing on last line, as it is not
5573 considered to be part of the visible height of the line.
5575 h
+= extra_line_spacing
;
5576 while (-it
.current_y
> h
)
5577 move_it_by_lines (&it
, 1, 1);
5579 charpos
= IT_CHARPOS (it
);
5580 bytepos
= IT_BYTEPOS (it
);
5584 struct position pos
;
5586 iarg
= max (iarg
, this_scroll_margin
);
5588 pos
= *vmotion (PT
, -iarg
, w
);
5589 charpos
= pos
.bufpos
;
5590 bytepos
= pos
.bytepos
;
5595 struct position pos
;
5596 int ht
= window_internal_height (w
);
5603 /* Don't let it get into the margin at either top or bottom. */
5604 iarg
= max (iarg
, this_scroll_margin
);
5605 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5607 pos
= *vmotion (PT
, - iarg
, w
);
5608 charpos
= pos
.bufpos
;
5609 bytepos
= pos
.bytepos
;
5612 /* Set the new window start. */
5613 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5614 w
->window_end_valid
= Qnil
;
5616 w
->optional_new_start
= Qt
;
5618 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5619 w
->start_at_line_beg
= Qt
;
5621 w
->start_at_line_beg
= Qnil
;
5623 set_buffer_internal (obuf
);
5628 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5630 doc
: /* Return the height in lines of the text display area of WINDOW.
5631 This doesn't include the mode-line (or header-line if any) or any
5632 partial-height lines in the text display area. */)
5636 struct window
*w
= decode_window (window
);
5637 int pixel_height
= window_box_height (w
);
5638 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5639 return make_number (line_height
);
5644 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5646 doc
: /* Position point relative to window.
5647 With no argument, position point at center of window.
5648 An argument specifies vertical position within the window;
5649 zero means top of window, negative means relative to bottom of window. */)
5653 struct window
*w
= XWINDOW (selected_window
);
5657 int this_scroll_margin
;
5660 window
= selected_window
;
5661 start
= marker_position (w
->start
);
5662 if (start
< BEGV
|| start
> ZV
)
5664 int height
= window_internal_height (w
);
5665 Fvertical_motion (make_number (- (height
/ 2)), window
);
5666 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5667 w
->start_at_line_beg
= Fbolp ();
5668 w
->force_start
= Qt
;
5671 Fgoto_char (w
->start
);
5673 lines
= displayed_window_lines (w
);
5676 this_scroll_margin
= max (0, scroll_margin
);
5677 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5681 XSETFASTINT (arg
, lines
/ 2);
5684 int iarg
= XINT (Fprefix_numeric_value (arg
));
5687 iarg
= iarg
+ lines
;
5689 #if 0 /* This code would prevent move-to-window-line from moving point
5690 to a place inside the scroll margins (which would cause the
5691 next redisplay to scroll). I wrote this code, but then concluded
5692 it is probably better not to install it. However, it is here
5693 inside #if 0 so as not to lose it. -- rms. */
5695 /* Don't let it get into the margin at either top or bottom. */
5696 iarg
= max (iarg
, this_scroll_margin
);
5697 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5700 arg
= make_number (iarg
);
5703 /* Skip past a partially visible first line. */
5705 XSETINT (arg
, XINT (arg
) + 1);
5707 return Fvertical_motion (arg
, window
);
5712 /***********************************************************************
5713 Window Configuration
5714 ***********************************************************************/
5716 struct save_window_data
5718 EMACS_INT size_from_Lisp_Vector_struct
;
5719 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5720 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5721 Lisp_Object frame_tool_bar_lines
;
5722 Lisp_Object selected_frame
;
5723 Lisp_Object current_window
;
5724 Lisp_Object current_buffer
;
5725 Lisp_Object minibuf_scroll_window
;
5726 Lisp_Object minibuf_selected_window
;
5727 Lisp_Object root_window
;
5728 Lisp_Object focus_frame
;
5729 /* Record the values of window-min-width and window-min-height
5730 so that window sizes remain consistent with them. */
5731 Lisp_Object min_width
, min_height
;
5732 /* A vector, each of whose elements is a struct saved_window
5734 Lisp_Object saved_windows
;
5737 /* This is saved as a Lisp_Vector */
5740 /* these first two must agree with struct Lisp_Vector in lisp.h */
5741 EMACS_INT size_from_Lisp_Vector_struct
;
5742 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5745 Lisp_Object buffer
, start
, pointm
, mark
;
5746 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5747 Lisp_Object hscroll
, min_hscroll
;
5748 Lisp_Object parent
, prev
;
5749 Lisp_Object start_at_line_beg
;
5750 Lisp_Object display_table
;
5751 Lisp_Object orig_top_line
, orig_total_lines
;
5752 Lisp_Object left_margin_cols
, right_margin_cols
;
5753 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5754 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5757 #define SAVED_WINDOW_N(swv,n) \
5758 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5760 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5761 doc
: /* Return t if OBJECT is a window-configuration object. */)
5765 if (WINDOW_CONFIGURATIONP (object
))
5770 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5771 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5775 register struct save_window_data
*data
;
5776 struct Lisp_Vector
*saved_windows
;
5778 if (! WINDOW_CONFIGURATIONP (config
))
5779 wrong_type_argument (Qwindow_configuration_p
, config
);
5781 data
= (struct save_window_data
*) XVECTOR (config
);
5782 saved_windows
= XVECTOR (data
->saved_windows
);
5783 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5786 DEFUN ("set-window-configuration", Fset_window_configuration
,
5787 Sset_window_configuration
, 1, 1, 0,
5788 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5789 CONFIGURATION must be a value previously returned
5790 by `current-window-configuration' (which see).
5791 If CONFIGURATION was made from a frame that is now deleted,
5792 only frame-independent values can be restored. In this case,
5793 the return value is nil. Otherwise the value is t. */)
5795 Lisp_Object configuration
;
5797 register struct save_window_data
*data
;
5798 struct Lisp_Vector
*saved_windows
;
5799 Lisp_Object new_current_buffer
;
5804 while (!WINDOW_CONFIGURATIONP (configuration
))
5805 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5807 data
= (struct save_window_data
*) XVECTOR (configuration
);
5808 saved_windows
= XVECTOR (data
->saved_windows
);
5810 new_current_buffer
= data
->current_buffer
;
5811 if (NILP (XBUFFER (new_current_buffer
)->name
))
5812 new_current_buffer
= Qnil
;
5815 if (XBUFFER (new_current_buffer
) == current_buffer
)
5816 /* The code further down "preserves point" by saving here PT in
5817 old_point and then setting it later back into PT. When the
5818 current-selected-window and the final-selected-window both show
5819 the current buffer, this suffers from the problem that the
5820 current PT is the window-point of the current-selected-window,
5821 while the final PT is the point of the final-selected-window, so
5822 this copy from one PT to the other would end up moving the
5823 window-point of the final-selected-window to the window-point of
5824 the current-selected-window. So we have to be careful which
5825 point of the current-buffer we copy into old_point. */
5826 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5827 && WINDOWP (selected_window
)
5828 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5829 && !EQ (selected_window
, data
->current_window
))
5830 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5834 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5835 point in new_current_buffer as of the last time this buffer was
5836 used. This can be non-deterministic since it can be changed by
5837 things like jit-lock by mere temporary selection of some random
5838 window that happens to show this buffer.
5839 So if possible we want this arbitrary choice of "which point" to
5840 be the one from the to-be-selected-window so as to prevent this
5841 window's cursor from being copied from another window. */
5842 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5843 /* If current_window = selected_window, its point is in BUF_PT. */
5844 && !EQ (selected_window
, data
->current_window
))
5845 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5847 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5850 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5853 /* If f is a dead frame, don't bother rebuilding its window tree.
5854 However, there is other stuff we should still try to do below. */
5855 if (FRAME_LIVE_P (f
))
5857 register struct window
*w
;
5858 register struct saved_window
*p
;
5859 struct window
*root_window
;
5860 struct window
**leaf_windows
;
5864 /* If the frame has been resized since this window configuration was
5865 made, we change the frame to the size specified in the
5866 configuration, restore the configuration, and then resize it
5867 back. We keep track of the prevailing height in these variables. */
5868 int previous_frame_lines
= FRAME_LINES (f
);
5869 int previous_frame_cols
= FRAME_COLS (f
);
5870 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5871 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5873 /* The mouse highlighting code could get screwed up
5874 if it runs during this. */
5877 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5878 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5879 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5880 XFASTINT (data
->frame_cols
), 0, 0, 0);
5881 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5882 if (XFASTINT (data
->frame_menu_bar_lines
)
5883 != previous_frame_menu_bar_lines
)
5884 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5885 #ifdef HAVE_WINDOW_SYSTEM
5886 if (XFASTINT (data
->frame_tool_bar_lines
)
5887 != previous_frame_tool_bar_lines
)
5888 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5892 /* "Swap out" point from the selected window's buffer
5893 into the window itself. (Normally the pointm of the selected
5894 window holds garbage.) We do this now, before
5895 restoring the window contents, and prevent it from
5896 being done later on when we select a new window. */
5897 if (! NILP (XWINDOW (selected_window
)->buffer
))
5899 w
= XWINDOW (selected_window
);
5900 set_marker_both (w
->pointm
,
5902 BUF_PT (XBUFFER (w
->buffer
)),
5903 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5906 windows_or_buffers_changed
++;
5907 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5909 /* Problem: Freeing all matrices and later allocating them again
5910 is a serious redisplay flickering problem. What we would
5911 really like to do is to free only those matrices not reused
5913 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5915 = (struct window
**) alloca (count_windows (root_window
)
5916 * sizeof (struct window
*));
5917 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5919 /* Temporarily avoid any problems with windows that are smaller
5920 than they are supposed to be. */
5921 window_min_height
= 1;
5922 window_min_width
= 1;
5925 Mark all windows now on frame as "deleted".
5926 Restoring the new configuration "undeletes" any that are in it.
5928 Save their current buffers in their height fields, since we may
5929 need it later, if a buffer saved in the configuration is now
5931 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5933 for (k
= 0; k
< saved_windows
->size
; k
++)
5935 p
= SAVED_WINDOW_N (saved_windows
, k
);
5936 w
= XWINDOW (p
->window
);
5939 if (!NILP (p
->parent
))
5940 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5941 XFASTINT (p
->parent
))->window
;
5945 if (!NILP (p
->prev
))
5947 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5948 XFASTINT (p
->prev
))->window
;
5949 XWINDOW (w
->prev
)->next
= p
->window
;
5954 if (!NILP (w
->parent
))
5956 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5958 XWINDOW (w
->parent
)->vchild
= p
->window
;
5959 XWINDOW (w
->parent
)->hchild
= Qnil
;
5963 XWINDOW (w
->parent
)->hchild
= p
->window
;
5964 XWINDOW (w
->parent
)->vchild
= Qnil
;
5969 /* If we squirreled away the buffer in the window's height,
5971 if (BUFFERP (w
->total_lines
))
5972 w
->buffer
= w
->total_lines
;
5973 w
->left_col
= p
->left_col
;
5974 w
->top_line
= p
->top_line
;
5975 w
->total_cols
= p
->total_cols
;
5976 w
->total_lines
= p
->total_lines
;
5977 w
->hscroll
= p
->hscroll
;
5978 w
->min_hscroll
= p
->min_hscroll
;
5979 w
->display_table
= p
->display_table
;
5980 w
->orig_top_line
= p
->orig_top_line
;
5981 w
->orig_total_lines
= p
->orig_total_lines
;
5982 w
->left_margin_cols
= p
->left_margin_cols
;
5983 w
->right_margin_cols
= p
->right_margin_cols
;
5984 w
->left_fringe_width
= p
->left_fringe_width
;
5985 w
->right_fringe_width
= p
->right_fringe_width
;
5986 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5987 w
->scroll_bar_width
= p
->scroll_bar_width
;
5988 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5989 XSETFASTINT (w
->last_modified
, 0);
5990 XSETFASTINT (w
->last_overlay_modified
, 0);
5992 /* Reinstall the saved buffer and pointers into it. */
5993 if (NILP (p
->buffer
))
5994 w
->buffer
= p
->buffer
;
5997 if (!NILP (XBUFFER (p
->buffer
)->name
))
5998 /* If saved buffer is alive, install it. */
6000 w
->buffer
= p
->buffer
;
6001 w
->start_at_line_beg
= p
->start_at_line_beg
;
6002 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6003 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6004 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6005 p
->mark
, w
->buffer
);
6007 /* As documented in Fcurrent_window_configuration, don't
6008 restore the location of point in the buffer which was
6009 current when the window configuration was recorded. */
6010 if (!EQ (p
->buffer
, new_current_buffer
)
6011 && XBUFFER (p
->buffer
) == current_buffer
)
6012 Fgoto_char (w
->pointm
);
6014 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6015 /* Else unless window has a live buffer, get one. */
6017 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6018 /* This will set the markers to beginning of visible
6020 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6021 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6022 w
->start_at_line_beg
= Qt
;
6025 /* Keeping window's old buffer; make sure the markers
6028 /* Set window markers at start of visible range. */
6029 if (XMARKER (w
->start
)->buffer
== 0)
6030 set_marker_restricted (w
->start
, make_number (0),
6032 if (XMARKER (w
->pointm
)->buffer
== 0)
6033 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6034 BUF_PT (XBUFFER (w
->buffer
)),
6035 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6036 w
->start_at_line_beg
= Qt
;
6041 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6042 /* Prevent "swapping out point" in the old selected window
6043 using the buffer that has been restored into it.
6044 We already swapped out point that from that window's old buffer. */
6045 selected_window
= Qnil
;
6047 /* Arrange *not* to restore point in the buffer that was
6048 current when the window configuration was saved. */
6049 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6050 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6051 make_number (old_point
),
6052 XWINDOW (data
->current_window
)->buffer
);
6054 Fselect_window (data
->current_window
, Qnil
);
6055 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6058 if (NILP (data
->focus_frame
)
6059 || (FRAMEP (data
->focus_frame
)
6060 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6061 Fredirect_frame_focus (frame
, data
->focus_frame
);
6063 #if 0 /* I don't understand why this is needed, and it causes problems
6064 when the frame's old selected window has been deleted. */
6065 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6066 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6070 /* Set the screen height to the value it had before this function. */
6071 if (previous_frame_lines
!= FRAME_LINES (f
)
6072 || previous_frame_cols
!= FRAME_COLS (f
))
6073 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6075 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6076 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6077 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6079 #ifdef HAVE_WINDOW_SYSTEM
6080 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6081 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6086 /* Now, free glyph matrices in windows that were not reused. */
6087 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6089 if (NILP (leaf_windows
[i
]->buffer
))
6091 /* Assert it's not reused as a combination. */
6092 xassert (NILP (leaf_windows
[i
]->hchild
)
6093 && NILP (leaf_windows
[i
]->vchild
));
6094 free_window_matrices (leaf_windows
[i
]);
6096 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6104 /* Fselect_window will have made f the selected frame, so we
6105 reselect the proper frame here. Fhandle_switch_frame will change the
6106 selected window too, but that doesn't make the call to
6107 Fselect_window above totally superfluous; it still sets f's
6109 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6110 do_switch_frame (data
->selected_frame
, 0, 0);
6112 if (! NILP (Vwindow_configuration_change_hook
)
6113 && ! NILP (Vrun_hooks
))
6114 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6117 if (!NILP (new_current_buffer
))
6118 Fset_buffer (new_current_buffer
);
6120 /* Restore the minimum heights recorded in the configuration. */
6121 window_min_height
= XINT (data
->min_height
);
6122 window_min_width
= XINT (data
->min_width
);
6124 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6125 minibuf_selected_window
= data
->minibuf_selected_window
;
6127 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6130 /* Mark all windows now on frame as deleted
6131 by setting their buffers to nil. */
6134 delete_all_subwindows (w
)
6135 register struct window
*w
;
6137 if (!NILP (w
->next
))
6138 delete_all_subwindows (XWINDOW (w
->next
));
6139 if (!NILP (w
->vchild
))
6140 delete_all_subwindows (XWINDOW (w
->vchild
));
6141 if (!NILP (w
->hchild
))
6142 delete_all_subwindows (XWINDOW (w
->hchild
));
6144 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6146 if (!NILP (w
->buffer
))
6149 /* We set all three of these fields to nil, to make sure that we can
6150 distinguish this dead window from any live window. Live leaf
6151 windows will have buffer set, and combination windows will have
6152 vchild or hchild set. */
6157 Vwindow_list
= Qnil
;
6161 count_windows (window
)
6162 register struct window
*window
;
6164 register int count
= 1;
6165 if (!NILP (window
->next
))
6166 count
+= count_windows (XWINDOW (window
->next
));
6167 if (!NILP (window
->vchild
))
6168 count
+= count_windows (XWINDOW (window
->vchild
));
6169 if (!NILP (window
->hchild
))
6170 count
+= count_windows (XWINDOW (window
->hchild
));
6175 /* Fill vector FLAT with leaf windows under W, starting at index I.
6176 Value is last index + 1. */
6179 get_leaf_windows (w
, flat
, i
)
6181 struct window
**flat
;
6186 if (!NILP (w
->hchild
))
6187 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6188 else if (!NILP (w
->vchild
))
6189 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6193 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6200 /* Return a pointer to the glyph W's physical cursor is on. Value is
6201 null if W's current matrix is invalid, so that no meaningfull glyph
6205 get_phys_cursor_glyph (w
)
6208 struct glyph_row
*row
;
6209 struct glyph
*glyph
;
6211 if (w
->phys_cursor
.vpos
>= 0
6212 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6213 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6215 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6216 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6225 save_window_save (window
, vector
, i
)
6227 struct Lisp_Vector
*vector
;
6230 register struct saved_window
*p
;
6231 register struct window
*w
;
6232 register Lisp_Object tem
;
6234 for (;!NILP (window
); window
= w
->next
)
6236 p
= SAVED_WINDOW_N (vector
, i
);
6237 w
= XWINDOW (window
);
6239 XSETFASTINT (w
->temslot
, i
); i
++;
6241 p
->buffer
= w
->buffer
;
6242 p
->left_col
= w
->left_col
;
6243 p
->top_line
= w
->top_line
;
6244 p
->total_cols
= w
->total_cols
;
6245 p
->total_lines
= w
->total_lines
;
6246 p
->hscroll
= w
->hscroll
;
6247 p
->min_hscroll
= w
->min_hscroll
;
6248 p
->display_table
= w
->display_table
;
6249 p
->orig_top_line
= w
->orig_top_line
;
6250 p
->orig_total_lines
= w
->orig_total_lines
;
6251 p
->left_margin_cols
= w
->left_margin_cols
;
6252 p
->right_margin_cols
= w
->right_margin_cols
;
6253 p
->left_fringe_width
= w
->left_fringe_width
;
6254 p
->right_fringe_width
= w
->right_fringe_width
;
6255 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6256 p
->scroll_bar_width
= w
->scroll_bar_width
;
6257 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6258 if (!NILP (w
->buffer
))
6260 /* Save w's value of point in the window configuration.
6261 If w is the selected window, then get the value of point
6262 from the buffer; pointm is garbage in the selected window. */
6263 if (EQ (window
, selected_window
))
6265 p
->pointm
= Fmake_marker ();
6266 set_marker_both (p
->pointm
, w
->buffer
,
6267 BUF_PT (XBUFFER (w
->buffer
)),
6268 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6271 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6273 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6274 p
->start_at_line_beg
= w
->start_at_line_beg
;
6276 tem
= XBUFFER (w
->buffer
)->mark
;
6277 p
->mark
= Fcopy_marker (tem
, Qnil
);
6284 p
->start_at_line_beg
= Qnil
;
6287 if (NILP (w
->parent
))
6290 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6295 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6297 if (!NILP (w
->vchild
))
6298 i
= save_window_save (w
->vchild
, vector
, i
);
6299 if (!NILP (w
->hchild
))
6300 i
= save_window_save (w
->hchild
, vector
, i
);
6306 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6307 Scurrent_window_configuration
, 0, 1, 0,
6308 doc
: /* Return an object representing the current window configuration of FRAME.
6309 If FRAME is nil or omitted, use the selected frame.
6310 This describes the number of windows, their sizes and current buffers,
6311 and for each displayed buffer, where display starts, and the positions of
6312 point and mark. An exception is made for point in the current buffer:
6313 its value is -not- saved.
6314 This also records the currently selected frame, and FRAME's focus
6315 redirection (see `redirect-frame-focus'). */)
6319 register Lisp_Object tem
;
6320 register int n_windows
;
6321 register struct save_window_data
*data
;
6322 register struct Lisp_Vector
*vec
;
6327 frame
= selected_frame
;
6328 CHECK_LIVE_FRAME (frame
);
6331 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6332 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6333 data
= (struct save_window_data
*)vec
;
6335 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6336 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6337 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6338 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6339 data
->selected_frame
= selected_frame
;
6340 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6341 XSETBUFFER (data
->current_buffer
, current_buffer
);
6342 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6343 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6344 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6345 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6346 XSETINT (data
->min_height
, window_min_height
);
6347 XSETINT (data
->min_width
, window_min_width
);
6348 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6349 data
->saved_windows
= tem
;
6350 for (i
= 0; i
< n_windows
; i
++)
6351 XVECTOR (tem
)->contents
[i
]
6352 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6353 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6354 XSETWINDOW_CONFIGURATION (tem
, data
);
6358 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6360 doc
: /* Execute BODY, preserving window sizes and contents.
6361 Return the value of the last form in BODY.
6362 Restore which buffer appears in which window, where display starts,
6363 and the value of point and mark for each window.
6364 Also restore the choice of selected window.
6365 Also restore which buffer is current.
6366 Does not restore the value of point in current buffer.
6367 usage: (save-window-excursion BODY ...) */)
6371 register Lisp_Object val
;
6372 register int count
= SPECPDL_INDEX ();
6374 record_unwind_protect (Fset_window_configuration
,
6375 Fcurrent_window_configuration (Qnil
));
6376 val
= Fprogn (args
);
6377 return unbind_to (count
, val
);
6382 /***********************************************************************
6384 ***********************************************************************/
6390 Lisp_Object tail
= Qnil
;
6391 Lisp_Object result
= Qnil
;
6398 if (!NILP (w
->hchild
))
6399 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6400 window_tree (XWINDOW (w
->hchild
))));
6401 else if (!NILP (w
->vchild
))
6402 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6403 window_tree (XWINDOW (w
->vchild
))));
6407 result
= tail
= Fcons (wn
, Qnil
);
6411 XSETCDR (tail
, Fcons (wn
, Qnil
));
6415 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6423 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6425 doc
: /* Return the window tree for frame FRAME.
6427 The return value is a list of the form (ROOT MINI), where ROOT
6428 represents the window tree of the frame's root window, and MINI
6429 is the frame's minibuffer window.
6431 If the root window is not split, ROOT is the root window itself.
6432 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6433 horizontal split, and t for a vertical split, EDGES gives the combined
6434 size and position of the subwindows in the split, and the rest of the
6435 elements are the subwindows in the split. Each of the subwindows may
6436 again be a window or a list representing a window split, and so on.
6437 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6439 If FRAME is nil or omitted, return information on the currently
6447 frame
= selected_frame
;
6449 CHECK_FRAME (frame
);
6452 if (!FRAME_LIVE_P (f
))
6455 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6459 /***********************************************************************
6461 ***********************************************************************/
6463 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6465 doc
: /* Set width of marginal areas of window WINDOW.
6466 If WINDOW is nil, set margins of the currently selected window.
6467 Second arg LEFT-WIDTH specifies the number of character cells to
6468 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6469 does the same for the right marginal area. A nil width parameter
6470 means no margin. */)
6471 (window
, left_width
, right_width
)
6472 Lisp_Object window
, left_width
, right_width
;
6474 struct window
*w
= decode_window (window
);
6476 /* Translate negative or zero widths to nil.
6477 Margins that are too wide have to be checked elsewhere. */
6479 if (!NILP (left_width
))
6481 CHECK_NUMBER (left_width
);
6482 if (XINT (left_width
) <= 0)
6486 if (!NILP (right_width
))
6488 CHECK_NUMBER (right_width
);
6489 if (XINT (right_width
) <= 0)
6493 if (!EQ (w
->left_margin_cols
, left_width
)
6494 || !EQ (w
->right_margin_cols
, right_width
))
6496 w
->left_margin_cols
= left_width
;
6497 w
->right_margin_cols
= right_width
;
6499 adjust_window_margins (w
);
6501 ++windows_or_buffers_changed
;
6502 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6509 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6511 doc
: /* Get width of marginal areas of window WINDOW.
6512 If WINDOW is omitted or nil, use the currently selected window.
6513 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6514 If a marginal area does not exist, its width will be returned
6519 struct window
*w
= decode_window (window
);
6520 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6525 /***********************************************************************
6527 ***********************************************************************/
6529 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6531 doc
: /* Set the fringe widths of window WINDOW.
6532 If WINDOW is nil, set the fringe widths of the currently selected
6534 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6535 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6536 fringe width. If a fringe width arg is nil, that means to use the
6537 frame's default fringe width. Default fringe widths can be set with
6538 the command `set-fringe-style'.
6539 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6540 outside of the display margins. By default, fringes are drawn between
6541 display marginal areas and the text area. */)
6542 (window
, left_width
, right_width
, outside_margins
)
6543 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6545 struct window
*w
= decode_window (window
);
6547 if (!NILP (left_width
))
6548 CHECK_NATNUM (left_width
);
6549 if (!NILP (right_width
))
6550 CHECK_NATNUM (right_width
);
6552 if (!EQ (w
->left_fringe_width
, left_width
)
6553 || !EQ (w
->right_fringe_width
, right_width
)
6554 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6556 w
->left_fringe_width
= left_width
;
6557 w
->right_fringe_width
= right_width
;
6558 w
->fringes_outside_margins
= outside_margins
;
6560 adjust_window_margins (w
);
6562 clear_glyph_matrix (w
->current_matrix
);
6563 w
->window_end_valid
= Qnil
;
6565 ++windows_or_buffers_changed
;
6566 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6573 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6575 doc
: /* Get width of fringes of window WINDOW.
6576 If WINDOW is omitted or nil, use the currently selected window.
6577 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6581 struct window
*w
= decode_window (window
);
6582 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6583 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6584 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6585 Qt
: Qnil
), Qnil
)));
6590 /***********************************************************************
6592 ***********************************************************************/
6594 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6596 doc
: /* Set width and type of scroll bars of window WINDOW.
6597 If window is nil, set scroll bars of the currently selected window.
6598 Second parameter WIDTH specifies the pixel width for the scroll bar;
6599 this is automatically adjusted to a multiple of the frame column width.
6600 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6601 bar: left, right, or nil.
6602 If WIDTH is nil, use the frame's scroll-bar width.
6603 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6604 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6605 (window
, width
, vertical_type
, horizontal_type
)
6606 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6608 struct window
*w
= decode_window (window
);
6612 CHECK_NATNUM (width
);
6614 if (XINT (width
) == 0)
6615 vertical_type
= Qnil
;
6618 if (!(EQ (vertical_type
, Qnil
)
6619 || EQ (vertical_type
, Qleft
)
6620 || EQ (vertical_type
, Qright
)
6621 || EQ (vertical_type
, Qt
)))
6622 error ("Invalid type of vertical scroll bar");
6624 if (!EQ (w
->scroll_bar_width
, width
)
6625 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6627 w
->scroll_bar_width
= width
;
6628 w
->vertical_scroll_bar_type
= vertical_type
;
6630 adjust_window_margins (w
);
6632 clear_glyph_matrix (w
->current_matrix
);
6633 w
->window_end_valid
= Qnil
;
6635 ++windows_or_buffers_changed
;
6636 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6643 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6645 doc
: /* Get width and type of scroll bars of window WINDOW.
6646 If WINDOW is omitted or nil, use the currently selected window.
6647 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6648 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6653 struct window
*w
= decode_window (window
);
6654 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6655 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6656 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6657 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6658 Fcons (w
->vertical_scroll_bar_type
,
6659 Fcons (Qnil
, Qnil
))));
6664 /***********************************************************************
6666 ***********************************************************************/
6668 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6669 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6670 Use the selected window if WINDOW is nil or omitted.
6671 Normally, value is a multiple of the canonical character height of WINDOW;
6672 optional second arg PIXELS-P means value is measured in pixels. */)
6674 Lisp_Object window
, pixels_p
;
6681 window
= selected_window
;
6683 CHECK_WINDOW (window
);
6684 w
= XWINDOW (window
);
6685 f
= XFRAME (w
->frame
);
6687 if (FRAME_WINDOW_P (f
))
6688 result
= (NILP (pixels_p
)
6689 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6690 : make_number (-w
->vscroll
));
6692 result
= make_number (0);
6697 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6699 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6700 WINDOW nil means use the selected window. Normally, VSCROLL is a
6701 non-negative multiple of the canonical character height of WINDOW;
6702 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6703 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6704 corresponds to an integral number of pixels. The return value is the
6705 result of this rounding.
6706 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6707 (window
, vscroll
, pixels_p
)
6708 Lisp_Object window
, vscroll
, pixels_p
;
6714 window
= selected_window
;
6716 CHECK_WINDOW (window
);
6717 CHECK_NUMBER_OR_FLOAT (vscroll
);
6719 w
= XWINDOW (window
);
6720 f
= XFRAME (w
->frame
);
6722 if (FRAME_WINDOW_P (f
))
6724 int old_dy
= w
->vscroll
;
6726 w
->vscroll
= - (NILP (pixels_p
)
6727 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6728 : XFLOATINT (vscroll
));
6729 w
->vscroll
= min (w
->vscroll
, 0);
6731 if (w
->vscroll
!= old_dy
)
6733 /* Adjust glyph matrix of the frame if the virtual display
6734 area becomes larger than before. */
6735 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6738 /* Prevent redisplay shortcuts. */
6739 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6743 return Fwindow_vscroll (window
, pixels_p
);
6747 /* Call FN for all leaf windows on frame F. FN is called with the
6748 first argument being a pointer to the leaf window, and with
6749 additional argument USER_DATA. Stops when FN returns 0. */
6752 foreach_window (f
, fn
, user_data
)
6754 int (* fn
) P_ ((struct window
*, void *));
6757 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6761 /* Helper function for foreach_window. Call FN for all leaf windows
6762 reachable from W. FN is called with the first argument being a
6763 pointer to the leaf window, and with additional argument USER_DATA.
6764 Stop when FN returns 0. Value is 0 if stopped by FN. */
6767 foreach_window_1 (w
, fn
, user_data
)
6769 int (* fn
) P_ ((struct window
*, void *));
6774 for (cont
= 1; w
&& cont
;)
6776 if (!NILP (w
->hchild
))
6777 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6778 else if (!NILP (w
->vchild
))
6779 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6781 cont
= fn (w
, user_data
);
6783 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6790 /* Freeze or unfreeze the window start of W unless it is a
6791 mini-window or the selected window. FREEZE_P non-null means freeze
6792 the window start. */
6795 freeze_window_start (w
, freeze_p
)
6799 if (w
== XWINDOW (selected_window
)
6800 || MINI_WINDOW_P (w
)
6801 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6802 && ! NILP (Vminibuf_scroll_window
)
6803 && w
== XWINDOW (Vminibuf_scroll_window
)))
6806 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6811 /* Freeze or unfreeze the window starts of all leaf windows on frame
6812 F, except the selected window and a mini-window. FREEZE_P non-zero
6813 means freeze the window start. */
6816 freeze_window_starts (f
, freeze_p
)
6820 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6824 /***********************************************************************
6826 ***********************************************************************/
6828 /* Return 1 if window configurations C1 and C2
6829 describe the same state of affairs. This is used by Fequal. */
6832 compare_window_configurations (c1
, c2
, ignore_positions
)
6834 int ignore_positions
;
6836 register struct save_window_data
*d1
, *d2
;
6837 struct Lisp_Vector
*sw1
, *sw2
;
6840 if (!WINDOW_CONFIGURATIONP (c1
))
6841 wrong_type_argument (Qwindow_configuration_p
, c1
);
6842 if (!WINDOW_CONFIGURATIONP (c2
))
6843 wrong_type_argument (Qwindow_configuration_p
, c2
);
6845 d1
= (struct save_window_data
*) XVECTOR (c1
);
6846 d2
= (struct save_window_data
*) XVECTOR (c2
);
6847 sw1
= XVECTOR (d1
->saved_windows
);
6848 sw2
= XVECTOR (d2
->saved_windows
);
6850 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6852 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6854 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6856 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6858 /* Don't compare the current_window field directly.
6859 Instead see w1_is_current and w2_is_current, below. */
6860 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6862 if (! ignore_positions
)
6864 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6866 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6869 /* Don't compare the root_window field.
6870 We don't require the two configurations
6871 to use the same window object,
6872 and the two root windows must be equivalent
6873 if everything else compares equal. */
6874 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6876 if (! EQ (d1
->min_width
, d2
->min_width
))
6878 if (! EQ (d1
->min_height
, d2
->min_height
))
6881 /* Verify that the two confis have the same number of windows. */
6882 if (sw1
->size
!= sw2
->size
)
6885 for (i
= 0; i
< sw1
->size
; i
++)
6887 struct saved_window
*p1
, *p2
;
6888 int w1_is_current
, w2_is_current
;
6890 p1
= SAVED_WINDOW_N (sw1
, i
);
6891 p2
= SAVED_WINDOW_N (sw2
, i
);
6893 /* Verify that the current windows in the two
6894 configurations correspond to each other. */
6895 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6896 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6898 if (w1_is_current
!= w2_is_current
)
6901 /* Verify that the corresponding windows do match. */
6902 if (! EQ (p1
->buffer
, p2
->buffer
))
6904 if (! EQ (p1
->left_col
, p2
->left_col
))
6906 if (! EQ (p1
->top_line
, p2
->top_line
))
6908 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6910 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6912 if (! EQ (p1
->display_table
, p2
->display_table
))
6914 if (! EQ (p1
->parent
, p2
->parent
))
6916 if (! EQ (p1
->prev
, p2
->prev
))
6918 if (! ignore_positions
)
6920 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6922 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6924 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6926 if (NILP (Fequal (p1
->start
, p2
->start
)))
6928 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6930 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6933 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6935 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6937 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6939 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6941 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6943 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6945 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6952 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6953 Scompare_window_configurations
, 2, 2, 0,
6954 doc
: /* Compare two window configurations as regards the structure of windows.
6955 This function ignores details such as the values of point and mark
6956 and scrolling positions. */)
6960 if (compare_window_configurations (x
, y
, 1))
6968 struct frame
*f
= make_terminal_frame ();
6969 XSETFRAME (selected_frame
, f
);
6970 Vterminal_frame
= selected_frame
;
6971 minibuf_window
= f
->minibuffer_window
;
6972 selected_window
= f
->selected_window
;
6973 last_nonminibuf_frame
= f
;
6975 window_initialized
= 1;
6981 Vwindow_list
= Qnil
;
6987 Qwindow_size_fixed
= intern ("window-size-fixed");
6988 staticpro (&Qwindow_size_fixed
);
6989 Fset (Qwindow_size_fixed
, Qnil
);
6991 staticpro (&Qwindow_configuration_change_hook
);
6992 Qwindow_configuration_change_hook
6993 = intern ("window-configuration-change-hook");
6995 Qwindowp
= intern ("windowp");
6996 staticpro (&Qwindowp
);
6998 Qwindow_configuration_p
= intern ("window-configuration-p");
6999 staticpro (&Qwindow_configuration_p
);
7001 Qwindow_live_p
= intern ("window-live-p");
7002 staticpro (&Qwindow_live_p
);
7004 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7005 staticpro (&Qtemp_buffer_show_hook
);
7007 staticpro (&Vwindow_list
);
7009 minibuf_selected_window
= Qnil
;
7010 staticpro (&minibuf_selected_window
);
7012 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7013 doc
: /* Non-nil means call as function to display a help buffer.
7014 The function is called with one argument, the buffer to be displayed.
7015 Used by `with-output-to-temp-buffer'.
7016 If this function is used, then it must do the entire job of showing
7017 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7018 Vtemp_buffer_show_function
= Qnil
;
7020 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7021 doc
: /* If non-nil, function to call to handle `display-buffer'.
7022 It will receive two args, the buffer and a flag which if non-nil means
7023 that the currently selected window is not acceptable.
7024 It should choose or create a window, display the specified buffer in it,
7025 and return the window.
7026 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7027 work using this function. */);
7028 Vdisplay_buffer_function
= Qnil
;
7030 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7031 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7032 If nil, `display-buffer' will leave the window configuration alone. */);
7033 Veven_window_heights
= Qt
;
7035 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7036 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7037 Vminibuf_scroll_window
= Qnil
;
7039 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7040 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7041 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7042 is displayed in the `mode-line' face. */);
7043 mode_line_in_non_selected_windows
= 1;
7045 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7046 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7047 Vother_window_scroll_buffer
= Qnil
;
7049 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7050 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7053 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7054 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7055 auto_window_vscroll_p
= 1;
7057 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7058 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7059 If the buffer in question is already displayed in a frame, raise that frame. */);
7060 display_buffer_reuse_frames
= 0;
7062 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7063 doc
: /* Function to call to handle automatic new frame creation.
7064 It is called with no arguments and should return a newly created frame.
7066 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7067 where `pop-up-frame-alist' would hold the default frame parameters. */);
7068 Vpop_up_frame_function
= Qnil
;
7070 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7071 doc
: /* *List of buffer names that should have their own special frames.
7072 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7073 if its name is in this list, makes a special frame for it
7074 using `special-display-function'. See also `special-display-regexps'.
7076 An element of the list can be a list instead of just a string.
7077 There are two ways to use a list as an element:
7078 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7079 In the first case, the FRAME-PARAMETERS are pairs of the form
7080 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7081 In the second case, FUNCTION is called with BUFFER as the first argument,
7082 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7083 All this is done by the function found in `special-display-function'.
7085 If the specified frame parameters include (same-buffer . t), the
7086 buffer is displayed in the currently selected window. Otherwise, if
7087 they include (same-frame . t), the buffer is displayed in a new window
7088 in the currently selected frame.
7090 If this variable appears \"not to work\", because you add a name to it
7091 but that buffer still appears in the selected window, look at the
7092 values of `same-window-buffer-names' and `same-window-regexps'.
7093 Those variables take precedence over this one. */);
7094 Vspecial_display_buffer_names
= Qnil
;
7096 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7097 doc
: /* *List of regexps saying which buffers should have their own special frames.
7098 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7099 if any regexp in this list matches the buffer name, it makes a
7100 special frame for the buffer by calling `special-display-function'.
7102 An element of the list can be a list instead of just a string.
7103 There are two ways to use a list as an element:
7104 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7105 In the first case, the FRAME-PARAMETERS are pairs of the form
7106 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7107 In the second case, FUNCTION is called with BUFFER as the first argument,
7108 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7109 All this is done by the function found in `special-display-function'.
7111 If the specified frame parameters include (same-buffer . t), the
7112 buffer is displayed in the currently selected window. Otherwise, if
7113 they include (same-frame . t), the buffer is displayed in a new window
7114 in the currently selected frame.
7116 If this variable appears \"not to work\", because you add a regexp to it
7117 but the matching buffers still appear in the selected window, look at the
7118 values of `same-window-buffer-names' and `same-window-regexps'.
7119 Those variables take precedence over this one. */);
7120 Vspecial_display_regexps
= Qnil
;
7122 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7123 doc
: /* Function to call to make a new frame for a special buffer.
7124 It is called with two arguments, the buffer and optional buffer specific
7125 data, and should return a window displaying that buffer.
7126 The default value normally makes a separate frame for the buffer,
7127 using `special-display-frame-alist' to specify the frame parameters.
7128 But if the buffer specific data includes (same-buffer . t) then the
7129 buffer is displayed in the current selected window.
7130 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7131 a new window in the currently selected frame.
7133 A buffer is special if it is listed in `special-display-buffer-names'
7134 or matches a regexp in `special-display-regexps'. */);
7135 Vspecial_display_function
= Qnil
;
7137 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7138 doc
: /* *List of buffer names that should appear in the selected window.
7139 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7140 switches to it in the selected window, rather than making it appear
7141 in some other window.
7143 An element of the list can be a cons cell instead of just a string.
7144 Then the car must be a string, which specifies the buffer name.
7145 This is for compatibility with `special-display-buffer-names';
7146 the cdr of the cons cell is ignored.
7148 See also `same-window-regexps'. */);
7149 Vsame_window_buffer_names
= Qnil
;
7151 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7152 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7153 If a buffer name matches one of these regexps, then displaying it
7154 using `display-buffer' or `pop-to-buffer' switches to it
7155 in the selected window, rather than making it appear in some other window.
7157 An element of the list can be a cons cell instead of just a string.
7158 Then the car must be a string, which specifies the buffer name.
7159 This is for compatibility with `special-display-buffer-names';
7160 the cdr of the cons cell is ignored.
7162 See also `same-window-buffer-names'. */);
7163 Vsame_window_regexps
= Qnil
;
7165 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7166 doc
: /* *Non-nil means display-buffer should make new windows. */);
7169 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7170 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7171 next_screen_context_lines
= 2;
7173 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7174 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
7175 If there is only one window, it is split regardless of this value. */);
7176 split_height_threshold
= 500;
7178 DEFVAR_INT ("window-min-height", &window_min_height
,
7179 doc
: /* *Delete any window less than this tall (including its mode line). */);
7180 window_min_height
= 4;
7182 DEFVAR_INT ("window-min-width", &window_min_width
,
7183 doc
: /* *Delete any window less than this wide. */);
7184 window_min_width
= 10;
7186 DEFVAR_LISP ("scroll-preserve-screen-position",
7187 &Vscroll_preserve_screen_position
,
7188 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7189 A value of nil means point does not keep its screen position except
7190 at the scroll margin or window boundary respectively.
7191 A value of t means point keeps its screen position if the scroll
7192 command moved it vertically out of the window, e.g. when scrolling
7194 Any other value means point always keeps its screen position. */);
7195 Vscroll_preserve_screen_position
= Qnil
;
7197 DEFVAR_LISP ("window-configuration-change-hook",
7198 &Vwindow_configuration_change_hook
,
7199 doc
: /* Functions to call when window configuration changes.
7200 The selected frame is the one whose configuration has changed. */);
7201 Vwindow_configuration_change_hook
= Qnil
;
7203 defsubr (&Sselected_window
);
7204 defsubr (&Sminibuffer_window
);
7205 defsubr (&Swindow_minibuffer_p
);
7206 defsubr (&Swindowp
);
7207 defsubr (&Swindow_live_p
);
7208 defsubr (&Spos_visible_in_window_p
);
7209 defsubr (&Swindow_buffer
);
7210 defsubr (&Swindow_height
);
7211 defsubr (&Swindow_width
);
7212 defsubr (&Swindow_hscroll
);
7213 defsubr (&Sset_window_hscroll
);
7214 defsubr (&Swindow_redisplay_end_trigger
);
7215 defsubr (&Sset_window_redisplay_end_trigger
);
7216 defsubr (&Swindow_edges
);
7217 defsubr (&Swindow_pixel_edges
);
7218 defsubr (&Swindow_inside_edges
);
7219 defsubr (&Swindow_inside_pixel_edges
);
7220 defsubr (&Scoordinates_in_window_p
);
7221 defsubr (&Swindow_at
);
7222 defsubr (&Swindow_point
);
7223 defsubr (&Swindow_start
);
7224 defsubr (&Swindow_end
);
7225 defsubr (&Sset_window_point
);
7226 defsubr (&Sset_window_start
);
7227 defsubr (&Swindow_dedicated_p
);
7228 defsubr (&Sset_window_dedicated_p
);
7229 defsubr (&Swindow_display_table
);
7230 defsubr (&Sset_window_display_table
);
7231 defsubr (&Snext_window
);
7232 defsubr (&Sprevious_window
);
7233 defsubr (&Sother_window
);
7234 defsubr (&Sget_lru_window
);
7235 defsubr (&Sget_largest_window
);
7236 defsubr (&Sget_buffer_window
);
7237 defsubr (&Sdelete_other_windows
);
7238 defsubr (&Sdelete_windows_on
);
7239 defsubr (&Sreplace_buffer_in_windows
);
7240 defsubr (&Sdelete_window
);
7241 defsubr (&Sset_window_buffer
);
7242 defsubr (&Sselect_window
);
7243 defsubr (&Sspecial_display_p
);
7244 defsubr (&Ssame_window_p
);
7245 defsubr (&Sdisplay_buffer
);
7246 defsubr (&Sforce_window_update
);
7247 defsubr (&Ssplit_window
);
7248 defsubr (&Senlarge_window
);
7249 defsubr (&Sshrink_window
);
7250 defsubr (&Sadjust_window_trailing_edge
);
7251 defsubr (&Sscroll_up
);
7252 defsubr (&Sscroll_down
);
7253 defsubr (&Sscroll_left
);
7254 defsubr (&Sscroll_right
);
7255 defsubr (&Sother_window_for_scrolling
);
7256 defsubr (&Sscroll_other_window
);
7257 defsubr (&Sminibuffer_selected_window
);
7258 defsubr (&Srecenter
);
7259 defsubr (&Swindow_text_height
);
7260 defsubr (&Smove_to_window_line
);
7261 defsubr (&Swindow_configuration_p
);
7262 defsubr (&Swindow_configuration_frame
);
7263 defsubr (&Sset_window_configuration
);
7264 defsubr (&Scurrent_window_configuration
);
7265 defsubr (&Ssave_window_excursion
);
7266 defsubr (&Swindow_tree
);
7267 defsubr (&Sset_window_margins
);
7268 defsubr (&Swindow_margins
);
7269 defsubr (&Sset_window_fringes
);
7270 defsubr (&Swindow_fringes
);
7271 defsubr (&Sset_window_scroll_bars
);
7272 defsubr (&Swindow_scroll_bars
);
7273 defsubr (&Swindow_vscroll
);
7274 defsubr (&Sset_window_vscroll
);
7275 defsubr (&Scompare_window_configurations
);
7276 defsubr (&Swindow_list
);
7282 initial_define_key (control_x_map
, '1', "delete-other-windows");
7283 initial_define_key (control_x_map
, '2', "split-window");
7284 initial_define_key (control_x_map
, '0', "delete-window");
7285 initial_define_key (control_x_map
, 'o', "other-window");
7286 initial_define_key (control_x_map
, '^', "enlarge-window");
7287 initial_define_key (control_x_map
, '<', "scroll-left");
7288 initial_define_key (control_x_map
, '>', "scroll-right");
7290 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7291 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7292 initial_define_key (meta_map
, 'v', "scroll-down");
7294 initial_define_key (global_map
, Ctl('L'), "recenter");
7295 initial_define_key (meta_map
, 'r', "move-to-window-line");
7298 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7299 (do not change this comment) */