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 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, 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
= CDR (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 (!EQ (Vtemp_buffer_show_function
, Qnil
))
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, 3, "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.
3890 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3891 of the siblings above or to the left of the selected window. Only
3892 siblings to the right or below are changed. */)
3893 (arg
, horizontal
, preserve_before
)
3894 register Lisp_Object arg
, horizontal
, preserve_before
;
3897 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
),
3898 !NILP (preserve_before
));
3900 if (! NILP (Vwindow_configuration_change_hook
))
3901 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3906 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3907 doc
: /* Make current window ARG lines smaller.
3908 From program, optional second arg non-nil means shrink sideways arg columns.
3909 Interactively, if an argument is not given, make the window one line smaller.
3911 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3912 of the siblings above or to the left of the selected window. Only
3913 siblings to the right or below are changed. */)
3914 (arg
, side
, preserve_before
)
3915 register Lisp_Object arg
, side
, preserve_before
;
3918 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3919 !NILP (preserve_before
));
3921 if (! NILP (Vwindow_configuration_change_hook
))
3922 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3928 window_height (window
)
3931 register struct window
*p
= XWINDOW (window
);
3932 return WINDOW_TOTAL_LINES (p
);
3936 window_width (window
)
3939 register struct window
*p
= XWINDOW (window
);
3940 return WINDOW_TOTAL_COLS (p
);
3945 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3947 #define CURSIZE(w) \
3948 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3951 /* Enlarge WINDOW by DELTA.
3952 HORIZ_FLAG nonzero means enlarge it horizontally;
3953 zero means do it vertically.
3955 Siblings of the selected window are resized to fulfill the size
3956 request. If they become too small in the process, they will be
3959 If PRESERVE_BEFORE is nonzero, that means don't alter
3960 the siblings to the left or above WINDOW. */
3963 enlarge_window (window
, delta
, horiz_flag
, preserve_before
)
3965 int delta
, horiz_flag
, preserve_before
;
3967 Lisp_Object parent
, next
, prev
;
3971 int (*sizefun
) P_ ((Lisp_Object
))
3972 = horiz_flag
? window_width
: window_height
;
3973 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3974 = (horiz_flag
? set_window_width
: set_window_height
);
3976 /* Check values of window_min_width and window_min_height for
3978 check_min_window_sizes ();
3980 /* Give up if this window cannot be resized. */
3981 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
3982 error ("Window is not resizable");
3984 /* Find the parent of the selected window. */
3987 p
= XWINDOW (window
);
3993 error ("No other window to side of this one");
3998 ? !NILP (XWINDOW (parent
)->hchild
)
3999 : !NILP (XWINDOW (parent
)->vchild
))
4005 sizep
= &CURSIZE (window
);
4008 register int maxdelta
;
4010 /* Compute the maximum size increment this window can have. */
4012 if (preserve_before
)
4016 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
4017 /* Subtract size of siblings before, since we can't take that. */
4018 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
4021 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4022 - window_min_size (XWINDOW (p
->next
),
4027 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4028 /* This is a main window followed by a minibuffer. */
4029 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4030 - window_min_size (XWINDOW (p
->next
),
4032 /* This is a minibuffer following a main window. */
4033 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4034 - window_min_size (XWINDOW (p
->prev
),
4036 /* This is a frame with only one window, a minibuffer-only
4037 or a minibufferless frame. */
4040 if (delta
> maxdelta
)
4041 /* This case traps trying to make the minibuffer
4042 the full frame, or make the only window aside from the
4043 minibuffer the full frame. */
4047 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4049 delete_window (window
);
4056 /* Find the total we can get from other siblings without deleting them. */
4058 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4059 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4061 if (! preserve_before
)
4062 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4063 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4066 /* If we can get it all from them without deleting them, do so. */
4067 if (delta
<= maximum
)
4069 Lisp_Object first_unaffected
;
4070 Lisp_Object first_affected
;
4075 first_affected
= window
;
4076 /* Look at one sibling at a time,
4077 moving away from this window in both directions alternately,
4078 and take as much as we can get without deleting that sibling. */
4080 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
4084 int this_one
= ((*sizefun
) (next
)
4085 - window_min_size (XWINDOW (next
),
4086 horiz_flag
, 0, &fixed_p
));
4089 if (this_one
> delta
)
4092 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4093 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4098 next
= XWINDOW (next
)->next
;
4104 if (!preserve_before
&& ! NILP (prev
))
4106 int this_one
= ((*sizefun
) (prev
)
4107 - window_min_size (XWINDOW (prev
),
4108 horiz_flag
, 0, &fixed_p
));
4111 if (this_one
> delta
)
4114 first_affected
= prev
;
4116 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4117 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4122 prev
= XWINDOW (prev
)->prev
;
4126 xassert (delta
== 0);
4128 /* Now recalculate the edge positions of all the windows affected,
4129 based on the new sizes. */
4130 first_unaffected
= next
;
4131 prev
= first_affected
;
4132 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4133 prev
= next
, next
= XWINDOW (next
)->next
)
4135 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4136 /* This does not change size of NEXT,
4137 but it propagates the new top edge to its children */
4138 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4143 register int delta1
;
4144 register int opht
= (*sizefun
) (parent
);
4146 if (opht
<= XINT (*sizep
) + delta
)
4148 /* If trying to grow this window to or beyond size of the parent,
4149 just delete all the sibling windows. */
4150 Lisp_Object start
, tem
, next
;
4152 start
= XWINDOW (parent
)->vchild
;
4154 start
= XWINDOW (parent
)->hchild
;
4156 /* Delete any siblings that come after WINDOW. */
4157 tem
= XWINDOW (window
)->next
;
4158 while (! NILP (tem
))
4160 next
= XWINDOW (tem
)->next
;
4161 delete_window (tem
);
4165 /* Delete any siblings that come after WINDOW.
4166 Note that if START is not WINDOW, then WINDOW still
4167 Fhas siblings, so WINDOW has not yet replaced its parent. */
4169 while (! EQ (tem
, window
))
4171 next
= XWINDOW (tem
)->next
;
4172 delete_window (tem
);
4178 /* Otherwise, make delta1 just right so that if we add
4179 delta1 lines to this window and to the parent, and then
4180 shrink the parent back to its original size, the new
4181 proportional size of this window will increase by delta.
4183 The function size_window will compute the new height h'
4184 of the window from delta1 as:
4187 x = delta1 - delta1/n * n for the 1st resizable child
4190 where n is the number of children that can be resized.
4191 We can ignore x by choosing a delta1 that is a multiple of
4192 n. We want the height of this window to come out as
4202 The number of children n equals the number of resizable
4203 children of this window + 1 because we know window itself
4204 is resizable (otherwise we would have signalled an error). */
4206 struct window
*w
= XWINDOW (window
);
4210 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4211 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4213 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4214 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4219 /* Add delta1 lines or columns to this window, and to the parent,
4220 keeping things consistent while not affecting siblings. */
4221 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4222 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4224 /* Squeeze out delta1 lines or columns from our parent,
4225 shriking this window and siblings proportionately.
4226 This brings parent back to correct size.
4227 Delta1 was calculated so this makes this window the desired size,
4228 taking it all out of the siblings. */
4229 (*setsizefun
) (parent
, opht
, 0);
4234 XSETFASTINT (p
->last_modified
, 0);
4235 XSETFASTINT (p
->last_overlay_modified
, 0);
4237 /* Adjust glyph matrices. */
4238 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4242 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4243 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4244 zero means adjust the height, moving the bottom edge.
4246 Following siblings of the selected window are resized to fulfill
4247 the size request. If they become too small in the process, they
4248 are not deleted; instead, we signal an error. */
4251 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4253 int delta
, horiz_flag
;
4255 Lisp_Object parent
, child
;
4257 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4258 int delcount
= window_deletion_count
;
4260 /* Check values of window_min_width and window_min_height for
4262 check_min_window_sizes ();
4265 window
= Fselected_window ();
4267 CHECK_WINDOW (window
);
4269 /* Give up if this window cannot be resized. */
4270 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4271 error ("Window is not resizable");
4275 p
= XWINDOW (window
);
4278 /* Make sure there is a following window. */
4281 : NILP (XWINDOW (window
)->next
)))
4283 Fset_window_configuration (old_config
);
4284 error ("No other window following this one");
4287 /* Don't make this window too small. */
4288 if (XINT (CURSIZE (window
)) + delta
4289 < (horiz_flag
? window_min_width
: window_min_height
))
4291 Fset_window_configuration (old_config
);
4292 error ("Cannot adjust window size as specified");
4295 /* Clear out some redisplay caches. */
4296 XSETFASTINT (p
->last_modified
, 0);
4297 XSETFASTINT (p
->last_overlay_modified
, 0);
4299 /* Adjust this window's edge. */
4300 XSETINT (CURSIZE (window
),
4301 XINT (CURSIZE (window
)) + delta
);
4303 /* If this window has following siblings in the desired dimension,
4305 (If we reach the top of the tree and can never do this,
4306 we will fail and report an error, above.) */
4308 ? !NILP (XWINDOW (parent
)->hchild
)
4309 : !NILP (XWINDOW (parent
)->vchild
))
4311 if (!NILP (XWINDOW (window
)->next
))
4313 XSETINT (CURBEG (p
->next
),
4314 XINT (CURBEG (p
->next
)) + delta
);
4315 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4321 /* Here we have a chain of parallel siblings, in the other dimension.
4322 Change the size of the other siblings. */
4323 for (child
= (horiz_flag
4324 ? XWINDOW (parent
)->vchild
4325 : XWINDOW (parent
)->hchild
);
4327 child
= XWINDOW (child
)->next
)
4328 if (! EQ (child
, window
))
4329 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4335 /* If we made a window so small it got deleted,
4336 we failed. Report failure. */
4337 if (delcount
!= window_deletion_count
)
4339 Fset_window_configuration (old_config
);
4340 error ("Cannot adjust window size as specified");
4343 /* Adjust glyph matrices. */
4344 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4350 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4351 Sadjust_window_trailing_edge
, 3, 3, 0,
4352 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4353 If HORIZ_FLAG is t, that means adjust the width, moving the right edge.
4354 Otherwise, adjust the height, moving the bottom edge.
4356 Following siblings of the selected window are resized to fulfill
4357 the size request. If they become too small in the process, they
4358 are not deleted; instead, we signal an error. */)
4359 (window
, delta
, horizontal
)
4360 Lisp_Object window
, delta
, horizontal
;
4362 CHECK_NUMBER (delta
);
4363 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4365 if (! NILP (Vwindow_configuration_change_hook
))
4366 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4373 /***********************************************************************
4374 Resizing Mini-Windows
4375 ***********************************************************************/
4377 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4379 enum save_restore_action
4386 static int save_restore_orig_size
P_ ((struct window
*,
4387 enum save_restore_action
));
4389 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4390 from lowest windows first. */
4393 shrink_window_lowest_first (w
, height
)
4401 xassert (!MINI_WINDOW_P (w
));
4403 /* Set redisplay hints. */
4404 XSETFASTINT (w
->last_modified
, 0);
4405 XSETFASTINT (w
->last_overlay_modified
, 0);
4406 windows_or_buffers_changed
++;
4407 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4409 old_height
= XFASTINT (w
->total_lines
);
4410 XSETFASTINT (w
->total_lines
, height
);
4412 if (!NILP (w
->hchild
))
4414 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4416 c
= XWINDOW (child
);
4417 c
->top_line
= w
->top_line
;
4418 shrink_window_lowest_first (c
, height
);
4421 else if (!NILP (w
->vchild
))
4423 Lisp_Object last_child
;
4424 int delta
= old_height
- height
;
4429 /* Find the last child. We are taking space from lowest windows
4430 first, so we iterate over children from the last child
4432 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4435 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4436 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4440 c
= XWINDOW (child
);
4441 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4443 if (this_one
> delta
)
4446 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4450 /* Compute new positions. */
4451 last_top
= XINT (w
->top_line
);
4452 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4454 c
= XWINDOW (child
);
4455 c
->top_line
= make_number (last_top
);
4456 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4457 last_top
+= XFASTINT (c
->total_lines
);
4463 /* Save, restore, or check positions and sizes in the window tree
4464 rooted at W. ACTION says what to do.
4466 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4467 orig_total_lines members are valid for all windows in the window
4468 tree. Value is non-zero if they are valid.
4470 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4471 orig_top_line and orig_total_lines for all windows in the tree.
4473 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4474 stored in orig_top_line and orig_total_lines for all windows. */
4477 save_restore_orig_size (w
, action
)
4479 enum save_restore_action action
;
4485 if (!NILP (w
->hchild
))
4487 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4490 else if (!NILP (w
->vchild
))
4492 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4498 case CHECK_ORIG_SIZES
:
4499 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4503 case SAVE_ORIG_SIZES
:
4504 w
->orig_top_line
= w
->top_line
;
4505 w
->orig_total_lines
= w
->total_lines
;
4506 XSETFASTINT (w
->last_modified
, 0);
4507 XSETFASTINT (w
->last_overlay_modified
, 0);
4510 case RESTORE_ORIG_SIZES
:
4511 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4512 w
->top_line
= w
->orig_top_line
;
4513 w
->total_lines
= w
->orig_total_lines
;
4514 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4515 XSETFASTINT (w
->last_modified
, 0);
4516 XSETFASTINT (w
->last_overlay_modified
, 0);
4523 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4530 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4531 without deleting other windows. */
4534 grow_mini_window (w
, delta
)
4538 struct frame
*f
= XFRAME (w
->frame
);
4539 struct window
*root
;
4541 xassert (MINI_WINDOW_P (w
));
4542 xassert (delta
>= 0);
4544 /* Check values of window_min_width and window_min_height for
4546 check_min_window_sizes ();
4548 /* Compute how much we can enlarge the mini-window without deleting
4550 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4553 int min_height
= window_min_size (root
, 0, 0, 0);
4554 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4555 /* Note that the root window may already be smaller than
4557 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4562 /* Save original window sizes and positions, if not already done. */
4563 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4564 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4566 /* Shrink other windows. */
4567 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4569 /* Grow the mini-window. */
4570 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4571 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4572 XSETFASTINT (w
->last_modified
, 0);
4573 XSETFASTINT (w
->last_overlay_modified
, 0);
4580 /* Shrink mini-window W. If there is recorded info about window sizes
4581 before a call to grow_mini_window, restore recorded window sizes.
4582 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4586 shrink_mini_window (w
)
4589 struct frame
*f
= XFRAME (w
->frame
);
4590 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4592 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4594 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4596 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4597 windows_or_buffers_changed
= 1;
4599 else if (XFASTINT (w
->total_lines
) > 1)
4601 /* Distribute the additional lines of the mini-window
4602 among the other windows. */
4604 XSETWINDOW (window
, w
);
4605 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0, 0);
4611 /* Mark window cursors off for all windows in the window tree rooted
4612 at W by setting their phys_cursor_on_p flag to zero. Called from
4613 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4614 the frame are cleared. */
4617 mark_window_cursors_off (w
)
4622 if (!NILP (w
->hchild
))
4623 mark_window_cursors_off (XWINDOW (w
->hchild
));
4624 else if (!NILP (w
->vchild
))
4625 mark_window_cursors_off (XWINDOW (w
->vchild
));
4627 w
->phys_cursor_on_p
= 0;
4629 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4634 /* Return number of lines of text (not counting mode lines) in W. */
4637 window_internal_height (w
)
4640 int ht
= XFASTINT (w
->total_lines
);
4642 if (!MINI_WINDOW_P (w
))
4644 if (!NILP (w
->parent
)
4645 || !NILP (w
->vchild
)
4646 || !NILP (w
->hchild
)
4649 || WINDOW_WANTS_MODELINE_P (w
))
4652 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4660 /* Return the number of columns in W.
4661 Don't count columns occupied by scroll bars or the vertical bar
4662 separating W from the sibling to its right. */
4665 window_box_text_cols (w
)
4668 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4669 int width
= XINT (w
->total_cols
);
4671 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4672 /* Scroll bars occupy a few columns. */
4673 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4674 else if (!FRAME_WINDOW_P (f
)
4675 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4676 /* The column of `|' characters separating side-by-side windows
4677 occupies one column only. */
4680 if (FRAME_WINDOW_P (f
))
4681 /* On window-systems, fringes and display margins cannot be
4682 used for normal text. */
4683 width
-= (WINDOW_FRINGE_COLS (w
)
4684 + WINDOW_LEFT_MARGIN_COLS (w
)
4685 + WINDOW_RIGHT_MARGIN_COLS (w
));
4691 /************************************************************************
4693 ***********************************************************************/
4695 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4696 N screen-fulls, which is defined as the height of the window minus
4697 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4698 instead. Negative values of N mean scroll down. NOERROR non-zero
4699 means don't signal an error if we try to move over BEGV or ZV,
4703 window_scroll (window
, n
, whole
, noerror
)
4711 /* If we must, use the pixel-based version which is much slower than
4712 the line-based one but can handle varying line heights. */
4713 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4714 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4716 window_scroll_line_based (window
, n
, whole
, noerror
);
4722 /* Implementation of window_scroll that works based on pixel line
4723 heights. See the comment of window_scroll for parameter
4727 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4734 struct window
*w
= XWINDOW (window
);
4735 struct text_pos start
;
4737 int this_scroll_margin
;
4739 /* True if we fiddled the window vscroll field without really scrolling. */
4742 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4744 /* If PT is not visible in WINDOW, move back one half of
4745 the screen. Allow PT to be partially visible, otherwise
4746 something like (scroll-down 1) with PT in the line before
4747 the partially visible one would recenter. */
4748 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4751 /* Move backward half the height of the window. Performance note:
4752 vmotion used here is about 10% faster, but would give wrong
4753 results for variable height lines. */
4754 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4755 it
.current_y
= it
.last_visible_y
;
4756 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4758 /* The function move_iterator_vertically may move over more than
4759 the specified y-distance. If it->w is small, e.g. a
4760 mini-buffer window, we may end up in front of the window's
4761 display area. This is the case when Start displaying at the
4762 start of the line containing PT in this case. */
4763 if (it
.current_y
<= 0)
4765 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4766 move_it_vertically_backward (&it
, 0);
4770 start
= it
.current
.pos
;
4772 else if (auto_window_vscroll_p
)
4774 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4777 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4779 dy
= max ((window_box_height (w
)
4780 - next_screen_context_lines
* dy
),
4784 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4786 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4787 Fset_window_vscroll (window
, make_number (px
), Qt
);
4790 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4792 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4793 Fset_window_vscroll (window
, make_number (px
), Qt
);
4797 Fset_window_vscroll (window
, make_number (0), Qt
);
4800 /* If scroll_preserve_screen_position is non-nil, we try to set
4801 point in the same window line as it is now, so get that line. */
4802 if (!NILP (Vscroll_preserve_screen_position
))
4804 start_display (&it
, w
, start
);
4805 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4806 preserve_y
= it
.current_y
;
4811 /* Move iterator it from start the specified distance forward or
4812 backward. The result is the new window start. */
4813 start_display (&it
, w
, start
);
4816 int start_pos
= IT_CHARPOS (it
);
4817 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4818 dy
= max ((window_box_height (w
)
4819 - next_screen_context_lines
* dy
),
4822 /* Note that move_it_vertically always moves the iterator to the
4823 start of a line. So, if the last line doesn't have a newline,
4824 we would end up at the start of the line ending at ZV. */
4827 move_it_vertically_backward (&it
, -dy
);
4828 /* Ensure we actually does move, e.g. in case we are currently
4829 looking at an image that is taller that the window height. */
4830 while (start_pos
== IT_CHARPOS (it
)
4831 && start_pos
> BEGV
)
4832 move_it_by_lines (&it
, -1, 1);
4836 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4837 MOVE_TO_POS
| MOVE_TO_Y
);
4838 /* Ensure we actually does move, e.g. in case we are currently
4839 looking at an image that is taller that the window height. */
4840 while (start_pos
== IT_CHARPOS (it
)
4842 move_it_by_lines (&it
, 1, 1);
4846 move_it_by_lines (&it
, n
, 1);
4848 /* We failed if we find ZV is already on the screen (scrolling up,
4849 means there's nothing past the end), or if we can't start any
4850 earlier (scrolling down, means there's nothing past the top). */
4851 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4852 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4854 if (IT_CHARPOS (it
) == ZV
)
4856 if (it
.current_y
< it
.last_visible_y
4857 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4858 >= it
.last_visible_y
))
4860 /* The last line was only partially visible, make it fully
4862 w
->vscroll
= (it
.last_visible_y
4863 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4864 adjust_glyphs (it
.f
);
4869 Fsignal (Qend_of_buffer
, Qnil
);
4873 if (w
->vscroll
!= 0)
4874 /* The first line was only partially visible, make it fully
4880 Fsignal (Qbeginning_of_buffer
, Qnil
);
4883 /* If control gets here, then we vscrolled. */
4885 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4887 /* Don't try to change the window start below. */
4893 int pos
= IT_CHARPOS (it
);
4896 /* If in the middle of a multi-glyph character move forward to
4897 the next character. */
4898 if (in_display_vector_p (&it
))
4901 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4904 /* Set the window start, and set up the window for redisplay. */
4905 set_marker_restricted (w
->start
, make_number (pos
),
4907 bytepos
= XMARKER (w
->start
)->bytepos
;
4908 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4910 w
->update_mode_line
= Qt
;
4911 XSETFASTINT (w
->last_modified
, 0);
4912 XSETFASTINT (w
->last_overlay_modified
, 0);
4913 /* Set force_start so that redisplay_window will run the
4914 window-scroll-functions. */
4915 w
->force_start
= Qt
;
4918 /* The rest of this function uses current_y in a nonstandard way,
4919 not including the height of the header line if any. */
4920 it
.current_y
= it
.vpos
= 0;
4922 /* Move PT out of scroll margins.
4923 This code wants current_y to be zero at the window start position
4924 even if there is a header line. */
4925 this_scroll_margin
= max (0, scroll_margin
);
4926 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4927 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4931 /* We moved the window start towards ZV, so PT may be now
4932 in the scroll margin at the top. */
4933 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4934 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4935 && (NILP (Vscroll_preserve_screen_position
)
4936 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4937 /* We found PT at a legitimate height. Leave it alone. */
4939 else if (preserve_y
>= 0)
4941 /* If we have a header line, take account of it.
4942 This is necessary because we set it.current_y to 0, above. */
4943 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4944 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4946 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4947 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4951 while (it
.current_y
< this_scroll_margin
)
4953 int prev
= it
.current_y
;
4954 move_it_by_lines (&it
, 1, 1);
4955 if (prev
== it
.current_y
)
4958 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4963 int charpos
, bytepos
;
4966 /* Save our position, for the preserve_y case. */
4967 charpos
= IT_CHARPOS (it
);
4968 bytepos
= IT_BYTEPOS (it
);
4970 /* We moved the window start towards BEGV, so PT may be now
4971 in the scroll margin at the bottom. */
4972 move_it_to (&it
, PT
, -1,
4973 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4974 - this_scroll_margin
- 1),
4976 MOVE_TO_POS
| MOVE_TO_Y
);
4978 /* Save our position, in case it's correct. */
4979 charpos
= IT_CHARPOS (it
);
4980 bytepos
= IT_BYTEPOS (it
);
4982 /* See if point is on a partially visible line at the end. */
4983 if (it
.what
== IT_EOB
)
4984 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4987 move_it_by_lines (&it
, 1, 1);
4988 partial_p
= it
.current_y
> it
.last_visible_y
;
4991 if (charpos
== PT
&& !partial_p
4992 && (NILP (Vscroll_preserve_screen_position
)
4993 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4994 /* We found PT before we found the display margin, so PT is ok. */
4996 else if (preserve_y
>= 0)
4998 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4999 start_display (&it
, w
, start
);
5000 #if 0 /* It's wrong to subtract this here
5001 because we called start_display again
5002 and did not alter it.current_y this time. */
5004 /* If we have a header line, take account of it. */
5005 if (WINDOW_WANTS_HEADER_LINE_P (w
))
5006 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
5009 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
5010 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5015 /* The last line was only partially visible, so back up two
5016 lines to make sure we're on a fully visible line. */
5018 move_it_by_lines (&it
, -2, 0);
5019 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5022 /* No, the position we saved is OK, so use it. */
5023 SET_PT_BOTH (charpos
, bytepos
);
5029 /* Implementation of window_scroll that works based on screen lines.
5030 See the comment of window_scroll for parameter descriptions. */
5033 window_scroll_line_based (window
, n
, whole
, noerror
)
5039 register struct window
*w
= XWINDOW (window
);
5040 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5041 register int pos
, pos_byte
;
5042 register int ht
= window_internal_height (w
);
5043 register Lisp_Object tem
;
5047 struct position posit
;
5050 /* If scrolling screen-fulls, compute the number of lines to
5051 scroll from the window's height. */
5053 n
*= max (1, ht
- next_screen_context_lines
);
5055 startpos
= marker_position (w
->start
);
5057 posit
= *compute_motion (startpos
, 0, 0, 0,
5059 -1, XINT (w
->hscroll
),
5061 original_vpos
= posit
.vpos
;
5063 XSETFASTINT (tem
, PT
);
5064 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5068 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5073 lose
= n
< 0 && PT
== BEGV
;
5074 Fvertical_motion (make_number (n
), window
);
5078 SET_PT_BOTH (opoint
, opoint_byte
);
5085 Fsignal (Qbeginning_of_buffer
, Qnil
);
5090 int this_scroll_margin
= scroll_margin
;
5092 /* Don't use a scroll margin that is negative or too large. */
5093 if (this_scroll_margin
< 0)
5094 this_scroll_margin
= 0;
5096 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5097 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5099 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5100 w
->start_at_line_beg
= bolp
;
5101 w
->update_mode_line
= Qt
;
5102 XSETFASTINT (w
->last_modified
, 0);
5103 XSETFASTINT (w
->last_overlay_modified
, 0);
5104 /* Set force_start so that redisplay_window will run
5105 the window-scroll-functions. */
5106 w
->force_start
= Qt
;
5108 if (!NILP (Vscroll_preserve_screen_position
)
5109 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5111 SET_PT_BOTH (pos
, pos_byte
);
5112 Fvertical_motion (make_number (original_vpos
), window
);
5114 /* If we scrolled forward, put point enough lines down
5115 that it is outside the scroll margin. */
5120 if (this_scroll_margin
> 0)
5122 SET_PT_BOTH (pos
, pos_byte
);
5123 Fvertical_motion (make_number (this_scroll_margin
), window
);
5129 if (top_margin
<= opoint
)
5130 SET_PT_BOTH (opoint
, opoint_byte
);
5131 else if (!NILP (Vscroll_preserve_screen_position
))
5133 SET_PT_BOTH (pos
, pos_byte
);
5134 Fvertical_motion (make_number (original_vpos
), window
);
5137 SET_PT (top_margin
);
5143 /* If we scrolled backward, put point near the end of the window
5144 but not within the scroll margin. */
5145 SET_PT_BOTH (pos
, pos_byte
);
5146 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5147 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5150 bottom_margin
= PT
+ 1;
5152 if (bottom_margin
> opoint
)
5153 SET_PT_BOTH (opoint
, opoint_byte
);
5156 if (!NILP (Vscroll_preserve_screen_position
))
5158 SET_PT_BOTH (pos
, pos_byte
);
5159 Fvertical_motion (make_number (original_vpos
), window
);
5162 Fvertical_motion (make_number (-1), window
);
5171 Fsignal (Qend_of_buffer
, Qnil
);
5176 /* Scroll selected_window up or down. If N is nil, scroll a
5177 screen-full which is defined as the height of the window minus
5178 next_screen_context_lines. If N is the symbol `-', scroll.
5179 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5180 up. This is the guts of Fscroll_up and Fscroll_down. */
5183 scroll_command (n
, direction
)
5187 int count
= SPECPDL_INDEX ();
5189 xassert (abs (direction
) == 1);
5191 /* If selected window's buffer isn't current, make it current for
5192 the moment. But don't screw up if window_scroll gets an error. */
5193 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5195 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5196 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5198 /* Make redisplay consider other windows than just selected_window. */
5199 ++windows_or_buffers_changed
;
5203 window_scroll (selected_window
, direction
, 1, 0);
5204 else if (EQ (n
, Qminus
))
5205 window_scroll (selected_window
, -direction
, 1, 0);
5208 n
= Fprefix_numeric_value (n
);
5209 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5212 unbind_to (count
, Qnil
);
5215 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5216 doc
: /* Scroll text of current window upward ARG lines.
5217 If ARG is omitted or nil, scroll upward by a near full screen.
5218 A near full screen is `next-screen-context-lines' less than a full screen.
5219 Negative ARG means scroll downward.
5220 If ARG is the atom `-', scroll downward by nearly full screen.
5221 When calling from a program, supply as argument a number, nil, or `-'. */)
5225 scroll_command (arg
, 1);
5229 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5230 doc
: /* Scroll text of current window down ARG lines.
5231 If ARG is omitted or nil, scroll down by a near full screen.
5232 A near full screen is `next-screen-context-lines' less than a full screen.
5233 Negative ARG means scroll upward.
5234 If ARG is the atom `-', scroll upward by nearly full screen.
5235 When calling from a program, supply as argument a number, nil, or `-'. */)
5239 scroll_command (arg
, -1);
5243 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5244 doc
: /* Return the other window for \"other window scroll\" commands.
5245 If `other-window-scroll-buffer' is non-nil, a window
5246 showing that buffer is used.
5247 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5248 specifies the window. This takes precedence over
5249 `other-window-scroll-buffer'. */)
5254 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5255 && !NILP (Vminibuf_scroll_window
))
5256 window
= Vminibuf_scroll_window
;
5257 /* If buffer is specified, scroll that buffer. */
5258 else if (!NILP (Vother_window_scroll_buffer
))
5260 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5262 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5266 /* Nothing specified; look for a neighboring window on the same
5268 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5270 if (EQ (window
, selected_window
))
5271 /* That didn't get us anywhere; look for a window on another
5274 window
= Fnext_window (window
, Qnil
, Qt
);
5275 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5276 && ! EQ (window
, selected_window
));
5279 CHECK_LIVE_WINDOW (window
);
5281 if (EQ (window
, selected_window
))
5282 error ("There is no other window");
5287 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5288 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5289 A near full screen is `next-screen-context-lines' less than a full screen.
5290 The next window is the one below the current one; or the one at the top
5291 if the current one is at the bottom. Negative ARG means scroll downward.
5292 If ARG is the atom `-', scroll downward by nearly full screen.
5293 When calling from a program, supply as argument a number, nil, or `-'.
5295 If `other-window-scroll-buffer' is non-nil, scroll the window
5296 showing that buffer, popping the buffer up if necessary.
5297 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5298 specifies the window to scroll. This takes precedence over
5299 `other-window-scroll-buffer'. */)
5305 int count
= SPECPDL_INDEX ();
5307 window
= Fother_window_for_scrolling ();
5308 w
= XWINDOW (window
);
5310 /* Don't screw up if window_scroll gets an error. */
5311 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5312 ++windows_or_buffers_changed
;
5314 Fset_buffer (w
->buffer
);
5315 SET_PT (marker_position (w
->pointm
));
5318 window_scroll (window
, 1, 1, 1);
5319 else if (EQ (arg
, Qminus
))
5320 window_scroll (window
, -1, 1, 1);
5326 window_scroll (window
, XINT (arg
), 0, 1);
5329 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5330 unbind_to (count
, Qnil
);
5335 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5336 doc
: /* Scroll selected window display ARG columns left.
5337 Default for ARG is window width minus 2.
5338 Value is the total amount of leftward horizontal scrolling in
5339 effect after the change.
5340 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5341 lower bound for automatic scrolling, i.e. automatic scrolling
5342 will not scroll a window to a column less than the value returned
5343 by this function. This happens in an interactive call. */)
5345 register Lisp_Object arg
, set_minimum
;
5349 struct window
*w
= XWINDOW (selected_window
);
5352 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5354 arg
= Fprefix_numeric_value (arg
);
5356 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5357 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5359 if (!NILP (set_minimum
))
5360 w
->min_hscroll
= w
->hscroll
;
5365 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5366 doc
: /* Scroll selected window display ARG columns right.
5367 Default for ARG is window width minus 2.
5368 Value is the total amount of leftward horizontal scrolling in
5369 effect after the change.
5370 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5371 lower bound for automatic scrolling, i.e. automatic scrolling
5372 will not scroll a window to a column less than the value returned
5373 by this function. This happens in an interactive call. */)
5375 register Lisp_Object arg
, set_minimum
;
5379 struct window
*w
= XWINDOW (selected_window
);
5382 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5384 arg
= Fprefix_numeric_value (arg
);
5386 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5387 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5389 if (!NILP (set_minimum
))
5390 w
->min_hscroll
= w
->hscroll
;
5395 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5396 doc
: /* Return the window which was selected when entering the minibuffer.
5397 Returns nil, if current window is not a minibuffer window. */)
5400 if (minibuf_level
> 0
5401 && MINI_WINDOW_P (XWINDOW (selected_window
))
5402 && WINDOW_LIVE_P (minibuf_selected_window
))
5403 return minibuf_selected_window
;
5408 /* Value is the number of lines actually displayed in window W,
5409 as opposed to its height. */
5412 displayed_window_lines (w
)
5416 struct text_pos start
;
5417 int height
= window_box_height (w
);
5418 struct buffer
*old_buffer
;
5421 if (XBUFFER (w
->buffer
) != current_buffer
)
5423 old_buffer
= current_buffer
;
5424 set_buffer_internal (XBUFFER (w
->buffer
));
5429 /* In case W->start is out of the accessible range, do something
5430 reasonable. This happens in Info mode when Info-scroll-down
5431 calls (recenter -1) while W->start is 1. */
5432 if (XMARKER (w
->start
)->charpos
< BEGV
)
5433 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5434 else if (XMARKER (w
->start
)->charpos
> ZV
)
5435 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5437 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5439 start_display (&it
, w
, start
);
5440 move_it_vertically (&it
, height
);
5441 bottom_y
= line_bottom_y (&it
);
5443 /* rms: On a non-window display,
5444 the value of it.vpos at the bottom of the screen
5445 seems to be 1 larger than window_box_height (w).
5446 This kludge fixes a bug whereby (move-to-window-line -1)
5447 when ZV is on the last screen line
5448 moves to the previous screen line instead of the last one. */
5449 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5452 /* Add in empty lines at the bottom of the window. */
5453 if (bottom_y
< height
)
5455 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5456 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5460 set_buffer_internal (old_buffer
);
5466 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5467 doc
: /* Center point in window and redisplay frame.
5468 With prefix argument ARG, recenter putting point on screen line ARG
5469 relative to the current window. If ARG is negative, it counts up from the
5470 bottom of the window. (ARG should be less than the height of the window.)
5472 If ARG is omitted or nil, erase the entire frame and then
5473 redraw with point in the center of the current window.
5474 Just C-u as prefix means put point in the center of the window
5475 and redisplay normally--don't erase and redraw the frame. */)
5477 register Lisp_Object arg
;
5479 struct window
*w
= XWINDOW (selected_window
);
5480 struct buffer
*buf
= XBUFFER (w
->buffer
);
5481 struct buffer
*obuf
= current_buffer
;
5483 int charpos
, bytepos
;
5485 int this_scroll_margin
;
5487 /* If redisplay is suppressed due to an error, try again. */
5488 obuf
->display_error_modiff
= 0;
5494 /* Invalidate pixel data calculated for all compositions. */
5495 for (i
= 0; i
< n_compositions
; i
++)
5496 composition_table
[i
]->font
= NULL
;
5498 Fredraw_frame (w
->frame
);
5499 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5502 else if (CONSP (arg
)) /* Just C-u. */
5506 arg
= Fprefix_numeric_value (arg
);
5511 set_buffer_internal (buf
);
5513 /* Do this after making BUF current
5514 in case scroll_margin is buffer-local. */
5515 this_scroll_margin
= max (0, scroll_margin
);
5516 this_scroll_margin
= min (this_scroll_margin
,
5517 XFASTINT (w
->total_lines
) / 4);
5519 /* Handle centering on a graphical frame specially. Such frames can
5520 have variable-height lines and centering point on the basis of
5521 line counts would lead to strange effects. */
5522 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5529 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5530 start_display (&it
, w
, pt
);
5531 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5532 charpos
= IT_CHARPOS (it
);
5533 bytepos
= IT_BYTEPOS (it
);
5540 int extra_line_spacing
;
5541 int h
= window_box_height (w
);
5543 iarg
= - max (-iarg
, this_scroll_margin
);
5545 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5546 start_display (&it
, w
, pt
);
5548 /* Be sure we have the exact height of the full line containing PT. */
5549 move_it_by_lines (&it
, 0, 1);
5551 /* The amount of pixels we have to move back is the window
5552 height minus what's displayed in the line containing PT,
5553 and the lines below. */
5556 move_it_by_lines (&it
, nlines
, 1);
5558 if (it
.vpos
== nlines
)
5562 /* Last line has no newline */
5563 h
-= line_bottom_y (&it
);
5567 /* Don't reserve space for extra line spacing of last line. */
5568 extra_line_spacing
= it
.max_extra_line_spacing
;
5570 /* If we can't move down NLINES lines because we hit
5571 the end of the buffer, count in some empty lines. */
5572 if (it
.vpos
< nlines
)
5575 extra_line_spacing
= it
.extra_line_spacing
;
5576 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5581 /* Now find the new top line (starting position) of the window. */
5582 start_display (&it
, w
, pt
);
5584 move_it_vertically_backward (&it
, h
);
5586 /* If extra line spacing is present, we may move too far
5587 back. This causes the last line to be only partially
5588 visible (which triggers redisplay to recenter that line
5589 in the middle), so move forward.
5590 But ignore extra line spacing on last line, as it is not
5591 considered to be part of the visible height of the line.
5593 h
+= extra_line_spacing
;
5594 while (-it
.current_y
> h
)
5595 move_it_by_lines (&it
, 1, 1);
5597 charpos
= IT_CHARPOS (it
);
5598 bytepos
= IT_BYTEPOS (it
);
5602 struct position pos
;
5604 iarg
= max (iarg
, this_scroll_margin
);
5606 pos
= *vmotion (PT
, -iarg
, w
);
5607 charpos
= pos
.bufpos
;
5608 bytepos
= pos
.bytepos
;
5613 struct position pos
;
5614 int ht
= window_internal_height (w
);
5621 /* Don't let it get into the margin at either top or bottom. */
5622 iarg
= max (iarg
, this_scroll_margin
);
5623 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5625 pos
= *vmotion (PT
, - iarg
, w
);
5626 charpos
= pos
.bufpos
;
5627 bytepos
= pos
.bytepos
;
5630 /* Set the new window start. */
5631 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5632 w
->window_end_valid
= Qnil
;
5634 w
->optional_new_start
= Qt
;
5636 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5637 w
->start_at_line_beg
= Qt
;
5639 w
->start_at_line_beg
= Qnil
;
5641 set_buffer_internal (obuf
);
5646 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5648 doc
: /* Return the height in lines of the text display area of WINDOW.
5649 This doesn't include the mode-line (or header-line if any) or any
5650 partial-height lines in the text display area. */)
5654 struct window
*w
= decode_window (window
);
5655 int pixel_height
= window_box_height (w
);
5656 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5657 return make_number (line_height
);
5662 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5664 doc
: /* Position point relative to window.
5665 With no argument, position point at center of window.
5666 An argument specifies vertical position within the window;
5667 zero means top of window, negative means relative to bottom of window. */)
5671 struct window
*w
= XWINDOW (selected_window
);
5675 int this_scroll_margin
;
5678 window
= selected_window
;
5679 start
= marker_position (w
->start
);
5680 if (start
< BEGV
|| start
> ZV
)
5682 int height
= window_internal_height (w
);
5683 Fvertical_motion (make_number (- (height
/ 2)), window
);
5684 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5685 w
->start_at_line_beg
= Fbolp ();
5686 w
->force_start
= Qt
;
5689 Fgoto_char (w
->start
);
5691 lines
= displayed_window_lines (w
);
5694 this_scroll_margin
= max (0, scroll_margin
);
5695 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5699 XSETFASTINT (arg
, lines
/ 2);
5702 int iarg
= XINT (Fprefix_numeric_value (arg
));
5705 iarg
= iarg
+ lines
;
5707 #if 0 /* This code would prevent move-to-window-line from moving point
5708 to a place inside the scroll margins (which would cause the
5709 next redisplay to scroll). I wrote this code, but then concluded
5710 it is probably better not to install it. However, it is here
5711 inside #if 0 so as not to lose it. -- rms. */
5713 /* Don't let it get into the margin at either top or bottom. */
5714 iarg
= max (iarg
, this_scroll_margin
);
5715 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5718 arg
= make_number (iarg
);
5721 /* Skip past a partially visible first line. */
5723 XSETINT (arg
, XINT (arg
) + 1);
5725 return Fvertical_motion (arg
, window
);
5730 /***********************************************************************
5731 Window Configuration
5732 ***********************************************************************/
5734 struct save_window_data
5736 EMACS_INT size_from_Lisp_Vector_struct
;
5737 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5738 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5739 Lisp_Object frame_tool_bar_lines
;
5740 Lisp_Object selected_frame
;
5741 Lisp_Object current_window
;
5742 Lisp_Object current_buffer
;
5743 Lisp_Object minibuf_scroll_window
;
5744 Lisp_Object minibuf_selected_window
;
5745 Lisp_Object root_window
;
5746 Lisp_Object focus_frame
;
5747 /* Record the values of window-min-width and window-min-height
5748 so that window sizes remain consistent with them. */
5749 Lisp_Object min_width
, min_height
;
5750 /* A vector, each of whose elements is a struct saved_window
5752 Lisp_Object saved_windows
;
5755 /* This is saved as a Lisp_Vector */
5758 /* these first two must agree with struct Lisp_Vector in lisp.h */
5759 EMACS_INT size_from_Lisp_Vector_struct
;
5760 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5763 Lisp_Object buffer
, start
, pointm
, mark
;
5764 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5765 Lisp_Object hscroll
, min_hscroll
;
5766 Lisp_Object parent
, prev
;
5767 Lisp_Object start_at_line_beg
;
5768 Lisp_Object display_table
;
5769 Lisp_Object orig_top_line
, orig_total_lines
;
5770 Lisp_Object left_margin_cols
, right_margin_cols
;
5771 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5772 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5775 #define SAVED_WINDOW_N(swv,n) \
5776 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5778 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5779 doc
: /* Return t if OBJECT is a window-configuration object. */)
5783 if (WINDOW_CONFIGURATIONP (object
))
5788 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5789 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5793 register struct save_window_data
*data
;
5794 struct Lisp_Vector
*saved_windows
;
5796 if (! WINDOW_CONFIGURATIONP (config
))
5797 wrong_type_argument (Qwindow_configuration_p
, config
);
5799 data
= (struct save_window_data
*) XVECTOR (config
);
5800 saved_windows
= XVECTOR (data
->saved_windows
);
5801 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5804 DEFUN ("set-window-configuration", Fset_window_configuration
,
5805 Sset_window_configuration
, 1, 1, 0,
5806 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5807 CONFIGURATION must be a value previously returned
5808 by `current-window-configuration' (which see).
5809 If CONFIGURATION was made from a frame that is now deleted,
5810 only frame-independent values can be restored. In this case,
5811 the return value is nil. Otherwise the value is t. */)
5813 Lisp_Object configuration
;
5815 register struct save_window_data
*data
;
5816 struct Lisp_Vector
*saved_windows
;
5817 Lisp_Object new_current_buffer
;
5822 while (!WINDOW_CONFIGURATIONP (configuration
))
5823 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5825 data
= (struct save_window_data
*) XVECTOR (configuration
);
5826 saved_windows
= XVECTOR (data
->saved_windows
);
5828 new_current_buffer
= data
->current_buffer
;
5829 if (NILP (XBUFFER (new_current_buffer
)->name
))
5830 new_current_buffer
= Qnil
;
5833 if (XBUFFER (new_current_buffer
) == current_buffer
)
5836 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5837 point in new_current_buffer as of the last time this buffer was
5838 used. This can be non-deterministic since it can be changed by
5839 things like jit-lock by mere temporary selection of some random
5840 window that happens to show this buffer.
5841 So if possible we want this arbitrary choice of "which point" to
5842 be the one from the to-be-selected-window so as to prevent this
5843 window's cursor from being copied from another window. */
5844 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5845 /* If current_window = selected_window, its point is in BUF_PT. */
5846 && !EQ (selected_window
, data
->current_window
))
5847 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5849 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5852 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5855 /* If f is a dead frame, don't bother rebuilding its window tree.
5856 However, there is other stuff we should still try to do below. */
5857 if (FRAME_LIVE_P (f
))
5859 register struct window
*w
;
5860 register struct saved_window
*p
;
5861 struct window
*root_window
;
5862 struct window
**leaf_windows
;
5866 /* If the frame has been resized since this window configuration was
5867 made, we change the frame to the size specified in the
5868 configuration, restore the configuration, and then resize it
5869 back. We keep track of the prevailing height in these variables. */
5870 int previous_frame_lines
= FRAME_LINES (f
);
5871 int previous_frame_cols
= FRAME_COLS (f
);
5872 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5873 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5875 /* The mouse highlighting code could get screwed up
5876 if it runs during this. */
5879 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5880 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5881 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5882 XFASTINT (data
->frame_cols
), 0, 0, 0);
5883 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5884 if (XFASTINT (data
->frame_menu_bar_lines
)
5885 != previous_frame_menu_bar_lines
)
5886 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5887 #ifdef HAVE_WINDOW_SYSTEM
5888 if (XFASTINT (data
->frame_tool_bar_lines
)
5889 != previous_frame_tool_bar_lines
)
5890 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5894 /* "Swap out" point from the selected window's buffer
5895 into the window itself. (Normally the pointm of the selected
5896 window holds garbage.) We do this now, before
5897 restoring the window contents, and prevent it from
5898 being done later on when we select a new window. */
5899 if (! NILP (XWINDOW (selected_window
)->buffer
))
5901 w
= XWINDOW (selected_window
);
5902 set_marker_both (w
->pointm
,
5904 BUF_PT (XBUFFER (w
->buffer
)),
5905 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5908 windows_or_buffers_changed
++;
5909 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5911 /* Problem: Freeing all matrices and later allocating them again
5912 is a serious redisplay flickering problem. What we would
5913 really like to do is to free only those matrices not reused
5915 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5917 = (struct window
**) alloca (count_windows (root_window
)
5918 * sizeof (struct window
*));
5919 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5921 /* Temporarily avoid any problems with windows that are smaller
5922 than they are supposed to be. */
5923 window_min_height
= 1;
5924 window_min_width
= 1;
5927 Mark all windows now on frame as "deleted".
5928 Restoring the new configuration "undeletes" any that are in it.
5930 Save their current buffers in their height fields, since we may
5931 need it later, if a buffer saved in the configuration is now
5933 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5935 for (k
= 0; k
< saved_windows
->size
; k
++)
5937 p
= SAVED_WINDOW_N (saved_windows
, k
);
5938 w
= XWINDOW (p
->window
);
5941 if (!NILP (p
->parent
))
5942 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5943 XFASTINT (p
->parent
))->window
;
5947 if (!NILP (p
->prev
))
5949 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5950 XFASTINT (p
->prev
))->window
;
5951 XWINDOW (w
->prev
)->next
= p
->window
;
5956 if (!NILP (w
->parent
))
5958 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5960 XWINDOW (w
->parent
)->vchild
= p
->window
;
5961 XWINDOW (w
->parent
)->hchild
= Qnil
;
5965 XWINDOW (w
->parent
)->hchild
= p
->window
;
5966 XWINDOW (w
->parent
)->vchild
= Qnil
;
5971 /* If we squirreled away the buffer in the window's height,
5973 if (BUFFERP (w
->total_lines
))
5974 w
->buffer
= w
->total_lines
;
5975 w
->left_col
= p
->left_col
;
5976 w
->top_line
= p
->top_line
;
5977 w
->total_cols
= p
->total_cols
;
5978 w
->total_lines
= p
->total_lines
;
5979 w
->hscroll
= p
->hscroll
;
5980 w
->min_hscroll
= p
->min_hscroll
;
5981 w
->display_table
= p
->display_table
;
5982 w
->orig_top_line
= p
->orig_top_line
;
5983 w
->orig_total_lines
= p
->orig_total_lines
;
5984 w
->left_margin_cols
= p
->left_margin_cols
;
5985 w
->right_margin_cols
= p
->right_margin_cols
;
5986 w
->left_fringe_width
= p
->left_fringe_width
;
5987 w
->right_fringe_width
= p
->right_fringe_width
;
5988 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5989 w
->scroll_bar_width
= p
->scroll_bar_width
;
5990 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5991 XSETFASTINT (w
->last_modified
, 0);
5992 XSETFASTINT (w
->last_overlay_modified
, 0);
5994 /* Reinstall the saved buffer and pointers into it. */
5995 if (NILP (p
->buffer
))
5996 w
->buffer
= p
->buffer
;
5999 if (!NILP (XBUFFER (p
->buffer
)->name
))
6000 /* If saved buffer is alive, install it. */
6002 w
->buffer
= p
->buffer
;
6003 w
->start_at_line_beg
= p
->start_at_line_beg
;
6004 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6005 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6006 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6007 p
->mark
, w
->buffer
);
6009 /* As documented in Fcurrent_window_configuration, don't
6010 restore the location of point in the buffer which was
6011 current when the window configuration was recorded. */
6012 if (!EQ (p
->buffer
, new_current_buffer
)
6013 && XBUFFER (p
->buffer
) == current_buffer
)
6014 Fgoto_char (w
->pointm
);
6016 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6017 /* Else unless window has a live buffer, get one. */
6019 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6020 /* This will set the markers to beginning of visible
6022 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6023 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6024 w
->start_at_line_beg
= Qt
;
6027 /* Keeping window's old buffer; make sure the markers
6030 /* Set window markers at start of visible range. */
6031 if (XMARKER (w
->start
)->buffer
== 0)
6032 set_marker_restricted (w
->start
, make_number (0),
6034 if (XMARKER (w
->pointm
)->buffer
== 0)
6035 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6036 BUF_PT (XBUFFER (w
->buffer
)),
6037 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6038 w
->start_at_line_beg
= Qt
;
6043 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6044 /* Prevent "swapping out point" in the old selected window
6045 using the buffer that has been restored into it.
6046 We already swapped out point that from that window's old buffer. */
6047 selected_window
= Qnil
;
6049 /* Arrange *not* to restore point in the buffer that was
6050 current when the window configuration was saved. */
6051 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6052 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6053 make_number (old_point
),
6054 XWINDOW (data
->current_window
)->buffer
);
6056 Fselect_window (data
->current_window
, Qnil
);
6057 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6060 if (NILP (data
->focus_frame
)
6061 || (FRAMEP (data
->focus_frame
)
6062 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6063 Fredirect_frame_focus (frame
, data
->focus_frame
);
6065 #if 0 /* I don't understand why this is needed, and it causes problems
6066 when the frame's old selected window has been deleted. */
6067 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6068 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6072 /* Set the screen height to the value it had before this function. */
6073 if (previous_frame_lines
!= FRAME_LINES (f
)
6074 || previous_frame_cols
!= FRAME_COLS (f
))
6075 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6077 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6078 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6079 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6081 #ifdef HAVE_WINDOW_SYSTEM
6082 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6083 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6088 /* Now, free glyph matrices in windows that were not reused. */
6089 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6091 if (NILP (leaf_windows
[i
]->buffer
))
6093 /* Assert it's not reused as a combination. */
6094 xassert (NILP (leaf_windows
[i
]->hchild
)
6095 && NILP (leaf_windows
[i
]->vchild
));
6096 free_window_matrices (leaf_windows
[i
]);
6098 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6106 /* Fselect_window will have made f the selected frame, so we
6107 reselect the proper frame here. Fhandle_switch_frame will change the
6108 selected window too, but that doesn't make the call to
6109 Fselect_window above totally superfluous; it still sets f's
6111 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6112 do_switch_frame (data
->selected_frame
, 0, 0);
6114 if (! NILP (Vwindow_configuration_change_hook
)
6115 && ! NILP (Vrun_hooks
))
6116 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6119 if (!NILP (new_current_buffer
))
6120 Fset_buffer (new_current_buffer
);
6122 /* Restore the minimum heights recorded in the configuration. */
6123 window_min_height
= XINT (data
->min_height
);
6124 window_min_width
= XINT (data
->min_width
);
6126 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6127 minibuf_selected_window
= data
->minibuf_selected_window
;
6129 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6132 /* Mark all windows now on frame as deleted
6133 by setting their buffers to nil. */
6136 delete_all_subwindows (w
)
6137 register struct window
*w
;
6139 if (!NILP (w
->next
))
6140 delete_all_subwindows (XWINDOW (w
->next
));
6141 if (!NILP (w
->vchild
))
6142 delete_all_subwindows (XWINDOW (w
->vchild
));
6143 if (!NILP (w
->hchild
))
6144 delete_all_subwindows (XWINDOW (w
->hchild
));
6146 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6148 if (!NILP (w
->buffer
))
6151 /* We set all three of these fields to nil, to make sure that we can
6152 distinguish this dead window from any live window. Live leaf
6153 windows will have buffer set, and combination windows will have
6154 vchild or hchild set. */
6159 Vwindow_list
= Qnil
;
6163 count_windows (window
)
6164 register struct window
*window
;
6166 register int count
= 1;
6167 if (!NILP (window
->next
))
6168 count
+= count_windows (XWINDOW (window
->next
));
6169 if (!NILP (window
->vchild
))
6170 count
+= count_windows (XWINDOW (window
->vchild
));
6171 if (!NILP (window
->hchild
))
6172 count
+= count_windows (XWINDOW (window
->hchild
));
6177 /* Fill vector FLAT with leaf windows under W, starting at index I.
6178 Value is last index + 1. */
6181 get_leaf_windows (w
, flat
, i
)
6183 struct window
**flat
;
6188 if (!NILP (w
->hchild
))
6189 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6190 else if (!NILP (w
->vchild
))
6191 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6195 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6202 /* Return a pointer to the glyph W's physical cursor is on. Value is
6203 null if W's current matrix is invalid, so that no meaningfull glyph
6207 get_phys_cursor_glyph (w
)
6210 struct glyph_row
*row
;
6211 struct glyph
*glyph
;
6213 if (w
->phys_cursor
.vpos
>= 0
6214 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6215 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6217 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6218 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6227 save_window_save (window
, vector
, i
)
6229 struct Lisp_Vector
*vector
;
6232 register struct saved_window
*p
;
6233 register struct window
*w
;
6234 register Lisp_Object tem
;
6236 for (;!NILP (window
); window
= w
->next
)
6238 p
= SAVED_WINDOW_N (vector
, i
);
6239 w
= XWINDOW (window
);
6241 XSETFASTINT (w
->temslot
, i
); i
++;
6243 p
->buffer
= w
->buffer
;
6244 p
->left_col
= w
->left_col
;
6245 p
->top_line
= w
->top_line
;
6246 p
->total_cols
= w
->total_cols
;
6247 p
->total_lines
= w
->total_lines
;
6248 p
->hscroll
= w
->hscroll
;
6249 p
->min_hscroll
= w
->min_hscroll
;
6250 p
->display_table
= w
->display_table
;
6251 p
->orig_top_line
= w
->orig_top_line
;
6252 p
->orig_total_lines
= w
->orig_total_lines
;
6253 p
->left_margin_cols
= w
->left_margin_cols
;
6254 p
->right_margin_cols
= w
->right_margin_cols
;
6255 p
->left_fringe_width
= w
->left_fringe_width
;
6256 p
->right_fringe_width
= w
->right_fringe_width
;
6257 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6258 p
->scroll_bar_width
= w
->scroll_bar_width
;
6259 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6260 if (!NILP (w
->buffer
))
6262 /* Save w's value of point in the window configuration.
6263 If w is the selected window, then get the value of point
6264 from the buffer; pointm is garbage in the selected window. */
6265 if (EQ (window
, selected_window
))
6267 p
->pointm
= Fmake_marker ();
6268 set_marker_both (p
->pointm
, w
->buffer
,
6269 BUF_PT (XBUFFER (w
->buffer
)),
6270 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6273 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6275 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6276 p
->start_at_line_beg
= w
->start_at_line_beg
;
6278 tem
= XBUFFER (w
->buffer
)->mark
;
6279 p
->mark
= Fcopy_marker (tem
, Qnil
);
6286 p
->start_at_line_beg
= Qnil
;
6289 if (NILP (w
->parent
))
6292 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6297 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6299 if (!NILP (w
->vchild
))
6300 i
= save_window_save (w
->vchild
, vector
, i
);
6301 if (!NILP (w
->hchild
))
6302 i
= save_window_save (w
->hchild
, vector
, i
);
6308 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6309 Scurrent_window_configuration
, 0, 1, 0,
6310 doc
: /* Return an object representing the current window configuration of FRAME.
6311 If FRAME is nil or omitted, use the selected frame.
6312 This describes the number of windows, their sizes and current buffers,
6313 and for each displayed buffer, where display starts, and the positions of
6314 point and mark. An exception is made for point in the current buffer:
6315 its value is -not- saved.
6316 This also records the currently selected frame, and FRAME's focus
6317 redirection (see `redirect-frame-focus'). */)
6321 register Lisp_Object tem
;
6322 register int n_windows
;
6323 register struct save_window_data
*data
;
6324 register struct Lisp_Vector
*vec
;
6329 frame
= selected_frame
;
6330 CHECK_LIVE_FRAME (frame
);
6333 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6334 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6335 data
= (struct save_window_data
*)vec
;
6337 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6338 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6339 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6340 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6341 data
->selected_frame
= selected_frame
;
6342 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6343 XSETBUFFER (data
->current_buffer
, current_buffer
);
6344 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6345 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6346 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6347 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6348 XSETINT (data
->min_height
, window_min_height
);
6349 XSETINT (data
->min_width
, window_min_width
);
6350 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6351 data
->saved_windows
= tem
;
6352 for (i
= 0; i
< n_windows
; i
++)
6353 XVECTOR (tem
)->contents
[i
]
6354 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6355 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6356 XSETWINDOW_CONFIGURATION (tem
, data
);
6360 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6362 doc
: /* Execute BODY, preserving window sizes and contents.
6363 Return the value of the last form in BODY.
6364 Restore which buffer appears in which window, where display starts,
6365 and the value of point and mark for each window.
6366 Also restore the choice of selected window.
6367 Also restore which buffer is current.
6368 Does not restore the value of point in current buffer.
6369 usage: (save-window-excursion BODY ...) */)
6373 register Lisp_Object val
;
6374 register int count
= SPECPDL_INDEX ();
6376 record_unwind_protect (Fset_window_configuration
,
6377 Fcurrent_window_configuration (Qnil
));
6378 val
= Fprogn (args
);
6379 return unbind_to (count
, val
);
6384 /***********************************************************************
6386 ***********************************************************************/
6392 Lisp_Object tail
= Qnil
;
6393 Lisp_Object result
= Qnil
;
6400 if (!NILP (w
->hchild
))
6401 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6402 window_tree (XWINDOW (w
->hchild
))));
6403 else if (!NILP (w
->vchild
))
6404 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6405 window_tree (XWINDOW (w
->vchild
))));
6409 result
= tail
= Fcons (wn
, Qnil
);
6413 XSETCDR (tail
, Fcons (wn
, Qnil
));
6417 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6425 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6427 doc
: /* Return the window tree for frame FRAME.
6429 The return value is a list of the form (ROOT MINI), where ROOT
6430 represents the window tree of the frame's root window, and MINI
6431 is the frame's minibuffer window.
6433 If the root window is not split, ROOT is the root window itself.
6434 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6435 horizontal split, and t for a vertical split, EDGES gives the combined
6436 size and position of the subwindows in the split, and the rest of the
6437 elements are the subwindows in the split. Each of the subwindows may
6438 again be a window or a list representing a window split, and so on.
6439 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6441 If FRAME is nil or omitted, return information on the currently
6449 frame
= selected_frame
;
6451 CHECK_FRAME (frame
);
6454 if (!FRAME_LIVE_P (f
))
6457 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6461 /***********************************************************************
6463 ***********************************************************************/
6465 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6467 doc
: /* Set width of marginal areas of window WINDOW.
6468 If WINDOW is nil, set margins of the currently selected window.
6469 Second arg LEFT-WIDTH specifies the number of character cells to
6470 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6471 does the same for the right marginal area. A nil width parameter
6472 means no margin. */)
6473 (window
, left_width
, right_width
)
6474 Lisp_Object window
, left_width
, right_width
;
6476 struct window
*w
= decode_window (window
);
6478 /* Translate negative or zero widths to nil.
6479 Margins that are too wide have to be checked elsewhere. */
6481 if (!NILP (left_width
))
6483 CHECK_NUMBER (left_width
);
6484 if (XINT (left_width
) <= 0)
6488 if (!NILP (right_width
))
6490 CHECK_NUMBER (right_width
);
6491 if (XINT (right_width
) <= 0)
6495 if (!EQ (w
->left_margin_cols
, left_width
)
6496 || !EQ (w
->right_margin_cols
, right_width
))
6498 w
->left_margin_cols
= left_width
;
6499 w
->right_margin_cols
= right_width
;
6501 adjust_window_margins (w
);
6503 ++windows_or_buffers_changed
;
6504 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6511 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6513 doc
: /* Get width of marginal areas of window WINDOW.
6514 If WINDOW is omitted or nil, use the currently selected window.
6515 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6516 If a marginal area does not exist, its width will be returned
6521 struct window
*w
= decode_window (window
);
6522 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6527 /***********************************************************************
6529 ***********************************************************************/
6531 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6533 doc
: /* Set the fringe widths of window WINDOW.
6534 If WINDOW is nil, set the fringe widths of the currently selected
6536 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6537 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6538 fringe width. If a fringe width arg is nil, that means to use the
6539 frame's default fringe width. Default fringe widths can be set with
6540 the command `set-fringe-style'.
6541 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6542 outside of the display margins. By default, fringes are drawn between
6543 display marginal areas and the text area. */)
6544 (window
, left_width
, right_width
, outside_margins
)
6545 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6547 struct window
*w
= decode_window (window
);
6549 if (!NILP (left_width
))
6550 CHECK_NATNUM (left_width
);
6551 if (!NILP (right_width
))
6552 CHECK_NATNUM (right_width
);
6554 if (!EQ (w
->left_fringe_width
, left_width
)
6555 || !EQ (w
->right_fringe_width
, right_width
)
6556 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6558 w
->left_fringe_width
= left_width
;
6559 w
->right_fringe_width
= right_width
;
6560 w
->fringes_outside_margins
= outside_margins
;
6562 adjust_window_margins (w
);
6564 clear_glyph_matrix (w
->current_matrix
);
6565 w
->window_end_valid
= Qnil
;
6567 ++windows_or_buffers_changed
;
6568 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6575 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6577 doc
: /* Get width of fringes of window WINDOW.
6578 If WINDOW is omitted or nil, use the currently selected window.
6579 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6583 struct window
*w
= decode_window (window
);
6584 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6585 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6586 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6587 Qt
: Qnil
), Qnil
)));
6592 /***********************************************************************
6594 ***********************************************************************/
6596 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6598 doc
: /* Set width and type of scroll bars of window WINDOW.
6599 If window is nil, set scroll bars of the currently selected window.
6600 Second parameter WIDTH specifies the pixel width for the scroll bar;
6601 this is automatically adjusted to a multiple of the frame column width.
6602 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6603 bar: left, right, or nil.
6604 If WIDTH is nil, use the frame's scroll-bar width.
6605 If TYPE is t, use the frame's scroll-bar type. */)
6606 (window
, width
, vertical_type
, horizontal_type
)
6607 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6609 struct window
*w
= decode_window (window
);
6613 CHECK_NATNUM (width
);
6615 if (XINT (width
) == 0)
6616 vertical_type
= Qnil
;
6619 if (!(EQ (vertical_type
, Qnil
)
6620 || EQ (vertical_type
, Qleft
)
6621 || EQ (vertical_type
, Qright
)
6622 || EQ (vertical_type
, Qt
)))
6623 error ("Invalid type of vertical scroll bar");
6625 if (!EQ (w
->scroll_bar_width
, width
)
6626 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6628 w
->scroll_bar_width
= width
;
6629 w
->vertical_scroll_bar_type
= vertical_type
;
6631 adjust_window_margins (w
);
6633 clear_glyph_matrix (w
->current_matrix
);
6634 w
->window_end_valid
= Qnil
;
6636 ++windows_or_buffers_changed
;
6637 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6644 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6646 doc
: /* Get width and type of scroll bars of window WINDOW.
6647 If WINDOW is omitted or nil, use the currently selected window.
6648 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6649 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6654 struct window
*w
= decode_window (window
);
6655 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6656 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6657 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6658 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6659 Fcons (w
->vertical_scroll_bar_type
,
6660 Fcons (Qnil
, Qnil
))));
6665 /***********************************************************************
6667 ***********************************************************************/
6669 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6670 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6671 Use the selected window if WINDOW is nil or omitted.
6672 Normally, value is a multiple of the canonical character height of WINDOW;
6673 optional second arg PIXELS_P means value is measured in pixels. */)
6675 Lisp_Object window
, pixels_p
;
6682 window
= selected_window
;
6684 CHECK_WINDOW (window
);
6685 w
= XWINDOW (window
);
6686 f
= XFRAME (w
->frame
);
6688 if (FRAME_WINDOW_P (f
))
6689 result
= (NILP (pixels_p
)
6690 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6691 : make_number (-w
->vscroll
));
6693 result
= make_number (0);
6698 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6700 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6701 WINDOW nil means use the selected window. Normally, VSCROLL is a
6702 non-negative multiple of the canonical character height of WINDOW;
6703 optional third arg PIXELS_P non-nil means that VSCROLL is in pixels.
6704 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6705 corresponds to an integral number of pixels. The return value is the
6706 result of this rounding.
6707 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6708 (window
, vscroll
, pixels_p
)
6709 Lisp_Object window
, vscroll
, pixels_p
;
6715 window
= selected_window
;
6717 CHECK_WINDOW (window
);
6718 CHECK_NUMBER_OR_FLOAT (vscroll
);
6720 w
= XWINDOW (window
);
6721 f
= XFRAME (w
->frame
);
6723 if (FRAME_WINDOW_P (f
))
6725 int old_dy
= w
->vscroll
;
6727 w
->vscroll
= - (NILP (pixels_p
)
6728 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6729 : XFLOATINT (vscroll
));
6730 w
->vscroll
= min (w
->vscroll
, 0);
6732 if (w
->vscroll
!= old_dy
)
6734 /* Adjust glyph matrix of the frame if the virtual display
6735 area becomes larger than before. */
6736 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6739 /* Prevent redisplay shortcuts. */
6740 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6744 return Fwindow_vscroll (window
, pixels_p
);
6748 /* Call FN for all leaf windows on frame F. FN is called with the
6749 first argument being a pointer to the leaf window, and with
6750 additional argument USER_DATA. Stops when FN returns 0. */
6753 foreach_window (f
, fn
, user_data
)
6755 int (* fn
) P_ ((struct window
*, void *));
6758 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6762 /* Helper function for foreach_window. Call FN for all leaf windows
6763 reachable from W. FN is called with the first argument being a
6764 pointer to the leaf window, and with additional argument USER_DATA.
6765 Stop when FN returns 0. Value is 0 if stopped by FN. */
6768 foreach_window_1 (w
, fn
, user_data
)
6770 int (* fn
) P_ ((struct window
*, void *));
6775 for (cont
= 1; w
&& cont
;)
6777 if (!NILP (w
->hchild
))
6778 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6779 else if (!NILP (w
->vchild
))
6780 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6782 cont
= fn (w
, user_data
);
6784 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6791 /* Freeze or unfreeze the window start of W unless it is a
6792 mini-window or the selected window. FREEZE_P non-null means freeze
6793 the window start. */
6796 freeze_window_start (w
, freeze_p
)
6800 if (w
== XWINDOW (selected_window
)
6801 || MINI_WINDOW_P (w
)
6802 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6803 && ! NILP (Vminibuf_scroll_window
)
6804 && w
== XWINDOW (Vminibuf_scroll_window
)))
6807 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6812 /* Freeze or unfreeze the window starts of all leaf windows on frame
6813 F, except the selected window and a mini-window. FREEZE_P non-zero
6814 means freeze the window start. */
6817 freeze_window_starts (f
, freeze_p
)
6821 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6825 /***********************************************************************
6827 ***********************************************************************/
6829 /* Return 1 if window configurations C1 and C2
6830 describe the same state of affairs. This is used by Fequal. */
6833 compare_window_configurations (c1
, c2
, ignore_positions
)
6835 int ignore_positions
;
6837 register struct save_window_data
*d1
, *d2
;
6838 struct Lisp_Vector
*sw1
, *sw2
;
6841 if (!WINDOW_CONFIGURATIONP (c1
))
6842 wrong_type_argument (Qwindow_configuration_p
, c1
);
6843 if (!WINDOW_CONFIGURATIONP (c2
))
6844 wrong_type_argument (Qwindow_configuration_p
, c2
);
6846 d1
= (struct save_window_data
*) XVECTOR (c1
);
6847 d2
= (struct save_window_data
*) XVECTOR (c2
);
6848 sw1
= XVECTOR (d1
->saved_windows
);
6849 sw2
= XVECTOR (d2
->saved_windows
);
6851 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6853 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6855 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6857 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6859 /* Don't compare the current_window field directly.
6860 Instead see w1_is_current and w2_is_current, below. */
6861 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6863 if (! ignore_positions
)
6865 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6867 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6870 /* Don't compare the root_window field.
6871 We don't require the two configurations
6872 to use the same window object,
6873 and the two root windows must be equivalent
6874 if everything else compares equal. */
6875 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6877 if (! EQ (d1
->min_width
, d2
->min_width
))
6879 if (! EQ (d1
->min_height
, d2
->min_height
))
6882 /* Verify that the two confis have the same number of windows. */
6883 if (sw1
->size
!= sw2
->size
)
6886 for (i
= 0; i
< sw1
->size
; i
++)
6888 struct saved_window
*p1
, *p2
;
6889 int w1_is_current
, w2_is_current
;
6891 p1
= SAVED_WINDOW_N (sw1
, i
);
6892 p2
= SAVED_WINDOW_N (sw2
, i
);
6894 /* Verify that the current windows in the two
6895 configurations correspond to each other. */
6896 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6897 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6899 if (w1_is_current
!= w2_is_current
)
6902 /* Verify that the corresponding windows do match. */
6903 if (! EQ (p1
->buffer
, p2
->buffer
))
6905 if (! EQ (p1
->left_col
, p2
->left_col
))
6907 if (! EQ (p1
->top_line
, p2
->top_line
))
6909 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6911 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6913 if (! EQ (p1
->display_table
, p2
->display_table
))
6915 if (! EQ (p1
->parent
, p2
->parent
))
6917 if (! EQ (p1
->prev
, p2
->prev
))
6919 if (! ignore_positions
)
6921 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6923 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6925 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6927 if (NILP (Fequal (p1
->start
, p2
->start
)))
6929 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6931 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6934 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6936 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6938 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6940 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6942 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6944 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6946 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6953 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6954 Scompare_window_configurations
, 2, 2, 0,
6955 doc
: /* Compare two window configurations as regards the structure of windows.
6956 This function ignores details such as the values of point and mark
6957 and scrolling positions. */)
6961 if (compare_window_configurations (x
, y
, 1))
6969 struct frame
*f
= make_terminal_frame ();
6970 XSETFRAME (selected_frame
, f
);
6971 Vterminal_frame
= selected_frame
;
6972 minibuf_window
= f
->minibuffer_window
;
6973 selected_window
= f
->selected_window
;
6974 last_nonminibuf_frame
= f
;
6976 window_initialized
= 1;
6982 Vwindow_list
= Qnil
;
6988 Qwindow_size_fixed
= intern ("window-size-fixed");
6989 staticpro (&Qwindow_size_fixed
);
6990 Fset (Qwindow_size_fixed
, Qnil
);
6992 staticpro (&Qwindow_configuration_change_hook
);
6993 Qwindow_configuration_change_hook
6994 = intern ("window-configuration-change-hook");
6996 Qwindowp
= intern ("windowp");
6997 staticpro (&Qwindowp
);
6999 Qwindow_configuration_p
= intern ("window-configuration-p");
7000 staticpro (&Qwindow_configuration_p
);
7002 Qwindow_live_p
= intern ("window-live-p");
7003 staticpro (&Qwindow_live_p
);
7005 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7006 staticpro (&Qtemp_buffer_show_hook
);
7008 staticpro (&Vwindow_list
);
7010 minibuf_selected_window
= Qnil
;
7011 staticpro (&minibuf_selected_window
);
7013 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7014 doc
: /* Non-nil means call as function to display a help buffer.
7015 The function is called with one argument, the buffer to be displayed.
7016 Used by `with-output-to-temp-buffer'.
7017 If this function is used, then it must do the entire job of showing
7018 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7019 Vtemp_buffer_show_function
= Qnil
;
7021 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7022 doc
: /* If non-nil, function to call to handle `display-buffer'.
7023 It will receive two args, the buffer and a flag which if non-nil means
7024 that the currently selected window is not acceptable.
7025 It should choose or create a window, display the specified buffer in it,
7026 and return the window.
7027 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7028 work using this function. */);
7029 Vdisplay_buffer_function
= Qnil
;
7031 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7032 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7033 If nil, `display-buffer' will leave the window configuration alone. */);
7034 Veven_window_heights
= Qt
;
7036 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7037 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7038 Vminibuf_scroll_window
= Qnil
;
7040 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7041 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7042 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7043 is displayed in the `mode-line' face. */);
7044 mode_line_in_non_selected_windows
= 1;
7046 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7047 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7048 Vother_window_scroll_buffer
= Qnil
;
7050 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7051 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7054 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7055 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7056 auto_window_vscroll_p
= 1;
7058 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7059 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7060 If the buffer in question is already displayed in a frame, raise that frame. */);
7061 display_buffer_reuse_frames
= 0;
7063 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7064 doc
: /* Function to call to handle automatic new frame creation.
7065 It is called with no arguments and should return a newly created frame.
7067 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7068 where `pop-up-frame-alist' would hold the default frame parameters. */);
7069 Vpop_up_frame_function
= Qnil
;
7071 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7072 doc
: /* *List of buffer names that should have their own special frames.
7073 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7074 if its name is in this list, makes a special frame for it
7075 using `special-display-function'. See also `special-display-regexps'.
7077 An element of the list can be a list instead of just a string.
7078 There are two ways to use a list as an element:
7079 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7080 In the first case, the FRAME-PARAMETERS are pairs of the form
7081 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7082 In the second case, FUNCTION is called with BUFFER as the first argument,
7083 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7084 All this is done by the function found in `special-display-function'.
7086 If the specified frame parameters include (same-buffer . t), the
7087 buffer is displayed in the currently selected window. Otherwise, if
7088 they include (same-frame . t), the buffer is displayed in a new window
7089 in the currently selected frame.
7091 If this variable appears \"not to work\", because you add a name to it
7092 but that buffer still appears in the selected window, look at the
7093 values of `same-window-buffer-names' and `same-window-regexps'.
7094 Those variables take precedence over this one. */);
7095 Vspecial_display_buffer_names
= Qnil
;
7097 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7098 doc
: /* *List of regexps saying which buffers should have their own special frames.
7099 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7100 if any regexp in this list matches the buffer name, it makes a
7101 special frame for the buffer by calling `special-display-function'.
7103 An element of the list can be a list instead of just a string.
7104 There are two ways to use a list as an element:
7105 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7106 In the first case, the FRAME-PARAMETERS are pairs of the form
7107 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7108 In the second case, FUNCTION is called with BUFFER as the first argument,
7109 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7110 All this is done by the function found in `special-display-function'.
7112 If the specified frame parameters include (same-buffer . t), the
7113 buffer is displayed in the currently selected window. Otherwise, if
7114 they include (same-frame . t), the buffer is displayed in a new window
7115 in the currently selected frame.
7117 If this variable appears \"not to work\", because you add a regexp to it
7118 but the matching buffers still appear in the selected window, look at the
7119 values of `same-window-buffer-names' and `same-window-regexps'.
7120 Those variables take precedence over this one. */);
7121 Vspecial_display_regexps
= Qnil
;
7123 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7124 doc
: /* Function to call to make a new frame for a special buffer.
7125 It is called with two arguments, the buffer and optional buffer specific
7126 data, and should return a window displaying that buffer.
7127 The default value normally makes a separate frame for the buffer,
7128 using `special-display-frame-alist' to specify the frame parameters.
7129 But if the buffer specific data includes (same-buffer . t) then the
7130 buffer is displayed in the current selected window.
7131 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7132 a new window in the currently selected frame.
7134 A buffer is special if it is listed in `special-display-buffer-names'
7135 or matches a regexp in `special-display-regexps'. */);
7136 Vspecial_display_function
= Qnil
;
7138 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7139 doc
: /* *List of buffer names that should appear in the selected window.
7140 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7141 switches to it in the selected window, rather than making it appear
7142 in some other window.
7144 An element of the list can be a cons cell instead of just a string.
7145 Then the car must be a string, which specifies the buffer name.
7146 This is for compatibility with `special-display-buffer-names';
7147 the cdr of the cons cell is ignored.
7149 See also `same-window-regexps'. */);
7150 Vsame_window_buffer_names
= Qnil
;
7152 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7153 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7154 If a buffer name matches one of these regexps, then displaying it
7155 using `display-buffer' or `pop-to-buffer' switches to it
7156 in the selected window, rather than making it appear in some other window.
7158 An element of the list can be a cons cell instead of just a string.
7159 Then the car must be a string, which specifies the buffer name.
7160 This is for compatibility with `special-display-buffer-names';
7161 the cdr of the cons cell is ignored.
7163 See also `same-window-buffer-names'. */);
7164 Vsame_window_regexps
= Qnil
;
7166 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7167 doc
: /* *Non-nil means display-buffer should make new windows. */);
7170 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7171 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7172 next_screen_context_lines
= 2;
7174 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7175 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
7176 If there is only one window, it is split regardless of this value. */);
7177 split_height_threshold
= 500;
7179 DEFVAR_INT ("window-min-height", &window_min_height
,
7180 doc
: /* *Delete any window less than this tall (including its mode line). */);
7181 window_min_height
= 4;
7183 DEFVAR_INT ("window-min-width", &window_min_width
,
7184 doc
: /* *Delete any window less than this wide. */);
7185 window_min_width
= 10;
7187 DEFVAR_LISP ("scroll-preserve-screen-position",
7188 &Vscroll_preserve_screen_position
,
7189 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7190 A value of nil means point does not keep its screen position except
7191 at the scroll margin or window boundary respectively.
7192 A value of t means point keeps its screen position if the scroll
7193 command moved it vertically out of the window, e.g. when scrolling
7195 Any other value means point always keeps its screen position. */);
7196 Vscroll_preserve_screen_position
= Qnil
;
7198 DEFVAR_LISP ("window-configuration-change-hook",
7199 &Vwindow_configuration_change_hook
,
7200 doc
: /* Functions to call when window configuration changes.
7201 The selected frame is the one whose configuration has changed. */);
7202 Vwindow_configuration_change_hook
= Qnil
;
7204 defsubr (&Sselected_window
);
7205 defsubr (&Sminibuffer_window
);
7206 defsubr (&Swindow_minibuffer_p
);
7207 defsubr (&Swindowp
);
7208 defsubr (&Swindow_live_p
);
7209 defsubr (&Spos_visible_in_window_p
);
7210 defsubr (&Swindow_buffer
);
7211 defsubr (&Swindow_height
);
7212 defsubr (&Swindow_width
);
7213 defsubr (&Swindow_hscroll
);
7214 defsubr (&Sset_window_hscroll
);
7215 defsubr (&Swindow_redisplay_end_trigger
);
7216 defsubr (&Sset_window_redisplay_end_trigger
);
7217 defsubr (&Swindow_edges
);
7218 defsubr (&Swindow_pixel_edges
);
7219 defsubr (&Swindow_inside_edges
);
7220 defsubr (&Swindow_inside_pixel_edges
);
7221 defsubr (&Scoordinates_in_window_p
);
7222 defsubr (&Swindow_at
);
7223 defsubr (&Swindow_point
);
7224 defsubr (&Swindow_start
);
7225 defsubr (&Swindow_end
);
7226 defsubr (&Sset_window_point
);
7227 defsubr (&Sset_window_start
);
7228 defsubr (&Swindow_dedicated_p
);
7229 defsubr (&Sset_window_dedicated_p
);
7230 defsubr (&Swindow_display_table
);
7231 defsubr (&Sset_window_display_table
);
7232 defsubr (&Snext_window
);
7233 defsubr (&Sprevious_window
);
7234 defsubr (&Sother_window
);
7235 defsubr (&Sget_lru_window
);
7236 defsubr (&Sget_largest_window
);
7237 defsubr (&Sget_buffer_window
);
7238 defsubr (&Sdelete_other_windows
);
7239 defsubr (&Sdelete_windows_on
);
7240 defsubr (&Sreplace_buffer_in_windows
);
7241 defsubr (&Sdelete_window
);
7242 defsubr (&Sset_window_buffer
);
7243 defsubr (&Sselect_window
);
7244 defsubr (&Sspecial_display_p
);
7245 defsubr (&Ssame_window_p
);
7246 defsubr (&Sdisplay_buffer
);
7247 defsubr (&Sforce_window_update
);
7248 defsubr (&Ssplit_window
);
7249 defsubr (&Senlarge_window
);
7250 defsubr (&Sshrink_window
);
7251 defsubr (&Sadjust_window_trailing_edge
);
7252 defsubr (&Sscroll_up
);
7253 defsubr (&Sscroll_down
);
7254 defsubr (&Sscroll_left
);
7255 defsubr (&Sscroll_right
);
7256 defsubr (&Sother_window_for_scrolling
);
7257 defsubr (&Sscroll_other_window
);
7258 defsubr (&Sminibuffer_selected_window
);
7259 defsubr (&Srecenter
);
7260 defsubr (&Swindow_text_height
);
7261 defsubr (&Smove_to_window_line
);
7262 defsubr (&Swindow_configuration_p
);
7263 defsubr (&Swindow_configuration_frame
);
7264 defsubr (&Sset_window_configuration
);
7265 defsubr (&Scurrent_window_configuration
);
7266 defsubr (&Ssave_window_excursion
);
7267 defsubr (&Swindow_tree
);
7268 defsubr (&Sset_window_margins
);
7269 defsubr (&Swindow_margins
);
7270 defsubr (&Sset_window_fringes
);
7271 defsubr (&Swindow_fringes
);
7272 defsubr (&Sset_window_scroll_bars
);
7273 defsubr (&Swindow_scroll_bars
);
7274 defsubr (&Swindow_vscroll
);
7275 defsubr (&Sset_window_vscroll
);
7276 defsubr (&Scompare_window_configurations
);
7277 defsubr (&Swindow_list
);
7283 initial_define_key (control_x_map
, '1', "delete-other-windows");
7284 initial_define_key (control_x_map
, '2', "split-window");
7285 initial_define_key (control_x_map
, '0', "delete-window");
7286 initial_define_key (control_x_map
, 'o', "other-window");
7287 initial_define_key (control_x_map
, '^', "enlarge-window");
7288 initial_define_key (control_x_map
, '<', "scroll-left");
7289 initial_define_key (control_x_map
, '>', "scroll-right");
7291 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7292 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7293 initial_define_key (meta_map
, 'v', "scroll-down");
7295 initial_define_key (global_map
, Ctl('L'), "recenter");
7296 initial_define_key (meta_map
, 'r', "move-to-window-line");
7299 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7300 (do not change this comment) */