1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
36 #include "dispextern.h"
37 #include "blockinput.h"
38 #include "intervals.h"
42 #endif /* HAVE_X_WINDOWS */
54 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
55 Lisp_Object Qscroll_up
, Qscroll_down
;
56 Lisp_Object Qwindow_size_fixed
;
57 extern Lisp_Object Qleft_margin
, Qright_margin
;
59 static int displayed_window_lines
P_ ((struct window
*));
60 static struct window
*decode_window
P_ ((Lisp_Object
));
61 static int count_windows
P_ ((struct window
*));
62 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
63 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
64 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
65 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
66 static int window_min_size_1
P_ ((struct window
*, int));
67 static int window_min_size
P_ ((struct window
*, int, int, int *));
68 static void size_window
P_ ((Lisp_Object
, int, int, int, int, int));
69 static int freeze_window_start
P_ ((struct window
*, void *));
70 static int window_fixed_size_p
P_ ((struct window
*, int, int));
71 static void enlarge_window
P_ ((Lisp_Object
, int, int));
72 static Lisp_Object window_list
P_ ((void));
73 static int add_window_to_list
P_ ((struct window
*, void *));
74 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
80 static int foreach_window_1
P_ ((struct window
*,
81 int (* fn
) (struct window
*, void *),
83 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
85 /* This is the window in which the terminal's cursor should
86 be left when nothing is being done with it. This must
87 always be a leaf window, and its buffer is selected by
88 the top level editing loop at the end of each command.
90 This value is always the same as
91 FRAME_SELECTED_WINDOW (selected_frame). */
93 Lisp_Object selected_window
;
95 /* A list of all windows for use by next_window and Fwindow_list.
96 Functions creating or deleting windows should invalidate this cache
97 by setting it to nil. */
99 Lisp_Object Vwindow_list
;
101 /* The mini-buffer window of the selected frame.
102 Note that you cannot test for mini-bufferness of an arbitrary window
103 by comparing against this; but you can test for mini-bufferness of
104 the selected window. */
106 Lisp_Object minibuf_window
;
108 /* Non-nil means it is the window whose mode line should be
109 shown as the selected window when the minibuffer is selected. */
111 Lisp_Object minibuf_selected_window
;
113 /* Non-nil means it is the window for C-M-v to scroll
114 when the mini-buffer is selected. */
116 Lisp_Object Vminibuf_scroll_window
;
118 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
120 Lisp_Object Vother_window_scroll_buffer
;
122 /* Non-nil means it's function to call to display temp buffers. */
124 Lisp_Object Vtemp_buffer_show_function
;
126 /* Non-zero means line and page scrolling on tall lines (with images)
127 does partial scrolling by modifying window-vscroll. */
129 int auto_window_vscroll_p
;
131 /* Non-zero means to use mode-line-inactive face in all windows but the
132 selected-window and the minibuffer-scroll-window when the
133 minibuffer is active. */
134 int mode_line_in_non_selected_windows
;
136 /* If a window gets smaller than either of these, it is removed. */
138 EMACS_INT window_min_height
;
139 EMACS_INT window_min_width
;
141 /* Nonzero implies Fdisplay_buffer should create windows. */
145 /* Nonzero implies make new frames for Fdisplay_buffer. */
149 /* Nonzero means reuse existing frames for displaying buffers. */
151 int display_buffer_reuse_frames
;
153 /* Non-nil means use this function instead of default */
155 Lisp_Object Vpop_up_frame_function
;
157 /* Function to call to handle Fdisplay_buffer. */
159 Lisp_Object Vdisplay_buffer_function
;
161 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
163 Lisp_Object Veven_window_heights
;
165 /* List of buffer *names* for buffers that should have their own frames. */
167 Lisp_Object Vspecial_display_buffer_names
;
169 /* List of regexps for buffer names that should have their own frames. */
171 Lisp_Object Vspecial_display_regexps
;
173 /* Function to pop up a special frame. */
175 Lisp_Object Vspecial_display_function
;
177 /* List of buffer *names* for buffers to appear in selected window. */
179 Lisp_Object Vsame_window_buffer_names
;
181 /* List of regexps for buffer names to appear in selected window. */
183 Lisp_Object Vsame_window_regexps
;
185 /* Hook run at end of temp_output_buffer_show. */
187 Lisp_Object Qtemp_buffer_show_hook
;
189 /* Fdisplay_buffer always splits the largest window
190 if that window is more than this high. */
192 EMACS_INT split_height_threshold
;
194 /* Number of lines of continuity in scrolling by screenfuls. */
196 EMACS_INT next_screen_context_lines
;
198 /* Incremented for each window created. */
200 static int sequence_number
;
202 /* Nonzero after init_window_once has finished. */
204 static int window_initialized
;
206 /* Hook to run when window config changes. */
208 Lisp_Object Qwindow_configuration_change_hook
;
209 Lisp_Object Vwindow_configuration_change_hook
;
211 /* Non-nil means scroll commands try to put point
212 at the same screen height as previously. */
214 Lisp_Object Vscroll_preserve_screen_position
;
216 /* Incremented by 1 whenever a window is deleted. */
218 int window_deletion_count
;
220 /* Used by the function window_scroll_pixel_based */
222 static int window_scroll_pixel_based_preserve_y
;
224 #if 0 /* This isn't used anywhere. */
225 /* Nonzero means we can split a frame even if it is "unsplittable". */
226 static int inhibit_frame_unsplittable
;
229 extern EMACS_INT scroll_margin
;
231 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
233 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
234 doc
: /* Returns t if OBJECT is a window. */)
238 return WINDOWP (object
) ? Qt
: Qnil
;
241 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
242 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
246 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
253 register struct window
*p
;
255 p
= allocate_window ();
257 XSETFASTINT (p
->sequence_number
, sequence_number
);
258 XSETFASTINT (p
->left_col
, 0);
259 XSETFASTINT (p
->top_line
, 0);
260 XSETFASTINT (p
->total_lines
, 0);
261 XSETFASTINT (p
->total_cols
, 0);
262 XSETFASTINT (p
->hscroll
, 0);
263 XSETFASTINT (p
->min_hscroll
, 0);
264 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
265 p
->start
= Fmake_marker ();
266 p
->pointm
= Fmake_marker ();
267 XSETFASTINT (p
->use_time
, 0);
269 p
->display_table
= Qnil
;
271 p
->pseudo_window_p
= 0;
272 bzero (&p
->cursor
, sizeof (p
->cursor
));
273 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
274 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
275 p
->desired_matrix
= p
->current_matrix
= 0;
276 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
277 p
->phys_cursor_type
= -1;
278 p
->phys_cursor_width
= -1;
279 p
->must_be_updated_p
= 0;
280 XSETFASTINT (p
->window_end_vpos
, 0);
281 XSETFASTINT (p
->window_end_pos
, 0);
282 p
->window_end_valid
= Qnil
;
285 XSETFASTINT (p
->last_point
, 0);
286 p
->frozen_window_start_p
= 0;
287 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
288 p
->left_margin_cols
= Qnil
;
289 p
->right_margin_cols
= Qnil
;
290 p
->left_fringe_width
= Qnil
;
291 p
->right_fringe_width
= Qnil
;
292 p
->fringes_outside_margins
= Qnil
;
293 p
->scroll_bar_width
= Qnil
;
294 p
->vertical_scroll_bar_type
= Qt
;
300 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
301 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
304 return selected_window
;
307 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
308 doc
: /* Return the window used now for minibuffers.
309 If the optional argument FRAME is specified, return the minibuffer window
310 used by that frame. */)
315 frame
= selected_frame
;
316 CHECK_LIVE_FRAME (frame
);
317 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
320 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
321 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
322 WINDOW defaults to the selected window. */)
326 struct window
*w
= decode_window (window
);
327 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
331 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
332 Spos_visible_in_window_p
, 0, 3, 0,
333 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
334 Return nil if that position is scrolled vertically out of view.
335 If a character is only partially visible, nil is returned, unless the
336 optional argument PARTIALLY is non-nil.
337 If POS is only out of view because of horizontal scrolling, return non-nil.
338 If POS is t, it specifies the position of the last visible glyph in WINDOW.
339 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
341 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
342 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
343 where X and Y are the pixel coordinates relative to the top left corner
344 of the window. The remaining elements are omitted if the character after
345 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
346 off-window at the top and bottom of the row, ROWH is the height of the
347 display row, and VPOS is the row number (0-based) containing POS. */)
348 (pos
, window
, partially
)
349 Lisp_Object pos
, window
, partially
;
351 register struct window
*w
;
353 register struct buffer
*buf
;
355 Lisp_Object in_window
= Qnil
;
356 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
359 w
= decode_window (window
);
360 buf
= XBUFFER (w
->buffer
);
361 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
365 else if (!NILP (pos
))
367 CHECK_NUMBER_COERCE_MARKER (pos
);
370 else if (w
== XWINDOW (selected_window
))
373 posint
= XMARKER (w
->pointm
)->charpos
;
375 /* If position is above window start or outside buffer boundaries,
376 or if window start is out of range, position is not visible. */
378 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
379 && CHARPOS (top
) >= BUF_BEGV (buf
)
380 && CHARPOS (top
) <= BUF_ZV (buf
)
381 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
382 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
385 if (!NILP (in_window
) && !NILP (partially
))
387 Lisp_Object part
= Qnil
;
389 part
= list4 (make_number (rtop
), make_number (rbot
),
390 make_number (rowh
), make_number (vpos
));
391 in_window
= Fcons (make_number (x
),
392 Fcons (make_number (y
), part
));
398 DEFUN ("window-line-height", Fwindow_line_height
,
399 Swindow_line_height
, 0, 2, 0,
400 doc
: /* Return height in pixels of text line LINE in window WINDOW.
401 If WINDOW is nil or omitted, use selected window.
403 Return height of current line if LINE is omitted or nil. Return height of
404 header or mode line if LINE is `header-line' and `mode-line'.
405 Otherwise, LINE is a text line number starting from 0. A negative number
406 counts from the end of the window.
408 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
409 in pixels of the visible part of the line, VPOS and YPOS are the
410 vertical position in lines and pixels of the line, relative to the top
411 of the first text line, and OFFBOT is the number of off-window pixels at
412 the bottom of the text line. If there are off-window pixels at the top
413 of the (first) text line, YPOS is negative.
415 Return nil if window display is not up-to-date. In that case, use
416 `pos-visible-in-window-p' to obtain the information. */)
418 Lisp_Object line
, window
;
420 register struct window
*w
;
421 register struct buffer
*b
;
422 struct glyph_row
*row
, *end_row
;
423 int max_y
, crop
, i
, n
;
425 w
= decode_window (window
);
428 || w
->pseudo_window_p
)
431 CHECK_BUFFER (w
->buffer
);
432 b
= XBUFFER (w
->buffer
);
434 /* Fail if current matrix is not up-to-date. */
435 if (NILP (w
->window_end_valid
)
436 || current_buffer
->clip_changed
437 || current_buffer
->prevent_redisplay_optimizations_p
438 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
439 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
445 if (i
< 0 || i
>= w
->current_matrix
->nrows
446 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
448 max_y
= window_text_bottom_y (w
);
452 if (EQ (line
, Qheader_line
))
454 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
456 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
459 return list4 (make_number (row
->height
),
460 make_number (0), make_number (0),
464 if (EQ (line
, Qmode_line
))
466 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
469 return list4 (make_number (row
->height
),
470 make_number (0), /* not accurate */
471 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
472 + window_text_bottom_y (w
)),
479 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
480 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
481 max_y
= window_text_bottom_y (w
);
484 while ((n
< 0 || i
< n
)
485 && row
<= end_row
&& row
->enabled_p
486 && row
->y
+ row
->height
< max_y
)
489 if (row
> end_row
|| !row
->enabled_p
)
501 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
502 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
504 make_number (row
->y
),
510 static struct window
*
511 decode_window (window
)
512 register Lisp_Object window
;
515 return XWINDOW (selected_window
);
517 CHECK_LIVE_WINDOW (window
);
518 return XWINDOW (window
);
521 static struct window
*
522 decode_any_window (window
)
523 register Lisp_Object window
;
526 return XWINDOW (selected_window
);
528 CHECK_WINDOW (window
);
529 return XWINDOW (window
);
532 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
533 doc
: /* Return the buffer that WINDOW is displaying.
534 WINDOW defaults to the selected window. */)
538 return decode_window (window
)->buffer
;
541 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
542 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
546 return decode_any_window (window
)->total_lines
;
549 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
550 doc
: /* Return the number of display columns in WINDOW.
551 This is the width that is usable columns available for text in WINDOW.
552 If you want to find out how many columns WINDOW takes up,
553 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
557 return make_number (window_box_text_cols (decode_any_window (window
)));
560 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
561 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
565 return decode_window (window
)->hscroll
;
568 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
569 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
570 Return NCOL. NCOL should be zero or positive.
572 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
573 window so that the location of point moves off-window. */)
575 Lisp_Object window
, ncol
;
577 struct window
*w
= decode_window (window
);
581 hscroll
= max (0, XINT (ncol
));
583 /* Prevent redisplay shortcuts when changing the hscroll. */
584 if (XINT (w
->hscroll
) != hscroll
)
585 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
587 w
->hscroll
= make_number (hscroll
);
591 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
592 Swindow_redisplay_end_trigger
, 0, 1, 0,
593 doc
: /* Return WINDOW's redisplay end trigger value.
594 See `set-window-redisplay-end-trigger' for more information. */)
598 return decode_window (window
)->redisplay_end_trigger
;
601 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
602 Sset_window_redisplay_end_trigger
, 2, 2, 0,
603 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
604 VALUE should be a buffer position (typically a marker) or nil.
605 If it is a buffer position, then if redisplay in WINDOW reaches a position
606 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
607 with two arguments: WINDOW, and the end trigger value.
608 Afterwards the end-trigger value is reset to nil. */)
610 register Lisp_Object window
, value
;
612 register struct window
*w
;
614 w
= decode_window (window
);
615 w
->redisplay_end_trigger
= value
;
619 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
620 doc
: /* Return a list of the edge coordinates of WINDOW.
621 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
622 RIGHT is one more than the rightmost column occupied by WINDOW,
623 and BOTTOM is one more than the bottommost row occupied by WINDOW.
624 The edges include the space used by the window's scroll bar,
625 display margins, fringes, header line, and mode line, if it has them.
626 To get the edges of the actual text area, use `window-inside-edges'. */)
630 register struct window
*w
= decode_any_window (window
);
632 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
633 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
634 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
635 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
639 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
640 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
641 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
642 RIGHT is one more than the rightmost x position occupied by WINDOW,
643 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
644 The pixel edges include the space used by the window's scroll bar,
645 display margins, fringes, header line, and mode line, if it has them.
646 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
650 register struct window
*w
= decode_any_window (window
);
652 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
653 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
654 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
655 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
659 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
660 doc
: /* Return a list of the edge coordinates of WINDOW.
661 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
662 RIGHT is one more than the rightmost column used by text in WINDOW,
663 and BOTTOM is one more than the bottommost row used by text in WINDOW.
664 The inside edges do not include the space used by the window's scroll bar,
665 display margins, fringes, header line, and/or mode line. */)
669 register struct window
*w
= decode_any_window (window
);
671 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
672 + WINDOW_LEFT_MARGIN_COLS (w
)
673 + WINDOW_LEFT_FRINGE_COLS (w
)),
674 make_number (WINDOW_TOP_EDGE_LINE (w
)
675 + WINDOW_HEADER_LINE_LINES (w
)),
676 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
677 - WINDOW_RIGHT_MARGIN_COLS (w
)
678 - WINDOW_RIGHT_FRINGE_COLS (w
)),
679 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
680 - WINDOW_MODE_LINE_LINES (w
)));
683 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
684 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
685 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
686 RIGHT is one more than the rightmost x position used by text in WINDOW,
687 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
688 The inside edges do not include the space used by the window's scroll bar,
689 display margins, fringes, header line, and/or mode line. */)
693 register struct window
*w
= decode_any_window (window
);
695 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
696 + WINDOW_LEFT_MARGIN_WIDTH (w
)
697 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
698 make_number (WINDOW_TOP_EDGE_Y (w
)
699 + WINDOW_HEADER_LINE_HEIGHT (w
)),
700 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
701 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
702 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
703 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
704 - WINDOW_MODE_LINE_HEIGHT (w
)));
707 /* Test if the character at column *X, row *Y is within window W.
708 If it is not, return ON_NOTHING;
709 if it is in the window's text area,
710 set *x and *y to its location relative to the upper left corner
713 if it is on the window's modeline, return ON_MODE_LINE;
714 if it is on the border between the window and its right sibling,
715 return ON_VERTICAL_BORDER.
716 if it is on a scroll bar,
717 return ON_SCROLL_BAR.
718 if it is on the window's top line, return ON_HEADER_LINE;
719 if it is in left or right fringe of the window,
720 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
721 to window-relative coordinates;
722 if it is in the marginal area to the left/right of the window,
723 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
724 to window-relative coordinates.
726 X and Y are frame relative pixel coordinates. */
728 static enum window_part
729 coordinates_in_window (w
, x
, y
)
730 register struct window
*w
;
733 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
734 int left_x
, right_x
, top_y
, bottom_y
;
735 enum window_part part
;
736 int ux
= FRAME_COLUMN_WIDTH (f
);
737 int x0
= WINDOW_LEFT_EDGE_X (w
);
738 int x1
= WINDOW_RIGHT_EDGE_X (w
);
739 /* The width of the area where the vertical line can be dragged.
740 (Between mode lines for instance. */
741 int grabbable_width
= ux
;
742 int lmargin_width
, rmargin_width
, text_left
, text_right
;
744 /* In what's below, we subtract 1 when computing right_x because we
745 want the rightmost pixel, which is given by left_pixel+width-1. */
746 if (w
->pseudo_window_p
)
749 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
750 top_y
= WINDOW_TOP_EDGE_Y (w
);
751 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
755 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
756 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
757 top_y
= WINDOW_TOP_EDGE_Y (w
);
758 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
761 /* Outside any interesting row? */
762 if (*y
< top_y
|| *y
>= bottom_y
)
765 /* On the mode line or header line? If it's near the start of
766 the mode or header line of window that's has a horizontal
767 sibling, say it's on the vertical line. That's to be able
768 to resize windows horizontally in case we're using toolkit
771 if (WINDOW_WANTS_MODELINE_P (w
)
772 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
776 header_vertical_border_check
:
777 /* We're somewhere on the mode line. We consider the place
778 between mode lines of horizontally adjacent mode lines
779 as the vertical border. If scroll bars on the left,
780 return the right window. */
781 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
782 || WINDOW_RIGHTMOST_P (w
))
784 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
786 /* Convert X and Y to window relative coordinates.
787 Vertical border is at the left edge of window. */
788 *x
= max (0, *x
- x0
);
790 return ON_VERTICAL_BORDER
;
795 if (abs (*x
- x1
) < grabbable_width
)
797 /* Convert X and Y to window relative coordinates.
798 Vertical border is at the right edge of window. */
799 *x
= min (x1
, *x
) - x0
;
801 return ON_VERTICAL_BORDER
;
805 if (*x
< x0
|| *x
>= x1
)
808 /* Convert X and Y to window relative coordinates.
809 Mode line starts at left edge of window. */
815 if (WINDOW_WANTS_HEADER_LINE_P (w
)
816 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
818 part
= ON_HEADER_LINE
;
819 goto header_vertical_border_check
;
822 if (*x
< x0
|| *x
>= x1
)
825 /* Outside any interesting column? */
826 if (*x
< left_x
|| *x
> right_x
)
829 return ON_SCROLL_BAR
;
832 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
833 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
835 text_left
= window_box_left (w
, TEXT_AREA
);
836 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
838 if (FRAME_WINDOW_P (f
))
840 if (!w
->pseudo_window_p
841 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
842 && !WINDOW_RIGHTMOST_P (w
)
843 && (abs (*x
- right_x
) < grabbable_width
))
845 /* Convert X and Y to window relative coordinates.
846 Vertical border is at the right edge of window. */
847 *x
= min (right_x
, *x
) - left_x
;
849 return ON_VERTICAL_BORDER
;
854 /* Need to say "*x > right_x" rather than >=, since on character
855 terminals, the vertical line's x coordinate is right_x. */
856 if (!w
->pseudo_window_p
857 && !WINDOW_RIGHTMOST_P (w
)
858 && *x
> right_x
- ux
)
860 /* On the border on the right side of the window? Assume that
861 this area begins at RIGHT_X minus a canonical char width. */
862 *x
= min (right_x
, *x
) - left_x
;
864 return ON_VERTICAL_BORDER
;
870 if (lmargin_width
> 0
871 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
872 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
873 : (*x
< left_x
+ lmargin_width
)))
876 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
877 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
879 return ON_LEFT_MARGIN
;
882 /* Convert X and Y to window-relative pixel coordinates. */
885 return ON_LEFT_FRINGE
;
888 if (*x
>= text_right
)
890 if (rmargin_width
> 0
891 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
892 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
893 : (*x
>= right_x
- rmargin_width
)))
895 *x
-= right_x
- rmargin_width
;
896 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
897 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
899 return ON_RIGHT_MARGIN
;
902 /* Convert X and Y to window-relative pixel coordinates. */
903 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
905 return ON_RIGHT_FRINGE
;
908 /* Everything special ruled out - must be on text area */
915 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
916 Scoordinates_in_window_p
, 2, 2, 0,
917 doc
: /* Return non-nil if COORDINATES are in WINDOW.
918 COORDINATES is a cons of the form (X . Y), X and Y being distances
919 measured in characters from the upper-left corner of the frame.
920 \(0 . 0) denotes the character in the upper left corner of the
922 If COORDINATES are in the text portion of WINDOW,
923 the coordinates relative to the window are returned.
924 If they are in the mode line of WINDOW, `mode-line' is returned.
925 If they are in the top mode line of WINDOW, `header-line' is returned.
926 If they are in the left fringe of WINDOW, `left-fringe' is returned.
927 If they are in the right fringe of WINDOW, `right-fringe' is returned.
928 If they are on the border between WINDOW and its right sibling,
929 `vertical-line' is returned.
930 If they are in the windows's left or right marginal areas, `left-margin'\n\
931 or `right-margin' is returned. */)
932 (coordinates
, window
)
933 register Lisp_Object coordinates
, window
;
940 CHECK_WINDOW (window
);
941 w
= XWINDOW (window
);
942 f
= XFRAME (w
->frame
);
943 CHECK_CONS (coordinates
);
944 lx
= Fcar (coordinates
);
945 ly
= Fcdr (coordinates
);
946 CHECK_NUMBER_OR_FLOAT (lx
);
947 CHECK_NUMBER_OR_FLOAT (ly
);
948 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
949 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
951 switch (coordinates_in_window (w
, &x
, &y
))
957 /* X and Y are now window relative pixel coordinates. Convert
958 them to canonical char units before returning them. */
959 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
960 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
965 case ON_VERTICAL_BORDER
:
966 return Qvertical_line
;
974 case ON_RIGHT_FRINGE
:
975 return Qright_fringe
;
980 case ON_RIGHT_MARGIN
:
981 return Qright_margin
;
984 /* Historically we are supposed to return nil in this case. */
993 /* Callback for foreach_window, used in window_from_coordinates.
994 Check if window W contains coordinates specified by USER_DATA which
995 is actually a pointer to a struct check_window_data CW.
997 Check if window W contains coordinates *CW->x and *CW->y. If it
998 does, return W in *CW->window, as Lisp_Object, and return in
999 *CW->part the part of the window under coordinates *X,*Y. Return
1000 zero from this function to stop iterating over windows. */
1002 struct check_window_data
1004 Lisp_Object
*window
;
1006 enum window_part
*part
;
1010 check_window_containing (w
, user_data
)
1014 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1015 enum window_part found
;
1018 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1019 if (found
!= ON_NOTHING
)
1022 XSETWINDOW (*cw
->window
, w
);
1030 /* Find the window containing frame-relative pixel position X/Y and
1031 return it as a Lisp_Object.
1033 If X, Y is on one of the window's special `window_part' elements,
1034 set *PART to the id of that element, and return X and Y converted
1035 to window relative coordinates in WX and WY.
1037 If there is no window under X, Y return nil and leave *PART
1038 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1040 This function was previously implemented with a loop cycling over
1041 windows with Fnext_window, and starting with the frame's selected
1042 window. It turned out that this doesn't work with an
1043 implementation of next_window using Vwindow_list, because
1044 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1045 tree of F when this function is called asynchronously from
1046 note_mouse_highlight. The original loop didn't terminate in this
1050 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
1053 enum window_part
*part
;
1058 struct check_window_data cw
;
1059 enum window_part dummy
;
1065 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1066 foreach_window (f
, check_window_containing
, &cw
);
1068 /* If not found above, see if it's in the tool bar window, if a tool
1072 && WINDOWP (f
->tool_bar_window
)
1073 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1074 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1078 window
= f
->tool_bar_window
;
1087 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1088 doc
: /* Return window containing coordinates X and Y on FRAME.
1089 If omitted, FRAME defaults to the currently selected frame.
1090 The top left corner of the frame is considered to be row 0,
1093 Lisp_Object x
, y
, frame
;
1098 frame
= selected_frame
;
1099 CHECK_LIVE_FRAME (frame
);
1102 /* Check that arguments are integers or floats. */
1103 CHECK_NUMBER_OR_FLOAT (x
);
1104 CHECK_NUMBER_OR_FLOAT (y
);
1106 return window_from_coordinates (f
,
1107 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1108 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1109 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1110 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1114 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1115 doc
: /* Return current value of point in WINDOW.
1116 For a nonselected window, this is the value point would have
1117 if that window were selected.
1119 Note that, when WINDOW is the selected window and its buffer
1120 is also currently selected, the value returned is the same as (point).
1121 It would be more strictly correct to return the `top-level' value
1122 of point, outside of any save-excursion forms.
1123 But that is hard to define. */)
1127 register struct window
*w
= decode_window (window
);
1129 if (w
== XWINDOW (selected_window
)
1130 && current_buffer
== XBUFFER (w
->buffer
))
1132 return Fmarker_position (w
->pointm
);
1135 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1136 doc
: /* Return position at which display currently starts in WINDOW.
1137 This is updated by redisplay or by calling `set-window-start'. */)
1141 return Fmarker_position (decode_window (window
)->start
);
1144 /* This is text temporarily removed from the doc string below.
1146 This function returns nil if the position is not currently known.
1147 That happens when redisplay is preempted and doesn't finish.
1148 If in that case you want to compute where the end of the window would
1149 have been if redisplay had finished, do this:
1151 (goto-char (window-start window))
1152 (vertical-motion (1- (window-height window)) window)
1155 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1156 doc
: /* Return position at which display currently ends in WINDOW.
1157 This is updated by redisplay, when it runs to completion.
1158 Simply changing the buffer text or setting `window-start'
1159 does not update this value.
1160 Return nil if there is no recorded value. \(This can happen if the
1161 last redisplay of WINDOW was preempted, and did not finish.)
1162 If UPDATE is non-nil, compute the up-to-date position
1163 if it isn't already recorded. */)
1165 Lisp_Object window
, update
;
1168 struct window
*w
= decode_window (window
);
1176 #if 0 /* This change broke some things. We should make it later. */
1177 /* If we don't know the end position, return nil.
1178 The user can compute it with vertical-motion if he wants to.
1179 It would be nicer to do it automatically,
1180 but that's so slow that it would probably bother people. */
1181 if (NILP (w
->window_end_valid
))
1186 && ! (! NILP (w
->window_end_valid
)
1187 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
))
1190 struct text_pos startp
;
1192 struct buffer
*old_buffer
= NULL
;
1194 /* Cannot use Fvertical_motion because that function doesn't
1195 cope with variable-height lines. */
1196 if (b
!= current_buffer
)
1198 old_buffer
= current_buffer
;
1199 set_buffer_internal (b
);
1202 /* In case W->start is out of the range, use something
1203 reasonable. This situation occurred when loading a file with
1204 `-l' containing a call to `rmail' with subsequent other
1205 commands. At the end, W->start happened to be BEG, while
1206 rmail had already narrowed the buffer. */
1207 if (XMARKER (w
->start
)->charpos
< BEGV
)
1208 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1209 else if (XMARKER (w
->start
)->charpos
> ZV
)
1210 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1212 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1214 start_display (&it
, w
, startp
);
1215 move_it_vertically (&it
, window_box_height (w
));
1216 if (it
.current_y
< it
.last_visible_y
)
1217 move_it_past_eol (&it
);
1218 value
= make_number (IT_CHARPOS (it
));
1221 set_buffer_internal (old_buffer
);
1224 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1229 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1230 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1233 Lisp_Object window
, pos
;
1235 register struct window
*w
= decode_window (window
);
1237 CHECK_NUMBER_COERCE_MARKER (pos
);
1238 if (w
== XWINDOW (selected_window
)
1239 && XBUFFER (w
->buffer
) == current_buffer
)
1242 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1244 /* We have to make sure that redisplay updates the window to show
1245 the new value of point. */
1246 if (!EQ (window
, selected_window
))
1247 ++windows_or_buffers_changed
;
1252 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1253 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1255 Optional third arg NOFORCE non-nil inhibits next redisplay
1256 from overriding motion of point in order to display at this exact start. */)
1257 (window
, pos
, noforce
)
1258 Lisp_Object window
, pos
, noforce
;
1260 register struct window
*w
= decode_window (window
);
1262 CHECK_NUMBER_COERCE_MARKER (pos
);
1263 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1264 /* this is not right, but much easier than doing what is right. */
1265 w
->start_at_line_beg
= Qnil
;
1267 w
->force_start
= Qt
;
1268 w
->update_mode_line
= Qt
;
1269 XSETFASTINT (w
->last_modified
, 0);
1270 XSETFASTINT (w
->last_overlay_modified
, 0);
1271 if (!EQ (window
, selected_window
))
1272 windows_or_buffers_changed
++;
1277 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1279 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1280 See also `set-window-dedicated-p'. */)
1284 return decode_window (window
)->dedicated
;
1287 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1288 Sset_window_dedicated_p
, 2, 2, 0,
1289 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1290 If it is dedicated, Emacs will not automatically change
1291 which buffer appears in it.
1292 The second argument is the new value for the dedication flag;
1293 non-nil means yes. */)
1295 Lisp_Object window
, arg
;
1297 register struct window
*w
= decode_window (window
);
1301 return w
->dedicated
;
1304 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1306 doc
: /* Return the display-table that WINDOW is using. */)
1310 return decode_window (window
)->display_table
;
1313 /* Get the display table for use on window W. This is either W's
1314 display table or W's buffer's display table. Ignore the specified
1315 tables if they are not valid; if no valid table is specified,
1318 struct Lisp_Char_Table
*
1319 window_display_table (w
)
1322 struct Lisp_Char_Table
*dp
= NULL
;
1324 if (DISP_TABLE_P (w
->display_table
))
1325 dp
= XCHAR_TABLE (w
->display_table
);
1326 else if (BUFFERP (w
->buffer
))
1328 struct buffer
*b
= XBUFFER (w
->buffer
);
1330 if (DISP_TABLE_P (b
->display_table
))
1331 dp
= XCHAR_TABLE (b
->display_table
);
1332 else if (DISP_TABLE_P (Vstandard_display_table
))
1333 dp
= XCHAR_TABLE (Vstandard_display_table
);
1339 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1340 doc
: /* Set WINDOW's display-table to TABLE. */)
1342 register Lisp_Object window
, table
;
1344 register struct window
*w
;
1346 w
= decode_window (window
);
1347 w
->display_table
= table
;
1351 /* Record info on buffer window w is displaying
1352 when it is about to cease to display that buffer. */
1355 register struct window
*w
;
1362 if (b
!= XMARKER (w
->pointm
)->buffer
)
1366 if (w
== XWINDOW (selected_window
)
1367 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1368 /* Do this except when the selected window's buffer
1369 is being removed from some other window. */
1371 /* last_window_start records the start position that this buffer
1372 had in the last window to be disconnected from it.
1373 Now that this statement is unconditional,
1374 it is possible for the buffer to be displayed in the
1375 selected window, while last_window_start reflects another
1376 window which was recently showing the same buffer.
1377 Some people might say that might be a good thing. Let's see. */
1378 b
->last_window_start
= marker_position (w
->start
);
1380 /* Point in the selected window's buffer
1381 is actually stored in that buffer, and the window's pointm isn't used.
1382 So don't clobber point in that buffer. */
1383 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1384 /* This line helps to fix Horsley's testbug.el bug. */
1385 && !(WINDOWP (b
->last_selected_window
)
1386 && w
!= XWINDOW (b
->last_selected_window
)
1387 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1388 temp_set_point_both (b
,
1389 clip_to_bounds (BUF_BEGV (b
),
1390 XMARKER (w
->pointm
)->charpos
,
1392 clip_to_bounds (BUF_BEGV_BYTE (b
),
1393 marker_byte_position (w
->pointm
),
1396 if (WINDOWP (b
->last_selected_window
)
1397 && w
== XWINDOW (b
->last_selected_window
))
1398 b
->last_selected_window
= Qnil
;
1401 /* Put replacement into the window structure in place of old. */
1403 replace_window (old
, replacement
)
1404 Lisp_Object old
, replacement
;
1406 register Lisp_Object tem
;
1407 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1409 /* If OLD is its frame's root_window, then replacement is the new
1410 root_window for that frame. */
1412 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1413 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1415 p
->left_col
= o
->left_col
;
1416 p
->top_line
= o
->top_line
;
1417 p
->total_cols
= o
->total_cols
;
1418 p
->total_lines
= o
->total_lines
;
1419 p
->desired_matrix
= p
->current_matrix
= 0;
1421 bzero (&p
->cursor
, sizeof (p
->cursor
));
1422 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1423 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1424 p
->phys_cursor_type
= -1;
1425 p
->phys_cursor_width
= -1;
1426 p
->must_be_updated_p
= 0;
1427 p
->pseudo_window_p
= 0;
1428 XSETFASTINT (p
->window_end_vpos
, 0);
1429 XSETFASTINT (p
->window_end_pos
, 0);
1430 p
->window_end_valid
= Qnil
;
1431 p
->frozen_window_start_p
= 0;
1432 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1434 p
->next
= tem
= o
->next
;
1436 XWINDOW (tem
)->prev
= replacement
;
1438 p
->prev
= tem
= o
->prev
;
1440 XWINDOW (tem
)->next
= replacement
;
1442 p
->parent
= tem
= o
->parent
;
1445 if (EQ (XWINDOW (tem
)->vchild
, old
))
1446 XWINDOW (tem
)->vchild
= replacement
;
1447 if (EQ (XWINDOW (tem
)->hchild
, old
))
1448 XWINDOW (tem
)->hchild
= replacement
;
1451 /*** Here, if replacement is a vertical combination
1452 and so is its new parent, we should make replacement's
1453 children be children of that parent instead. ***/
1456 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1457 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1459 register Lisp_Object window
;
1461 delete_window (window
);
1463 if (! NILP (Vwindow_configuration_change_hook
)
1464 && ! NILP (Vrun_hooks
))
1465 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1471 delete_window (window
)
1472 register Lisp_Object window
;
1474 register Lisp_Object tem
, parent
, sib
;
1475 register struct window
*p
;
1476 register struct window
*par
;
1479 /* Because this function is called by other C code on non-leaf
1480 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1481 so we can't decode_window here. */
1483 window
= selected_window
;
1485 CHECK_WINDOW (window
);
1486 p
= XWINDOW (window
);
1488 /* It's a no-op to delete an already-deleted window. */
1489 if (NILP (p
->buffer
)
1491 && NILP (p
->vchild
))
1496 error ("Attempt to delete minibuffer or sole ordinary window");
1497 par
= XWINDOW (parent
);
1499 windows_or_buffers_changed
++;
1500 Vwindow_list
= Qnil
;
1501 f
= XFRAME (WINDOW_FRAME (p
));
1502 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1504 /* Are we trying to delete any frame's selected window? */
1506 Lisp_Object swindow
, pwindow
;
1508 /* See if the frame's selected window is either WINDOW
1509 or any subwindow of it, by finding all that window's parents
1510 and comparing each one with WINDOW. */
1511 swindow
= FRAME_SELECTED_WINDOW (f
);
1516 while (!NILP (pwindow
))
1518 if (EQ (window
, pwindow
))
1520 pwindow
= XWINDOW (pwindow
)->parent
;
1523 /* If the window being deleted is not a parent of SWINDOW,
1524 then SWINDOW is ok as the new selected window. */
1525 if (!EQ (window
, pwindow
))
1527 /* Otherwise, try another window for SWINDOW. */
1528 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1530 /* If we get back to the frame's selected window,
1531 it means there was no acceptable alternative,
1532 so we cannot delete. */
1533 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1534 error ("Cannot delete window");
1537 /* If we need to change SWINDOW, do it. */
1538 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1540 /* If we're about to delete the selected window on the
1541 selected frame, then we should use Fselect_window to select
1542 the new window. On the other hand, if we're about to
1543 delete the selected window on any other frame, we shouldn't do
1544 anything but set the frame's selected_window slot. */
1545 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1546 Fselect_window (swindow
, Qnil
);
1548 FRAME_SELECTED_WINDOW (f
) = swindow
;
1552 /* Now we know we can delete this one. */
1553 window_deletion_count
++;
1556 /* tem is null for dummy parent windows
1557 (which have inferiors but not any contents themselves) */
1561 unchain_marker (XMARKER (p
->pointm
));
1562 unchain_marker (XMARKER (p
->start
));
1565 /* Free window glyph matrices. It is sure that they are allocated
1566 again when ADJUST_GLYPHS is called. Block input so that expose
1567 events and other events that access glyph matrices are not
1568 processed while we are changing them. */
1570 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1574 XWINDOW (tem
)->prev
= p
->prev
;
1578 XWINDOW (tem
)->next
= p
->next
;
1580 if (EQ (window
, par
->hchild
))
1581 par
->hchild
= p
->next
;
1582 if (EQ (window
, par
->vchild
))
1583 par
->vchild
= p
->next
;
1585 /* Find one of our siblings to give our space to. */
1589 /* If p gives its space to its next sibling, that sibling needs
1590 to have its top/left side pulled back to where p's is.
1591 set_window_{height,width} will re-position the sibling's
1594 XWINDOW (sib
)->top_line
= p
->top_line
;
1595 XWINDOW (sib
)->left_col
= p
->left_col
;
1598 /* Stretch that sibling. */
1599 if (!NILP (par
->vchild
))
1600 set_window_height (sib
,
1601 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1603 if (!NILP (par
->hchild
))
1604 set_window_width (sib
,
1605 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1608 /* If parent now has only one child,
1609 put the child into the parent's place. */
1613 if (NILP (XWINDOW (tem
)->next
)) {
1614 replace_window (parent
, tem
);
1615 par
= XWINDOW (tem
);
1618 /* Since we may be deleting combination windows, we must make sure that
1619 not only p but all its children have been marked as deleted. */
1620 if (! NILP (p
->hchild
))
1621 delete_all_subwindows (XWINDOW (p
->hchild
));
1622 else if (! NILP (p
->vchild
))
1623 delete_all_subwindows (XWINDOW (p
->vchild
));
1625 /* Mark this window as deleted. */
1626 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1628 if (! NILP (par
->parent
))
1629 par
= XWINDOW (par
->parent
);
1631 /* Check if we have a v/hchild with a v/hchild. In that case remove
1634 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1636 p
= XWINDOW (par
->vchild
);
1637 par
->vchild
= p
->vchild
;
1640 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1642 p
= XWINDOW (par
->hchild
);
1643 par
->hchild
= p
->hchild
;
1651 while (! NILP (tem
)) {
1652 XWINDOW (tem
)->parent
= p
->parent
;
1653 if (NILP (XWINDOW (tem
)->next
))
1655 tem
= XWINDOW (tem
)->next
;
1658 /* The next of the v/hchild we are removing is now the next of the
1659 last child for the v/hchild:
1660 Before v/hchild -> v/hchild -> next1 -> next2
1663 After: v/hchild -> next1 -> next2 -> next3
1665 XWINDOW (tem
)->next
= p
->next
;
1666 if (! NILP (p
->next
))
1667 XWINDOW (p
->next
)->prev
= tem
;
1669 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1673 /* Adjust glyph matrices. */
1680 /***********************************************************************
1682 ***********************************************************************/
1684 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1685 pointer. This is a callback function for foreach_window, used in
1686 function window_list. */
1689 add_window_to_list (w
, user_data
)
1693 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1695 XSETWINDOW (window
, w
);
1696 *list
= Fcons (window
, *list
);
1701 /* Return a list of all windows, for use by next_window. If
1702 Vwindow_list is a list, return that list. Otherwise, build a new
1703 list, cache it in Vwindow_list, and return that. */
1708 if (!CONSP (Vwindow_list
))
1712 Vwindow_list
= Qnil
;
1713 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1715 Lisp_Object args
[2];
1717 /* We are visiting windows in canonical order, and add
1718 new windows at the front of args[1], which means we
1719 have to reverse this list at the end. */
1721 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1722 args
[0] = Vwindow_list
;
1723 args
[1] = Fnreverse (args
[1]);
1724 Vwindow_list
= Fnconc (2, args
);
1728 return Vwindow_list
;
1732 /* Value is non-zero if WINDOW satisfies the constraints given by
1733 OWINDOW, MINIBUF and ALL_FRAMES.
1735 MINIBUF t means WINDOW may be minibuffer windows.
1736 `lambda' means WINDOW may not be a minibuffer window.
1737 a window means a specific minibuffer window
1739 ALL_FRAMES t means search all frames,
1740 nil means search just current frame,
1741 `visible' means search just visible frames,
1742 0 means search visible and iconified frames,
1743 a window means search the frame that window belongs to,
1744 a frame means consider windows on that frame, only. */
1747 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1748 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1750 struct window
*w
= XWINDOW (window
);
1751 struct frame
*f
= XFRAME (w
->frame
);
1752 int candidate_p
= 1;
1754 if (!BUFFERP (w
->buffer
))
1756 else if (MINI_WINDOW_P (w
)
1757 && (EQ (minibuf
, Qlambda
)
1758 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1760 /* If MINIBUF is `lambda' don't consider any mini-windows.
1761 If it is a window, consider only that one. */
1764 else if (EQ (all_frames
, Qt
))
1766 else if (NILP (all_frames
))
1768 xassert (WINDOWP (owindow
));
1769 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1771 else if (EQ (all_frames
, Qvisible
))
1773 FRAME_SAMPLE_VISIBILITY (f
);
1774 candidate_p
= FRAME_VISIBLE_P (f
);
1776 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1778 FRAME_SAMPLE_VISIBILITY (f
);
1779 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1781 else if (WINDOWP (all_frames
))
1782 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1783 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1784 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1785 else if (FRAMEP (all_frames
))
1786 candidate_p
= EQ (all_frames
, w
->frame
);
1792 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1793 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1797 decode_next_window_args (window
, minibuf
, all_frames
)
1798 Lisp_Object
*window
, *minibuf
, *all_frames
;
1801 *window
= selected_window
;
1803 CHECK_LIVE_WINDOW (*window
);
1805 /* MINIBUF nil may or may not include minibuffers. Decide if it
1807 if (NILP (*minibuf
))
1808 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1809 else if (!EQ (*minibuf
, Qt
))
1812 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1813 => count none of them, or a specific minibuffer window (the
1814 active one) to count. */
1816 /* ALL_FRAMES nil doesn't specify which frames to include. */
1817 if (NILP (*all_frames
))
1818 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1819 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1821 else if (EQ (*all_frames
, Qvisible
))
1823 else if (EQ (*all_frames
, make_number (0)))
1825 else if (FRAMEP (*all_frames
))
1827 else if (!EQ (*all_frames
, Qt
))
1830 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1831 search just current frame, `visible' meaning search just visible
1832 frames, 0 meaning search visible and iconified frames, or a
1833 window, meaning search the frame that window belongs to, or a
1834 frame, meaning consider windows on that frame, only. */
1838 /* Return the next or previous window of WINDOW in canonical ordering
1839 of windows. NEXT_P non-zero means return the next window. See the
1840 documentation string of next-window for the meaning of MINIBUF and
1844 next_window (window
, minibuf
, all_frames
, next_p
)
1845 Lisp_Object window
, minibuf
, all_frames
;
1848 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1850 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1851 return the first window on the frame. */
1852 if (FRAMEP (all_frames
)
1853 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1854 return Fframe_first_window (all_frames
);
1860 /* Find WINDOW in the list of all windows. */
1861 list
= Fmemq (window
, window_list ());
1863 /* Scan forward from WINDOW to the end of the window list. */
1865 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1866 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1869 /* Scan from the start of the window list up to WINDOW. */
1871 for (list
= Vwindow_list
;
1872 CONSP (list
) && !EQ (XCAR (list
), window
);
1874 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1878 window
= XCAR (list
);
1882 Lisp_Object candidate
, list
;
1884 /* Scan through the list of windows for candidates. If there are
1885 candidate windows in front of WINDOW, the last one of these
1886 is the one we want. If there are candidates following WINDOW
1887 in the list, again the last one of these is the one we want. */
1889 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1891 if (EQ (XCAR (list
), window
))
1893 if (WINDOWP (candidate
))
1896 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1898 candidate
= XCAR (list
);
1901 if (WINDOWP (candidate
))
1909 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1910 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1911 If omitted, WINDOW defaults to the selected window.
1913 Optional second arg MINIBUF t means count the minibuffer window even
1914 if not active. MINIBUF nil or omitted means count the minibuffer iff
1915 it is active. MINIBUF neither t nor nil means not to count the
1916 minibuffer even if it is active.
1918 Several frames may share a single minibuffer; if the minibuffer
1919 counts, all windows on all frames that share that minibuffer count
1920 too. Therefore, `next-window' can be used to iterate through the
1921 set of windows even when the minibuffer is on another frame. If the
1922 minibuffer does not count, only windows from WINDOW's frame count.
1924 Optional third arg ALL-FRAMES t means include windows on all frames.
1925 ALL-FRAMES nil or omitted means cycle within the frames as specified
1926 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1927 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1928 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1929 Anything else means restrict to WINDOW's frame.
1931 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1932 `next-window' to iterate through the entire cycle of acceptable
1933 windows, eventually ending up back at the window you started with.
1934 `previous-window' traverses the same cycle, in the reverse order. */)
1935 (window
, minibuf
, all_frames
)
1936 Lisp_Object window
, minibuf
, all_frames
;
1938 return next_window (window
, minibuf
, all_frames
, 1);
1942 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1943 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1944 If omitted, WINDOW defaults to the selected window.
1946 Optional second arg MINIBUF t means count the minibuffer window even
1947 if not active. MINIBUF nil or omitted means count the minibuffer iff
1948 it is active. MINIBUF neither t nor nil means not to count the
1949 minibuffer even if it is active.
1951 Several frames may share a single minibuffer; if the minibuffer
1952 counts, all windows on all frames that share that minibuffer count
1953 too. Therefore, `previous-window' can be used to iterate through
1954 the set of windows even when the minibuffer is on another frame. If
1955 the minibuffer does not count, only windows from WINDOW's frame count
1957 Optional third arg ALL-FRAMES t means include windows on all frames.
1958 ALL-FRAMES nil or omitted means cycle within the frames as specified
1959 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1960 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1961 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1962 Anything else means restrict to WINDOW's frame.
1964 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1965 `previous-window' to iterate through the entire cycle of acceptable
1966 windows, eventually ending up back at the window you started with.
1967 `next-window' traverses the same cycle, in the reverse order. */)
1968 (window
, minibuf
, all_frames
)
1969 Lisp_Object window
, minibuf
, all_frames
;
1971 return next_window (window
, minibuf
, all_frames
, 0);
1975 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1976 doc
: /* Select the ARG'th different window on this frame.
1977 All windows on current frame are arranged in a cyclic order.
1978 This command selects the window ARG steps away in that order.
1979 A negative ARG moves in the opposite order. The optional second
1980 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1982 Lisp_Object arg
, all_frames
;
1988 window
= selected_window
;
1990 for (i
= XINT (arg
); i
> 0; --i
)
1991 window
= Fnext_window (window
, Qnil
, all_frames
);
1993 window
= Fprevious_window (window
, Qnil
, all_frames
);
1995 Fselect_window (window
, Qnil
);
2000 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2001 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2002 FRAME nil or omitted means use the selected frame.
2003 WINDOW nil or omitted means use the selected window.
2004 MINIBUF t means include the minibuffer window, even if it isn't active.
2005 MINIBUF nil or omitted means include the minibuffer window only
2007 MINIBUF neither nil nor t means never include the minibuffer window. */)
2008 (frame
, minibuf
, window
)
2009 Lisp_Object frame
, minibuf
, window
;
2012 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2013 CHECK_WINDOW (window
);
2015 frame
= selected_frame
;
2017 if (!EQ (frame
, XWINDOW (window
)->frame
))
2018 error ("Window is on a different frame");
2020 return window_list_1 (window
, minibuf
, frame
);
2024 /* Return a list of windows in canonical ordering. Arguments are like
2025 for `next-window'. */
2028 window_list_1 (window
, minibuf
, all_frames
)
2029 Lisp_Object window
, minibuf
, all_frames
;
2031 Lisp_Object tail
, list
, rest
;
2033 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2036 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2037 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2038 list
= Fcons (XCAR (tail
), list
);
2040 /* Rotate the list to start with WINDOW. */
2041 list
= Fnreverse (list
);
2042 rest
= Fmemq (window
, list
);
2043 if (!NILP (rest
) && !EQ (rest
, list
))
2045 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2047 XSETCDR (tail
, Qnil
);
2048 list
= nconc2 (rest
, list
);
2055 /* Look at all windows, performing an operation specified by TYPE
2057 If FRAMES is Qt, look at all frames;
2058 Qnil, look at just the selected frame;
2059 Qvisible, look at visible frames;
2060 a frame, just look at windows on that frame.
2061 If MINI is non-zero, perform the operation on minibuffer windows too. */
2066 GET_BUFFER_WINDOW
, /* Arg is buffer */
2067 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2068 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2069 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2071 UNSHOW_BUFFER
, /* Arg is buffer */
2072 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2077 window_loop (type
, obj
, mini
, frames
)
2078 enum window_loop type
;
2079 Lisp_Object obj
, frames
;
2082 Lisp_Object window
, windows
, best_window
, frame_arg
;
2084 struct gcpro gcpro1
;
2086 /* If we're only looping through windows on a particular frame,
2087 frame points to that frame. If we're looping through windows
2088 on all frames, frame is 0. */
2089 if (FRAMEP (frames
))
2090 f
= XFRAME (frames
);
2091 else if (NILP (frames
))
2092 f
= SELECTED_FRAME ();
2097 frame_arg
= Qlambda
;
2098 else if (EQ (frames
, make_number (0)))
2100 else if (EQ (frames
, Qvisible
))
2105 /* frame_arg is Qlambda to stick to one frame,
2106 Qvisible to consider all visible frames,
2109 /* Pick a window to start with. */
2113 window
= FRAME_SELECTED_WINDOW (f
);
2115 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2117 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2121 for (; CONSP (windows
); windows
= XCDR (windows
))
2125 window
= XCAR (windows
);
2126 w
= XWINDOW (window
);
2128 /* Note that we do not pay attention here to whether the frame
2129 is visible, since Fwindow_list skips non-visible frames if
2130 that is desired, under the control of frame_arg. */
2131 if (!MINI_WINDOW_P (w
)
2132 /* For UNSHOW_BUFFER, we must always consider all windows. */
2133 || type
== UNSHOW_BUFFER
2134 || (mini
&& minibuf_level
> 0))
2137 case GET_BUFFER_WINDOW
:
2138 if (EQ (w
->buffer
, obj
)
2139 /* Don't find any minibuffer window
2140 except the one that is currently in use. */
2141 && (MINI_WINDOW_P (w
)
2142 ? EQ (window
, minibuf_window
)
2145 if (NILP (best_window
))
2146 best_window
= window
;
2147 else if (EQ (window
, selected_window
))
2148 /* For compatibility with 20.x, prefer to return
2150 best_window
= window
;
2154 case GET_LRU_WINDOW
:
2155 /* `obj' is an integer encoding a bitvector.
2156 `obj & 1' means consider only full-width windows.
2157 `obj & 2' means consider also dedicated windows. */
2158 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2159 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2160 /* Minibuffer windows are always ignored. */
2161 || MINI_WINDOW_P (w
))
2163 if (NILP (best_window
)
2164 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2165 > XFASTINT (w
->use_time
)))
2166 best_window
= window
;
2169 case DELETE_OTHER_WINDOWS
:
2170 if (!EQ (window
, obj
))
2171 Fdelete_window (window
);
2174 case DELETE_BUFFER_WINDOWS
:
2175 if (EQ (w
->buffer
, obj
))
2177 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2179 /* If this window is dedicated, and in a frame of its own,
2181 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2182 && !NILP (w
->dedicated
)
2183 && other_visible_frames (f
))
2185 /* Skip the other windows on this frame.
2186 There might be one, the minibuffer! */
2187 while (CONSP (XCDR (windows
))
2188 && EQ (XWINDOW (XCAR (windows
))->frame
,
2189 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2190 windows
= XCDR (windows
);
2192 /* Now we can safely delete the frame. */
2193 Fdelete_frame (w
->frame
, Qnil
);
2195 else if (NILP (w
->parent
))
2197 /* If we're deleting the buffer displayed in the
2198 only window on the frame, find a new buffer to
2201 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2202 Fset_window_buffer (window
, buffer
, Qnil
);
2203 if (EQ (window
, selected_window
))
2204 Fset_buffer (w
->buffer
);
2207 Fdelete_window (window
);
2211 case GET_LARGEST_WINDOW
:
2212 { /* nil `obj' means to ignore dedicated windows. */
2213 /* Ignore dedicated windows and minibuffers. */
2214 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2217 if (NILP (best_window
))
2218 best_window
= window
;
2221 struct window
*b
= XWINDOW (best_window
);
2222 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2223 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2224 best_window
= window
;
2230 if (EQ (w
->buffer
, obj
))
2233 struct frame
*f
= XFRAME (w
->frame
);
2235 /* Find another buffer to show in this window. */
2236 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2238 /* If this window is dedicated, and in a frame of its own,
2240 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2241 && !NILP (w
->dedicated
)
2242 && other_visible_frames (f
))
2244 /* Skip the other windows on this frame.
2245 There might be one, the minibuffer! */
2246 while (CONSP (XCDR (windows
))
2247 && EQ (XWINDOW (XCAR (windows
))->frame
,
2248 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2249 windows
= XCDR (windows
);
2251 /* Now we can safely delete the frame. */
2252 Fdelete_frame (w
->frame
, Qnil
);
2254 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2257 XSETWINDOW (window
, w
);
2258 /* If this window is dedicated and not the only window
2259 in its frame, then kill it. */
2260 Fdelete_window (window
);
2264 /* Otherwise show a different buffer in the window. */
2265 w
->dedicated
= Qnil
;
2266 Fset_window_buffer (window
, buffer
, Qnil
);
2267 if (EQ (window
, selected_window
))
2268 Fset_buffer (w
->buffer
);
2273 case REDISPLAY_BUFFER_WINDOWS
:
2274 if (EQ (w
->buffer
, obj
))
2276 mark_window_display_accurate (window
, 0);
2277 w
->update_mode_line
= Qt
;
2278 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2279 ++update_mode_lines
;
2280 best_window
= window
;
2284 /* Check for a window that has a killed buffer. */
2285 case CHECK_ALL_WINDOWS
:
2286 if (! NILP (w
->buffer
)
2287 && NILP (XBUFFER (w
->buffer
)->name
))
2291 case WINDOW_LOOP_UNUSED
:
2300 /* Used for debugging. Abort if any window has a dead buffer. */
2303 check_all_windows ()
2305 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2308 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2309 doc
: /* Return the window least recently selected or used for display.
2310 Return a full-width window if possible.
2311 A minibuffer window is never a candidate.
2312 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2313 so if all windows are dedicated, the value is nil.
2314 If optional argument FRAME is `visible', search all visible frames.
2315 If FRAME is 0, search all visible and iconified frames.
2316 If FRAME is t, search all frames.
2317 If FRAME is nil, search only the selected frame.
2318 If FRAME is a frame, search only that frame. */)
2320 Lisp_Object frame
, dedicated
;
2322 register Lisp_Object w
;
2323 /* First try for a window that is full-width */
2324 w
= window_loop (GET_LRU_WINDOW
,
2325 NILP (dedicated
) ? make_number (1) : make_number (3),
2327 if (!NILP (w
) && !EQ (w
, selected_window
))
2329 /* If none of them, try the rest */
2330 return window_loop (GET_LRU_WINDOW
,
2331 NILP (dedicated
) ? make_number (0) : make_number (2),
2335 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2336 doc
: /* Return the largest window in area.
2337 A minibuffer window is never a candidate.
2338 A dedicated window is never a candidate unless DEDICATED is non-nil,
2339 so if all windows are dedicated, the value is nil.
2340 If optional argument FRAME is `visible', search all visible frames.
2341 If FRAME is 0, search all visible and iconified frames.
2342 If FRAME is t, search all frames.
2343 If FRAME is nil, search only the selected frame.
2344 If FRAME is a frame, search only that frame. */)
2346 Lisp_Object frame
, dedicated
;
2348 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2352 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2353 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2354 BUFFER can be a buffer or a buffer name.
2355 If optional argument FRAME is `visible', search all visible frames.
2356 If optional argument FRAME is 0, search all visible and iconified frames.
2357 If FRAME is t, search all frames.
2358 If FRAME is nil, search only the selected frame.
2359 If FRAME is a frame, search only that frame. */)
2361 Lisp_Object buffer
, frame
;
2363 buffer
= Fget_buffer (buffer
);
2364 if (BUFFERP (buffer
))
2365 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2370 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2372 doc
: /* Make WINDOW (or the selected window) fill its frame.
2373 Only the frame WINDOW is on is affected.
2374 This function tries to reduce display jumps
2375 by keeping the text previously visible in WINDOW
2376 in the same place on the frame. Doing this depends on
2377 the value of (window-start WINDOW), so if calling this function
2378 in a program gives strange scrolling, make sure the window-start
2379 value is reasonable when this function is called. */)
2388 window
= selected_window
;
2390 CHECK_LIVE_WINDOW (window
);
2391 w
= XWINDOW (window
);
2393 startpos
= marker_position (w
->start
);
2394 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2396 if (MINI_WINDOW_P (w
) && top
> 0)
2397 error ("Can't expand minibuffer to full frame");
2399 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2401 /* Try to minimize scrolling, by setting the window start to the point
2402 will cause the text at the old window start to be at the same place
2403 on the frame. But don't try to do this if the window start is
2404 outside the visible portion (as might happen when the display is
2405 not current, due to typeahead). */
2406 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2408 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2409 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2411 struct position pos
;
2412 struct buffer
*obuf
= current_buffer
;
2414 Fset_buffer (w
->buffer
);
2415 /* This computation used to temporarily move point, but that can
2416 have unwanted side effects due to text properties. */
2417 pos
= *vmotion (startpos
, -top
, w
);
2419 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2420 w
->window_end_valid
= Qnil
;
2421 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2422 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2424 /* We need to do this, so that the window-scroll-functions
2426 w
->optional_new_start
= Qt
;
2428 set_buffer_internal (obuf
);
2434 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2435 1, 2, "bDelete windows on (buffer): ",
2436 doc
: /* Delete all windows showing BUFFER.
2437 BUFFER must be a buffer or the name of an existing buffer.
2438 Optional second argument FRAME controls which frames are affected.
2439 If optional argument FRAME is `visible', search all visible frames.
2440 If FRAME is 0, search all visible and iconified frames.
2441 If FRAME is nil, search all frames.
2442 If FRAME is t, search only the selected frame.
2443 If FRAME is a frame, search only that frame. */)
2445 Lisp_Object buffer
, frame
;
2447 /* FRAME uses t and nil to mean the opposite of what window_loop
2451 else if (EQ (frame
, Qt
))
2456 buffer
= Fget_buffer (buffer
);
2457 CHECK_BUFFER (buffer
);
2458 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2464 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2465 Sreplace_buffer_in_windows
,
2466 1, 1, "bReplace buffer in windows: ",
2467 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2468 BUFFER may be a buffer or the name of an existing buffer. */)
2474 buffer
= Fget_buffer (buffer
);
2475 CHECK_BUFFER (buffer
);
2476 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2481 /* Replace BUFFER with some other buffer in all windows
2482 of all frames, even those on other keyboards. */
2485 replace_buffer_in_all_windows (buffer
)
2489 Lisp_Object tail
, frame
;
2491 /* A single call to window_loop won't do the job
2492 because it only considers frames on the current keyboard.
2493 So loop manually over frames, and handle each one. */
2494 FOR_EACH_FRAME (tail
, frame
)
2495 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2497 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2501 /* Set the height of WINDOW and all its inferiors. */
2503 /* The smallest acceptable dimensions for a window. Anything smaller
2504 might crash Emacs. */
2506 #define MIN_SAFE_WINDOW_WIDTH (2)
2507 #define MIN_SAFE_WINDOW_HEIGHT (1)
2509 /* Make sure that window_min_height and window_min_width are
2510 not too small; if they are, set them to safe minima. */
2513 check_min_window_sizes ()
2515 /* Smaller values might permit a crash. */
2516 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2517 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2518 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2519 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2522 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2523 minimum allowable size. */
2526 check_frame_size (frame
, rows
, cols
)
2530 /* For height, we have to see:
2531 how many windows the frame has at minimum (one or two),
2532 and whether it has a menu bar or other special stuff at the top. */
2534 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2535 ? MIN_SAFE_WINDOW_HEIGHT
2536 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2538 if (FRAME_TOP_MARGIN (frame
) > 0)
2539 min_height
+= FRAME_TOP_MARGIN (frame
);
2541 if (*rows
< min_height
)
2543 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2544 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2548 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2549 check if W's width can be changed, otherwise check W's height.
2550 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2551 siblings, too. If none of the siblings is resizable, WINDOW isn't
2555 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2557 int width_p
, check_siblings_p
;
2562 if (!NILP (w
->hchild
))
2564 c
= XWINDOW (w
->hchild
);
2568 /* A horiz. combination is fixed-width if all of if its
2570 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2571 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2572 fixed_p
= c
== NULL
;
2576 /* A horiz. combination is fixed-height if one of if its
2578 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2579 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2580 fixed_p
= c
!= NULL
;
2583 else if (!NILP (w
->vchild
))
2585 c
= XWINDOW (w
->vchild
);
2589 /* A vert. combination is fixed-width if one of if its
2591 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2592 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2593 fixed_p
= c
!= NULL
;
2597 /* A vert. combination is fixed-height if all of if its
2599 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2600 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2601 fixed_p
= c
== NULL
;
2604 else if (BUFFERP (w
->buffer
))
2606 struct buffer
*old
= current_buffer
;
2609 current_buffer
= XBUFFER (w
->buffer
);
2610 val
= find_symbol_value (Qwindow_size_fixed
);
2611 current_buffer
= old
;
2614 if (!EQ (val
, Qunbound
))
2616 fixed_p
= !NILP (val
);
2619 && ((EQ (val
, Qheight
) && width_p
)
2620 || (EQ (val
, Qwidth
) && !width_p
)))
2624 /* Can't tell if this one is resizable without looking at
2625 siblings. If all siblings are fixed-size this one is too. */
2626 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2630 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2631 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2635 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2636 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2650 /* Return the minimum size of window W, not taking fixed-width windows
2651 into account. WIDTH_P non-zero means return the minimum width,
2652 otherwise return the minimum height. If W is a combination window,
2653 compute the minimum size from the minimum sizes of W's children. */
2656 window_min_size_1 (w
, width_p
)
2663 if (!NILP (w
->hchild
))
2665 c
= XWINDOW (w
->hchild
);
2670 /* The min width of a horizontal combination is
2671 the sum of the min widths of its children. */
2674 size
+= window_min_size_1 (c
, width_p
);
2675 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2680 /* The min height a horizontal combination equals
2681 the maximum of all min height of its children. */
2684 int min_size
= window_min_size_1 (c
, width_p
);
2685 size
= max (min_size
, size
);
2686 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2690 else if (!NILP (w
->vchild
))
2692 c
= XWINDOW (w
->vchild
);
2697 /* The min width of a vertical combination is
2698 the maximum of the min widths of its children. */
2701 int min_size
= window_min_size_1 (c
, width_p
);
2702 size
= max (min_size
, size
);
2703 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2708 /* The min height of a vertical combination equals
2709 the sum of the min height of its children. */
2712 size
+= window_min_size_1 (c
, width_p
);
2713 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2720 size
= max (window_min_width
,
2721 (MIN_SAFE_WINDOW_WIDTH
2722 + WINDOW_FRINGE_COLS (w
)
2723 + WINDOW_SCROLL_BAR_COLS (w
)));
2726 if (MINI_WINDOW_P (w
)
2727 || (!WINDOW_WANTS_MODELINE_P (w
)
2728 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2731 size
= window_min_height
;
2739 /* Return the minimum size of window W, taking fixed-size windows into
2740 account. WIDTH_P non-zero means return the minimum width,
2741 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2742 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2743 unless FIXED is null. */
2746 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2748 int width_p
, ignore_fixed_p
, *fixed
;
2755 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2761 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2763 size
= window_min_size_1 (w
, width_p
);
2769 /* Adjust the margins of window W if text area is too small.
2770 Return 1 if window width is ok after adjustment; 0 if window
2771 is still too narrow. */
2774 adjust_window_margins (w
)
2777 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2778 - WINDOW_FRINGE_COLS (w
)
2779 - WINDOW_SCROLL_BAR_COLS (w
));
2780 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2781 + WINDOW_RIGHT_MARGIN_COLS (w
));
2783 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2786 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2789 /* Window's text area is too narrow, but reducing the window
2790 margins will fix that. */
2791 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2792 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2794 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2795 w
->left_margin_cols
= w
->right_margin_cols
2796 = make_number (margin_cols
/2);
2798 w
->right_margin_cols
= make_number (margin_cols
);
2801 w
->left_margin_cols
= make_number (margin_cols
);
2805 /* Calculate new sizes for windows in the list FORWARD when the window size
2806 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2807 The number of windows in FORWARD is NCHILDREN, and the number that
2808 can shrink is SHRINKABLE.
2809 The minimum size a window can have is MIN_SIZE.
2810 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2811 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2814 This function returns an allocated array of new sizes that the caller
2815 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2816 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2817 the second, and so on.
2819 This function tries to keep windows at least at the minimum size
2820 and resize other windows before it resizes any window to zero (i.e.
2821 delete that window).
2823 Windows are resized proportional to their size, so bigger windows
2824 shrink more than smaller windows. */
2826 shrink_windows (total
, size
, nchildren
, shrinkable
,
2827 min_size
, resize_fixed_p
, forward
, width_p
)
2828 int total
, size
, nchildren
, shrinkable
, min_size
;
2829 int resize_fixed_p
, width_p
;
2830 Lisp_Object forward
;
2832 int available_resize
= 0;
2836 int smallest
= total
;
2837 int total_removed
= 0;
2838 int total_shrink
= total
- size
;
2841 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2843 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2847 c
= XWINDOW (child
);
2848 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2850 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2854 new_sizes
[i
] = child_size
;
2855 if (child_size
> min_size
)
2856 available_resize
+= child_size
- min_size
;
2859 /* We might need to shrink some windows to zero. Find the smallest
2860 windows and set them to 0 until we can fulfil the new size. */
2862 while (shrinkable
> 1 && size
+ available_resize
< total
)
2864 for (i
= 0; i
< nchildren
; ++i
)
2865 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2866 smallest
= new_sizes
[i
];
2868 for (i
= 0; i
< nchildren
; ++i
)
2869 if (new_sizes
[i
] == smallest
)
2871 /* Resize this window down to zero. */
2873 if (smallest
> min_size
)
2874 available_resize
-= smallest
- min_size
;
2875 available_resize
+= smallest
;
2877 total_removed
+= smallest
;
2879 /* We don't know what the smallest is now. */
2882 /* Out of for, just remove one window at the time and
2883 check again if we have enough space. */
2888 /* Now, calculate the new sizes. Try to shrink each window
2889 proportional to its size. */
2890 for (i
= 0; i
< nchildren
; ++i
)
2892 if (new_sizes
[i
] > min_size
)
2894 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2895 if (new_sizes
[i
] - to_shrink
< min_size
)
2896 to_shrink
= new_sizes
[i
] - min_size
;
2897 new_sizes
[i
] -= to_shrink
;
2898 total_removed
+= to_shrink
;
2902 /* Any reminder due to rounding, we just subtract from windows
2903 that are left and still can be shrunk. */
2904 while (total_shrink
> total_removed
)
2906 int nonzero_sizes
= 0;
2907 int nonzero_idx
= -1;
2909 for (i
= 0; i
< nchildren
; ++i
)
2910 if (new_sizes
[i
] > 0)
2916 for (i
= 0; i
< nchildren
; ++i
)
2917 if (new_sizes
[i
] > min_size
)
2922 /* Out of for, just shrink one window at the time and
2923 check again if we have enough space. */
2928 /* Special case, only one window left. */
2929 if (nonzero_sizes
== 1)
2933 /* Any surplus due to rounding, we add to windows that are left. */
2934 while (total_shrink
< total_removed
)
2936 for (i
= 0; i
< nchildren
; ++i
)
2938 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2950 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2951 WINDOW's width. Resize WINDOW's children, if any, so that they
2952 keep their proportionate size relative to WINDOW.
2954 If FIRST_ONLY is 1, change only the first of WINDOW's children when
2955 they are in series. If LAST_ONLY is 1, change only the last of
2956 WINDOW's children when they are in series.
2958 Propagate WINDOW's top or left edge position to children. Delete
2959 windows that become too small unless NODELETE_P is non-zero.
2961 If NODELETE_P is 2, that means we do delete windows that are
2962 too small, even if they were too small before! */
2965 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
2967 int size
, width_p
, nodelete_p
;
2968 int first_only
, last_only
;
2970 struct window
*w
= XWINDOW (window
);
2972 Lisp_Object child
, *forward
, *sideward
;
2973 int old_size
, min_size
, safe_min_size
;
2975 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2976 seems like it's too soon to do this here. ++KFS. */
2977 if (nodelete_p
== 2)
2980 check_min_window_sizes ();
2981 size
= max (0, size
);
2983 /* If the window has been "too small" at one point,
2984 don't delete it for being "too small" in the future.
2985 Preserve it as long as that is at all possible. */
2988 old_size
= WINDOW_TOTAL_COLS (w
);
2989 min_size
= window_min_width
;
2990 /* Ensure that there is room for the scroll bar and fringes!
2991 We may reduce display margins though. */
2992 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2993 + WINDOW_FRINGE_COLS (w
)
2994 + WINDOW_SCROLL_BAR_COLS (w
));
2998 old_size
= XINT (w
->total_lines
);
2999 min_size
= window_min_height
;
3000 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
3003 if (old_size
< min_size
&& nodelete_p
!= 2)
3004 w
->too_small_ok
= Qt
;
3006 /* Maybe delete WINDOW if it's too small. */
3007 if (nodelete_p
!= 1 && !NILP (w
->parent
))
3009 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
3010 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
3011 if (min_size
< safe_min_size
)
3012 min_size
= safe_min_size
;
3013 if (size
< min_size
)
3015 delete_window (window
);
3020 /* Set redisplay hints. */
3021 w
->last_modified
= make_number (0);
3022 w
->last_overlay_modified
= make_number (0);
3023 windows_or_buffers_changed
++;
3024 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3028 sideward
= &w
->vchild
;
3029 forward
= &w
->hchild
;
3030 w
->total_cols
= make_number (size
);
3031 adjust_window_margins (w
);
3035 sideward
= &w
->hchild
;
3036 forward
= &w
->vchild
;
3037 w
->total_lines
= make_number (size
);
3038 w
->orig_total_lines
= Qnil
;
3041 if (!NILP (*sideward
))
3043 /* We have a chain of parallel siblings whose size should all change. */
3044 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3046 c
= XWINDOW (child
);
3048 c
->left_col
= w
->left_col
;
3050 c
->top_line
= w
->top_line
;
3051 size_window (child
, size
, width_p
, nodelete_p
,
3052 first_only
, last_only
);
3055 else if (!NILP (*forward
) && last_only
)
3057 /* Change the last in a series of siblings. */
3058 Lisp_Object last_child
;
3061 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3063 c
= XWINDOW (child
);
3067 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3068 size_window (last_child
,
3069 size
- old_size
+ child_size
,
3070 width_p
, nodelete_p
, first_only
, last_only
);
3072 else if (!NILP (*forward
) && first_only
)
3074 /* Change the first in a series of siblings. */
3078 c
= XWINDOW (child
);
3081 c
->left_col
= w
->left_col
;
3083 c
->top_line
= w
->top_line
;
3085 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3087 size
- old_size
+ child_size
,
3088 width_p
, nodelete_p
, first_only
, last_only
);
3090 else if (!NILP (*forward
))
3092 int fixed_size
, each
, extra
, n
;
3093 int resize_fixed_p
, nfixed
;
3094 int last_pos
, first_pos
, nchildren
, total
;
3095 int *new_sizes
= NULL
;
3097 /* Determine the fixed-size portion of this window, and the
3098 number of child windows. */
3099 fixed_size
= nchildren
= nfixed
= total
= 0;
3100 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3104 c
= XWINDOW (child
);
3105 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3106 total
+= child_size
;
3108 if (window_fixed_size_p (c
, width_p
, 0))
3110 fixed_size
+= child_size
;
3115 /* If the new size is smaller than fixed_size, or if there
3116 aren't any resizable windows, allow resizing fixed-size
3118 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3120 /* Compute how many lines/columns to add/remove to each child. The
3121 value of extra takes care of rounding errors. */
3122 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3123 if (size
< total
&& n
> 1)
3124 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
3125 resize_fixed_p
, *forward
, width_p
);
3128 each
= (size
- total
) / n
;
3129 extra
= (size
- total
) - n
* each
;
3132 /* Compute new children heights and edge positions. */
3133 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3134 last_pos
= first_pos
;
3135 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3137 int new_size
, old_size
;
3139 c
= XWINDOW (child
);
3140 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
3141 new_size
= old_size
;
3143 /* The top or left edge position of this child equals the
3144 bottom or right edge of its predecessor. */
3146 c
->left_col
= make_number (last_pos
);
3148 c
->top_line
= make_number (last_pos
);
3150 /* If this child can be resized, do it. */
3151 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3153 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3157 /* Set new height. Note that size_window also propagates
3158 edge positions to children, so it's not a no-op if we
3159 didn't change the child's size. */
3160 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3162 /* Remember the bottom/right edge position of this child; it
3163 will be used to set the top/left edge of the next child. */
3164 last_pos
+= new_size
;
3167 if (new_sizes
) xfree (new_sizes
);
3169 /* We should have covered the parent exactly with child windows. */
3170 xassert (size
== last_pos
- first_pos
);
3172 /* Now delete any children that became too small. */
3174 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3177 c
= XWINDOW (child
);
3178 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3179 size_window (child
, child_size
, width_p
, 2, first_only
, last_only
);
3184 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3185 WINDOW's children. NODELETE non-zero means don't delete windows
3186 that become too small in the process. (The caller should check
3187 later and do so if appropriate.) */
3190 set_window_height (window
, height
, nodelete
)
3195 size_window (window
, height
, 0, nodelete
, 0, 0);
3199 /* Set WINDOW's width to WIDTH, and recursively change the width of
3200 WINDOW's children. NODELETE non-zero means don't delete windows
3201 that become too small in the process. (The caller should check
3202 later and do so if appropriate.) */
3205 set_window_width (window
, width
, nodelete
)
3210 size_window (window
, width
, 1, nodelete
, 0, 0);
3213 /* Change window heights in windows rooted in WINDOW by N lines. */
3216 change_window_heights (window
, n
)
3220 struct window
*w
= XWINDOW (window
);
3222 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3223 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3225 if (INTEGERP (w
->orig_top_line
))
3226 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3227 if (INTEGERP (w
->orig_total_lines
))
3228 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3230 /* Handle just the top child in a vertical split. */
3231 if (!NILP (w
->vchild
))
3232 change_window_heights (w
->vchild
, n
);
3234 /* Adjust all children in a horizontal split. */
3235 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3237 w
= XWINDOW (window
);
3238 change_window_heights (window
, n
);
3243 int window_select_count
;
3246 Fset_window_buffer_unwind (obuf
)
3253 EXFUN (Fset_window_fringes
, 4);
3254 EXFUN (Fset_window_scroll_bars
, 4);
3256 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3257 means it's allowed to run hooks. See make_frame for a case where
3258 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3259 margins, fringes, and scroll-bar settings of the window are not
3260 reset from the buffer's local settings. */
3263 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3264 Lisp_Object window
, buffer
;
3265 int run_hooks_p
, keep_margins_p
;
3267 struct window
*w
= XWINDOW (window
);
3268 struct buffer
*b
= XBUFFER (buffer
);
3269 int count
= SPECPDL_INDEX ();
3270 #ifdef HAVE_WINDOW_SYSTEM
3271 struct frame
*f
= XFRAME (w
->frame
);
3272 Display_Info
*dpyinfo
;
3277 if (EQ (window
, selected_window
))
3278 b
->last_selected_window
= window
;
3280 /* Let redisplay errors through. */
3281 b
->display_error_modiff
= 0;
3283 /* Update time stamps of buffer display. */
3284 if (INTEGERP (b
->display_count
))
3285 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3286 b
->display_time
= Fcurrent_time ();
3288 XSETFASTINT (w
->window_end_pos
, 0);
3289 XSETFASTINT (w
->window_end_vpos
, 0);
3290 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3291 w
->window_end_valid
= Qnil
;
3292 w
->hscroll
= w
->min_hscroll
= make_number (0);
3294 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3295 set_marker_restricted (w
->start
,
3296 make_number (b
->last_window_start
),
3298 w
->start_at_line_beg
= Qnil
;
3299 w
->force_start
= Qnil
;
3300 XSETFASTINT (w
->last_modified
, 0);
3301 XSETFASTINT (w
->last_overlay_modified
, 0);
3302 windows_or_buffers_changed
++;
3304 /* We must select BUFFER for running the window-scroll-functions.
3305 If WINDOW is selected, switch permanently.
3306 Otherwise, switch but go back to the ambient buffer afterward. */
3307 if (EQ (window
, selected_window
))
3308 Fset_buffer (buffer
);
3309 /* We can't check ! NILP (Vwindow_scroll_functions) here
3310 because that might itself be a local variable. */
3311 else if (window_initialized
)
3313 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3314 Fset_buffer (buffer
);
3317 if (!keep_margins_p
)
3319 /* Set left and right marginal area width etc. from buffer. */
3321 /* This may call adjust_window_margins three times, so
3322 temporarily disable window margins. */
3323 Lisp_Object save_left
= w
->left_margin_cols
;
3324 Lisp_Object save_right
= w
->right_margin_cols
;
3326 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3328 Fset_window_fringes (window
,
3329 b
->left_fringe_width
, b
->right_fringe_width
,
3330 b
->fringes_outside_margins
);
3332 Fset_window_scroll_bars (window
,
3333 b
->scroll_bar_width
,
3334 b
->vertical_scroll_bar_type
, Qnil
);
3336 w
->left_margin_cols
= save_left
;
3337 w
->right_margin_cols
= save_right
;
3339 Fset_window_margins (window
,
3340 b
->left_margin_cols
, b
->right_margin_cols
);
3345 if (! NILP (Vwindow_scroll_functions
))
3346 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3347 Fmarker_position (w
->start
));
3349 if (! NILP (Vwindow_configuration_change_hook
)
3350 && ! NILP (Vrun_hooks
))
3351 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3354 #ifdef HAVE_WINDOW_SYSTEM
3356 if (f
&& FRAME_X_OUTPUT (f
)
3357 && (dpyinfo
= FRAME_X_DISPLAY_INFO (f
))
3358 && EQ (window
, dpyinfo
->mouse_face_window
))
3359 clear_mouse_face (dpyinfo
);
3363 unbind_to (count
, Qnil
);
3367 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3368 doc
: /* Make WINDOW display BUFFER as its contents.
3369 BUFFER can be a buffer or the name of an existing buffer.
3370 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3371 display margins, fringe widths, and scroll bar settings are maintained;
3372 the default is to reset these from BUFFER's local settings or the frame
3375 This function runs the hook `window-scroll-functions'. */)
3376 (window
, buffer
, keep_margins
)
3377 register Lisp_Object window
, buffer
, keep_margins
;
3379 register Lisp_Object tem
;
3380 register struct window
*w
= decode_window (window
);
3382 XSETWINDOW (window
, w
);
3383 buffer
= Fget_buffer (buffer
);
3384 CHECK_BUFFER (buffer
);
3386 if (NILP (XBUFFER (buffer
)->name
))
3387 error ("Attempt to display deleted buffer");
3391 error ("Window is deleted");
3392 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3393 is first being set up. */
3395 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3396 error ("Window is dedicated to `%s'",
3397 SDATA (XBUFFER (tem
)->name
));
3402 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3406 /* Note that selected_window can be nil
3407 when this is called from Fset_window_configuration. */
3409 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3410 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3411 If WINDOW is not already selected, make WINDOW's buffer current
3412 and make WINDOW the frame's selected window. Return WINDOW.
3413 Optional second arg NORECORD non-nil means
3414 do not put this buffer at the front of the list of recently selected ones.
3416 Note that the main editor command loop
3417 selects the buffer of the selected window before each command. */)
3419 register Lisp_Object window
, norecord
;
3421 register struct window
*w
;
3422 register struct window
*ow
;
3425 CHECK_LIVE_WINDOW (window
);
3427 w
= XWINDOW (window
);
3428 w
->frozen_window_start_p
= 0;
3430 ++window_select_count
;
3431 XSETFASTINT (w
->use_time
, window_select_count
);
3432 if (EQ (window
, selected_window
))
3435 /* Store the current buffer's actual point into the
3436 old selected window. It belongs to that window,
3437 and when the window is not selected, must be in the window. */
3438 if (!NILP (selected_window
))
3440 ow
= XWINDOW (selected_window
);
3441 if (! NILP (ow
->buffer
))
3442 set_marker_both (ow
->pointm
, ow
->buffer
,
3443 BUF_PT (XBUFFER (ow
->buffer
)),
3444 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3447 selected_window
= window
;
3448 sf
= SELECTED_FRAME ();
3449 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3451 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3452 /* Use this rather than Fhandle_switch_frame
3453 so that FRAME_FOCUS_FRAME is moved appropriately as we
3454 move around in the state where a minibuffer in a separate
3456 Fselect_frame (WINDOW_FRAME (w
));
3459 sf
->selected_window
= window
;
3461 if (NILP (norecord
))
3462 record_buffer (w
->buffer
);
3463 Fset_buffer (w
->buffer
);
3465 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3467 /* Go to the point recorded in the window.
3468 This is important when the buffer is in more
3469 than one window. It also matters when
3470 redisplay_window has altered point after scrolling,
3471 because it makes the change only in the window. */
3473 register int new_point
= marker_position (w
->pointm
);
3474 if (new_point
< BEGV
)
3476 else if (new_point
> ZV
)
3482 windows_or_buffers_changed
++;
3487 select_window_norecord (window
)
3490 return Fselect_window (window
, Qt
);
3493 /* Deiconify the frame containing the window WINDOW,
3494 unless it is the selected frame;
3497 The reason for the exception for the selected frame
3498 is that it seems better not to change the selected frames visibility
3499 merely because of displaying a different buffer in it.
3500 The deiconification is useful when a buffer gets shown in
3501 another frame that you were not using lately. */
3504 display_buffer_1 (window
)
3507 Lisp_Object frame
= XWINDOW (window
)->frame
;
3508 FRAME_PTR f
= XFRAME (frame
);
3510 FRAME_SAMPLE_VISIBILITY (f
);
3512 if (EQ (frame
, selected_frame
))
3513 ; /* Assume the selected frame is already visible enough. */
3514 else if (minibuf_level
> 0
3515 && MINI_WINDOW_P (XWINDOW (selected_window
))
3516 && WINDOW_LIVE_P (minibuf_selected_window
)
3517 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3518 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3521 if (FRAME_ICONIFIED_P (f
))
3522 Fmake_frame_visible (frame
);
3523 else if (FRAME_VISIBLE_P (f
))
3524 Fraise_frame (frame
);
3530 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3531 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3532 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3533 special frame for that buffer using the default frame parameters.
3535 If the value is a list, it is a list of frame parameters that would be used
3536 to make a frame for that buffer.
3537 The variables `special-display-buffer-names'
3538 and `special-display-regexps' control this. */)
3540 Lisp_Object buffer_name
;
3544 CHECK_STRING (buffer_name
);
3546 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3550 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3554 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3556 Lisp_Object car
= XCAR (tem
);
3558 && fast_string_match (car
, buffer_name
) >= 0)
3560 else if (CONSP (car
)
3561 && STRINGP (XCAR (car
))
3562 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3568 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3569 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3570 More precisely, if `display-buffer' or `pop-to-buffer' would display
3571 that buffer in the selected window rather than (as usual) in some other window.
3572 See `same-window-buffer-names' and `same-window-regexps'. */)
3574 Lisp_Object buffer_name
;
3578 CHECK_STRING (buffer_name
);
3580 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3584 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3588 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3590 Lisp_Object car
= XCAR (tem
);
3592 && fast_string_match (car
, buffer_name
) >= 0)
3594 else if (CONSP (car
)
3595 && STRINGP (XCAR (car
))
3596 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3602 /* Use B so the default is (other-buffer). */
3603 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3604 "BDisplay buffer: \nP",
3605 doc
: /* Make BUFFER appear in some window but don't select it.
3606 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3608 If BUFFER is shown already in some window, just use that one,
3609 unless the window is the selected window and the optional second
3610 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3611 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3612 Returns the window displaying BUFFER.
3613 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3614 displaying BUFFER, then simply raise that frame.
3616 The variables `special-display-buffer-names',
3617 `special-display-regexps', `same-window-buffer-names', and
3618 `same-window-regexps' customize how certain buffer names are handled.
3619 The latter two take effect only if NOT-THIS-WINDOW is nil.
3621 If optional argument FRAME is `visible', search all visible frames.
3622 If FRAME is 0, search all visible and iconified frames.
3623 If FRAME is t, search all frames.
3624 If FRAME is a frame, search only that frame.
3625 If FRAME is nil, search only the selected frame
3626 (actually the last nonminibuffer frame),
3627 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3628 which means search visible and iconified frames.
3630 If a full-width window on a splittable frame is available to display
3631 the buffer, it may be split, subject to the value of the variable
3632 `split-height-threshold'.
3634 If `even-window-heights' is non-nil, window heights will be evened out
3635 if displaying the buffer causes two vertically adjacent windows to be
3637 (buffer
, not_this_window
, frame
)
3638 register Lisp_Object buffer
, not_this_window
, frame
;
3640 register Lisp_Object window
, tem
, swp
;
3644 buffer
= Fget_buffer (buffer
);
3645 CHECK_BUFFER (buffer
);
3647 if (!NILP (Vdisplay_buffer_function
))
3648 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3650 if (NILP (not_this_window
)
3651 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3652 return display_buffer_1 (selected_window
);
3654 /* See if the user has specified this buffer should appear
3655 in the selected window. */
3656 if (NILP (not_this_window
))
3658 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3659 if (!NILP (swp
) && !no_switch_window (selected_window
))
3661 Fswitch_to_buffer (buffer
, Qnil
);
3662 return display_buffer_1 (selected_window
);
3666 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3667 look for a window showing BUFFER on any visible or iconified frame.
3668 Otherwise search only the current frame. */
3671 else if (pop_up_frames
3672 || display_buffer_reuse_frames
3673 || last_nonminibuf_frame
== 0)
3674 XSETFASTINT (tem
, 0);
3676 XSETFRAME (tem
, last_nonminibuf_frame
);
3678 window
= Fget_buffer_window (buffer
, tem
);
3680 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3681 return display_buffer_1 (window
);
3683 /* Certain buffer names get special handling. */
3684 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3686 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3688 return call1 (Vspecial_display_function
, buffer
);
3690 return call2 (Vspecial_display_function
, buffer
, tem
);
3693 /* If there are no frames open that have more than a minibuffer,
3694 we need to create a new frame. */
3695 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3697 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3698 Fset_window_buffer (window
, buffer
, Qnil
);
3699 return display_buffer_1 (window
);
3702 f
= SELECTED_FRAME ();
3704 || FRAME_MINIBUF_ONLY_P (f
)
3705 /* If the current frame is a special display frame,
3706 don't try to reuse its windows. */
3707 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3712 if (FRAME_MINIBUF_ONLY_P (f
))
3713 XSETFRAME (frames
, last_nonminibuf_frame
);
3714 /* Don't try to create a window if we would get an error. */
3715 if (split_height_threshold
< window_min_height
<< 1)
3716 split_height_threshold
= window_min_height
<< 1;
3718 /* Note that both Fget_largest_window and Fget_lru_window
3719 ignore minibuffers and dedicated windows.
3720 This means they can return nil. */
3722 /* If the frame we would try to split cannot be split,
3723 try other frames. */
3724 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3726 /* Try visible frames first. */
3727 window
= Fget_largest_window (Qvisible
, Qt
);
3728 /* If that didn't work, try iconified frames. */
3730 window
= Fget_largest_window (make_number (0), Qt
);
3731 #if 0 /* Don't try windows on other displays. */
3733 window
= Fget_largest_window (Qt
, Qt
);
3737 window
= Fget_largest_window (frames
, Qt
);
3739 /* If we got a tall enough full-width window that can be split,
3742 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3743 && window_height (window
) >= split_height_threshold
3744 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3745 window
= Fsplit_window (window
, Qnil
, Qnil
);
3748 Lisp_Object upper
, lower
, other
;
3750 window
= Fget_lru_window (frames
, Qt
);
3751 /* If the LRU window is selected, and big enough,
3752 and can be split, split it. */
3754 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3755 && (EQ (window
, selected_window
)
3756 || EQ (XWINDOW (window
)->parent
, Qnil
))
3757 && window_height (window
) >= window_min_height
<< 1)
3758 window
= Fsplit_window (window
, Qnil
, Qnil
);
3760 window
= Fget_lru_window (frames
, Qnil
);
3761 /* If Fget_lru_window returned nil, try other approaches. */
3763 /* Try visible frames first. */
3765 window
= Fget_buffer_window (buffer
, Qvisible
);
3767 window
= Fget_largest_window (Qvisible
, Qnil
);
3768 /* If that didn't work, try iconified frames. */
3770 window
= Fget_buffer_window (buffer
, make_number (0));
3772 window
= Fget_largest_window (make_number (0), Qnil
);
3774 #if 0 /* Don't try frames on other displays. */
3776 window
= Fget_buffer_window (buffer
, Qt
);
3778 window
= Fget_largest_window (Qt
, Qnil
);
3780 /* As a last resort, make a new frame. */
3782 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3783 /* If window appears above or below another,
3784 even out their heights. */
3785 other
= upper
= lower
= Qnil
;
3786 if (!NILP (XWINDOW (window
)->prev
))
3787 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3788 if (!NILP (XWINDOW (window
)->next
))
3789 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3791 && !NILP (Veven_window_heights
)
3792 /* Check that OTHER and WINDOW are vertically arrayed. */
3793 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3794 && (XFASTINT (XWINDOW (other
)->total_lines
)
3795 > XFASTINT (XWINDOW (window
)->total_lines
)))
3797 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3798 + XFASTINT (XWINDOW (window
)->total_lines
));
3799 enlarge_window (upper
,
3800 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3806 window
= Fget_lru_window (Qnil
, Qnil
);
3808 Fset_window_buffer (window
, buffer
, Qnil
);
3809 return display_buffer_1 (window
);
3813 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3815 doc
: /* Force all windows to be updated on next redisplay.
3816 If optional arg OBJECT is a window, force redisplay of that window only.
3817 If OBJECT is a buffer or buffer name, force redisplay of all windows
3818 displaying that buffer. */)
3824 windows_or_buffers_changed
++;
3825 update_mode_lines
++;
3829 if (WINDOWP (object
))
3831 struct window
*w
= XWINDOW (object
);
3832 mark_window_display_accurate (object
, 0);
3833 w
->update_mode_line
= Qt
;
3834 if (BUFFERP (w
->buffer
))
3835 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3836 ++update_mode_lines
;
3840 if (STRINGP (object
))
3841 object
= Fget_buffer (object
);
3842 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3844 /* Walk all windows looking for buffer, and force update
3845 of each of those windows. */
3847 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3848 return NILP (object
) ? Qnil
: Qt
;
3851 /* If nothing suitable was found, just return.
3852 We could signal an error, but this feature will typically be used
3853 asynchronously in timers or process sentinels, so we don't. */
3859 temp_output_buffer_show (buf
)
3860 register Lisp_Object buf
;
3862 register struct buffer
*old
= current_buffer
;
3863 register Lisp_Object window
;
3864 register struct window
*w
;
3866 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3869 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3873 #if 0 /* rms: there should be no reason for this. */
3874 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3876 set_buffer_internal (old
);
3878 if (!NILP (Vtemp_buffer_show_function
))
3879 call1 (Vtemp_buffer_show_function
, buf
);
3882 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3884 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3885 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3886 Vminibuf_scroll_window
= window
;
3887 w
= XWINDOW (window
);
3888 XSETFASTINT (w
->hscroll
, 0);
3889 XSETFASTINT (w
->min_hscroll
, 0);
3890 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3891 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3893 /* Run temp-buffer-show-hook, with the chosen window selected
3894 and its buffer current. */
3896 if (!NILP (Vrun_hooks
)
3897 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3898 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3900 int count
= SPECPDL_INDEX ();
3901 Lisp_Object prev_window
, prev_buffer
;
3902 prev_window
= selected_window
;
3903 XSETBUFFER (prev_buffer
, old
);
3905 /* Select the window that was chosen, for running the hook.
3906 Note: Both Fselect_window and select_window_norecord may
3907 set-buffer to the buffer displayed in the window,
3908 so we need to save the current buffer. --stef */
3909 record_unwind_protect (Fset_buffer
, prev_buffer
);
3910 record_unwind_protect (select_window_norecord
, prev_window
);
3911 Fselect_window (window
, Qt
);
3912 Fset_buffer (w
->buffer
);
3913 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3914 unbind_to (count
, Qnil
);
3920 make_dummy_parent (window
)
3924 register struct window
*o
, *p
;
3927 o
= XWINDOW (window
);
3928 p
= allocate_window ();
3929 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3930 ((struct Lisp_Vector
*) p
)->contents
[i
]
3931 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3932 XSETWINDOW (new, p
);
3935 XSETFASTINT (p
->sequence_number
, sequence_number
);
3937 /* Put new into window structure in place of window */
3938 replace_window (window
, new);
3951 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3952 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3953 WINDOW defaults to selected one and SIZE to half its size.
3954 If optional third arg HORFLAG is non-nil, split side by side
3955 and put SIZE columns in the first of the pair. In that case,
3956 SIZE includes that window's scroll bar, or the divider column to its right.
3957 Interactively, all arguments are nil.
3959 Returns the newly created window (which is the lower or rightmost one).
3960 The upper or leftmost window is the original one, and remains selected
3961 if it was selected before.
3963 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3964 (window
, size
, horflag
)
3965 Lisp_Object window
, size
, horflag
;
3967 register Lisp_Object
new;
3968 register struct window
*o
, *p
;
3970 register int size_int
;
3973 window
= selected_window
;
3975 CHECK_LIVE_WINDOW (window
);
3977 o
= XWINDOW (window
);
3978 fo
= XFRAME (WINDOW_FRAME (o
));
3982 if (!NILP (horflag
))
3983 /* Calculate the size of the left-hand window, by dividing
3984 the usable space in columns by two.
3985 We round up, since the left-hand window may include
3986 a dividing line, while the right-hand may not. */
3987 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3989 size_int
= XFASTINT (o
->total_lines
) >> 1;
3993 CHECK_NUMBER (size
);
3994 size_int
= XINT (size
);
3997 if (MINI_WINDOW_P (o
))
3998 error ("Attempt to split minibuffer window");
3999 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
4000 error ("Attempt to split fixed-size window");
4002 check_min_window_sizes ();
4006 if (size_int
< window_min_height
)
4007 error ("Window height %d too small (after splitting)", size_int
);
4008 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
4009 error ("Window height %d too small (after splitting)",
4010 XFASTINT (o
->total_lines
) - size_int
);
4011 if (NILP (o
->parent
)
4012 || NILP (XWINDOW (o
->parent
)->vchild
))
4014 make_dummy_parent (window
);
4016 XWINDOW (new)->vchild
= window
;
4021 if (size_int
< window_min_width
)
4022 error ("Window width %d too small (after splitting)", size_int
);
4024 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
4025 error ("Window width %d too small (after splitting)",
4026 XFASTINT (o
->total_cols
) - size_int
);
4027 if (NILP (o
->parent
)
4028 || NILP (XWINDOW (o
->parent
)->hchild
))
4030 make_dummy_parent (window
);
4032 XWINDOW (new)->hchild
= window
;
4036 /* Now we know that window's parent is a vertical combination
4037 if we are dividing vertically, or a horizontal combination
4038 if we are making side-by-side windows */
4040 windows_or_buffers_changed
++;
4041 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
4042 new = make_window ();
4045 p
->frame
= o
->frame
;
4047 if (!NILP (p
->next
))
4048 XWINDOW (p
->next
)->prev
= new;
4051 p
->parent
= o
->parent
;
4053 p
->window_end_valid
= Qnil
;
4054 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
4056 /* Duplicate special geometry settings. */
4058 p
->left_margin_cols
= o
->left_margin_cols
;
4059 p
->right_margin_cols
= o
->right_margin_cols
;
4060 p
->left_fringe_width
= o
->left_fringe_width
;
4061 p
->right_fringe_width
= o
->right_fringe_width
;
4062 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
4063 p
->scroll_bar_width
= o
->scroll_bar_width
;
4064 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
4066 /* Apportion the available frame space among the two new windows */
4068 if (!NILP (horflag
))
4070 p
->total_lines
= o
->total_lines
;
4071 p
->top_line
= o
->top_line
;
4072 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
4073 XSETFASTINT (o
->total_cols
, size_int
);
4074 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
4075 adjust_window_margins (p
);
4076 adjust_window_margins (o
);
4080 p
->left_col
= o
->left_col
;
4081 p
->total_cols
= o
->total_cols
;
4082 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
4083 XSETFASTINT (o
->total_lines
, size_int
);
4084 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
4087 /* Adjust glyph matrices. */
4090 Fset_window_buffer (new, o
->buffer
, Qt
);
4094 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
4095 doc
: /* Make current window ARG lines bigger.
4096 From program, optional second arg non-nil means grow sideways ARG columns.
4097 Interactively, if an argument is not given, make the window one line bigger.
4098 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
4099 This function can delete windows, even the second window, if they get
4102 Lisp_Object arg
, horizontal
;
4105 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
4107 if (! NILP (Vwindow_configuration_change_hook
))
4108 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4113 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
4114 doc
: /* Make current window ARG lines smaller.
4115 From program, optional second arg non-nil means shrink sideways arg columns.
4116 Interactively, if an argument is not given, make the window one line smaller. Only
4117 siblings to the right or below are changed. */)
4119 Lisp_Object arg
, side
;
4122 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
4124 if (! NILP (Vwindow_configuration_change_hook
))
4125 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4131 window_height (window
)
4134 register struct window
*p
= XWINDOW (window
);
4135 return WINDOW_TOTAL_LINES (p
);
4139 window_width (window
)
4142 register struct window
*p
= XWINDOW (window
);
4143 return WINDOW_TOTAL_COLS (p
);
4148 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4150 #define CURSIZE(w) \
4151 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4154 /* Enlarge WINDOW by DELTA.
4155 HORIZ_FLAG nonzero means enlarge it horizontally;
4156 zero means do it vertically.
4158 Siblings of the selected window are resized to fulfill the size
4159 request. If they become too small in the process, they will be
4163 enlarge_window (window
, delta
, horiz_flag
)
4165 int delta
, horiz_flag
;
4167 Lisp_Object parent
, next
, prev
;
4171 int (*sizefun
) P_ ((Lisp_Object
))
4172 = horiz_flag
? window_width
: window_height
;
4173 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
4174 = (horiz_flag
? set_window_width
: set_window_height
);
4176 /* Check values of window_min_width and window_min_height for
4178 check_min_window_sizes ();
4180 /* Give up if this window cannot be resized. */
4181 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4182 error ("Window is not resizable");
4184 /* Find the parent of the selected window. */
4187 p
= XWINDOW (window
);
4193 error ("No other window to side of this one");
4198 ? !NILP (XWINDOW (parent
)->hchild
)
4199 : !NILP (XWINDOW (parent
)->vchild
))
4205 sizep
= &CURSIZE (window
);
4208 register int maxdelta
;
4210 /* Compute the maximum size increment this window can have. */
4212 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4213 /* This is a main window followed by a minibuffer. */
4214 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4215 - window_min_size (XWINDOW (p
->next
),
4217 /* This is a minibuffer following a main window. */
4218 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4219 - window_min_size (XWINDOW (p
->prev
),
4221 /* This is a frame with only one window, a minibuffer-only
4222 or a minibufferless frame. */
4225 if (delta
> maxdelta
)
4226 /* This case traps trying to make the minibuffer
4227 the full frame, or make the only window aside from the
4228 minibuffer the full frame. */
4232 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4234 delete_window (window
);
4241 /* Find the total we can get from other siblings without deleting them. */
4243 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4244 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4246 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4247 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4250 /* If we can get it all from them without deleting them, do so. */
4251 if (delta
<= maximum
)
4253 Lisp_Object first_unaffected
;
4254 Lisp_Object first_affected
;
4259 first_affected
= window
;
4260 /* Look at one sibling at a time,
4261 moving away from this window in both directions alternately,
4262 and take as much as we can get without deleting that sibling. */
4264 && (!NILP (next
) || !NILP (prev
)))
4268 int this_one
= ((*sizefun
) (next
)
4269 - window_min_size (XWINDOW (next
),
4270 horiz_flag
, 0, &fixed_p
));
4273 if (this_one
> delta
)
4276 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4277 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4282 next
= XWINDOW (next
)->next
;
4290 int this_one
= ((*sizefun
) (prev
)
4291 - window_min_size (XWINDOW (prev
),
4292 horiz_flag
, 0, &fixed_p
));
4295 if (this_one
> delta
)
4298 first_affected
= prev
;
4300 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4301 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4306 prev
= XWINDOW (prev
)->prev
;
4310 xassert (delta
== 0);
4312 /* Now recalculate the edge positions of all the windows affected,
4313 based on the new sizes. */
4314 first_unaffected
= next
;
4315 prev
= first_affected
;
4316 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4317 prev
= next
, next
= XWINDOW (next
)->next
)
4319 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4320 /* This does not change size of NEXT,
4321 but it propagates the new top edge to its children */
4322 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4327 register int delta1
;
4328 register int opht
= (*sizefun
) (parent
);
4330 if (opht
<= XINT (*sizep
) + delta
)
4332 /* If trying to grow this window to or beyond size of the parent,
4333 just delete all the sibling windows. */
4334 Lisp_Object start
, tem
, next
;
4336 start
= XWINDOW (parent
)->vchild
;
4338 start
= XWINDOW (parent
)->hchild
;
4340 /* Delete any siblings that come after WINDOW. */
4341 tem
= XWINDOW (window
)->next
;
4342 while (! NILP (tem
))
4344 next
= XWINDOW (tem
)->next
;
4345 delete_window (tem
);
4349 /* Delete any siblings that come after WINDOW.
4350 Note that if START is not WINDOW, then WINDOW still
4351 Fhas siblings, so WINDOW has not yet replaced its parent. */
4353 while (! EQ (tem
, window
))
4355 next
= XWINDOW (tem
)->next
;
4356 delete_window (tem
);
4362 /* Otherwise, make delta1 just right so that if we add
4363 delta1 lines to this window and to the parent, and then
4364 shrink the parent back to its original size, the new
4365 proportional size of this window will increase by delta.
4367 The function size_window will compute the new height h'
4368 of the window from delta1 as:
4371 x = delta1 - delta1/n * n for the 1st resizable child
4374 where n is the number of children that can be resized.
4375 We can ignore x by choosing a delta1 that is a multiple of
4376 n. We want the height of this window to come out as
4386 The number of children n equals the number of resizable
4387 children of this window + 1 because we know window itself
4388 is resizable (otherwise we would have signalled an error). */
4390 struct window
*w
= XWINDOW (window
);
4394 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4395 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4397 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4398 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4403 /* Add delta1 lines or columns to this window, and to the parent,
4404 keeping things consistent while not affecting siblings. */
4405 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4406 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4408 /* Squeeze out delta1 lines or columns from our parent,
4409 shriking this window and siblings proportionately.
4410 This brings parent back to correct size.
4411 Delta1 was calculated so this makes this window the desired size,
4412 taking it all out of the siblings. */
4413 (*setsizefun
) (parent
, opht
, 0);
4418 XSETFASTINT (p
->last_modified
, 0);
4419 XSETFASTINT (p
->last_overlay_modified
, 0);
4421 /* Adjust glyph matrices. */
4422 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4426 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4427 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4428 zero means adjust the height, moving the bottom edge.
4430 Following siblings of the selected window are resized to fulfill
4431 the size request. If they become too small in the process, they
4432 are not deleted; instead, we signal an error. */
4435 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4437 int delta
, horiz_flag
;
4439 Lisp_Object parent
, child
;
4441 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4442 int delcount
= window_deletion_count
;
4444 /* Check values of window_min_width and window_min_height for
4446 check_min_window_sizes ();
4449 window
= Fselected_window ();
4451 CHECK_WINDOW (window
);
4453 /* Give up if this window cannot be resized. */
4454 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4455 error ("Window is not resizable");
4459 Lisp_Object first_parallel
= Qnil
;
4463 /* This happens if WINDOW on the previous iteration was
4464 at top level of the window tree. */
4465 Fset_window_configuration (old_config
);
4466 error ("Specified window edge is fixed");
4469 p
= XWINDOW (window
);
4472 /* See if this level has windows in parallel in the specified
4473 direction. If so, set FIRST_PARALLEL to the first one. */
4476 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4477 first_parallel
= XWINDOW (parent
)->vchild
;
4478 else if (NILP (parent
) && !NILP (p
->next
))
4480 /* Handle the vertical chain of main window and minibuffer
4481 which has no parent. */
4482 first_parallel
= window
;
4483 while (! NILP (XWINDOW (first_parallel
)->prev
))
4484 first_parallel
= XWINDOW (first_parallel
)->prev
;
4489 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4490 first_parallel
= XWINDOW (parent
)->hchild
;
4493 /* If this level's succession is in the desired dimension,
4494 and this window is the last one, and there is no higher level,
4495 its trailing edge is fixed. */
4496 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4499 Fset_window_configuration (old_config
);
4500 error ("Specified window edge is fixed");
4503 /* Don't make this window too small. */
4504 if (XINT (CURSIZE (window
)) + delta
4505 < (horiz_flag
? window_min_width
: window_min_height
))
4507 Fset_window_configuration (old_config
);
4508 error ("Cannot adjust window size as specified");
4511 /* Clear out some redisplay caches. */
4512 XSETFASTINT (p
->last_modified
, 0);
4513 XSETFASTINT (p
->last_overlay_modified
, 0);
4515 /* Adjust this window's edge. */
4516 XSETINT (CURSIZE (window
),
4517 XINT (CURSIZE (window
)) + delta
);
4519 /* If this window has following siblings in the desired dimension,
4520 make them smaller, and exit the loop.
4522 (If we reach the top of the tree and can never do this,
4523 we will fail and report an error, above.) */
4524 if (NILP (first_parallel
))
4526 if (!NILP (p
->next
))
4528 /* This may happen for the minibuffer. In that case
4529 the window_deletion_count check below does not work. */
4530 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4532 Fset_window_configuration (old_config
);
4533 error ("Cannot adjust window size as specified");
4536 XSETINT (CURBEG (p
->next
),
4537 XINT (CURBEG (p
->next
)) + delta
);
4538 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4539 horiz_flag
, 0, 1, 0);
4544 /* Here we have a chain of parallel siblings, in the other dimension.
4545 Change the size of the other siblings. */
4546 for (child
= first_parallel
;
4548 child
= XWINDOW (child
)->next
)
4549 if (! EQ (child
, window
))
4550 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4551 horiz_flag
, 0, 0, 1);
4556 /* If we made a window so small it got deleted,
4557 we failed. Report failure. */
4558 if (delcount
!= window_deletion_count
)
4560 Fset_window_configuration (old_config
);
4561 error ("Cannot adjust window size as specified");
4564 /* Adjust glyph matrices. */
4565 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4571 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4572 Sadjust_window_trailing_edge
, 3, 3, 0,
4573 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4574 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4575 Otherwise, adjust the height, moving the bottom edge.
4577 Following siblings of the selected window are resized to fulfill
4578 the size request. If they become too small in the process, they
4579 are not deleted; instead, we signal an error. */)
4580 (window
, delta
, horizontal
)
4581 Lisp_Object window
, delta
, horizontal
;
4583 CHECK_NUMBER (delta
);
4584 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4586 if (! NILP (Vwindow_configuration_change_hook
))
4587 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4594 /***********************************************************************
4595 Resizing Mini-Windows
4596 ***********************************************************************/
4598 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4600 enum save_restore_action
4607 static int save_restore_orig_size
P_ ((struct window
*,
4608 enum save_restore_action
));
4610 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4611 from lowest windows first. */
4614 shrink_window_lowest_first (w
, height
)
4622 xassert (!MINI_WINDOW_P (w
));
4624 /* Set redisplay hints. */
4625 XSETFASTINT (w
->last_modified
, 0);
4626 XSETFASTINT (w
->last_overlay_modified
, 0);
4627 windows_or_buffers_changed
++;
4628 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4630 old_height
= XFASTINT (w
->total_lines
);
4631 XSETFASTINT (w
->total_lines
, height
);
4633 if (!NILP (w
->hchild
))
4635 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4637 c
= XWINDOW (child
);
4638 c
->top_line
= w
->top_line
;
4639 shrink_window_lowest_first (c
, height
);
4642 else if (!NILP (w
->vchild
))
4644 Lisp_Object last_child
;
4645 int delta
= old_height
- height
;
4650 /* Find the last child. We are taking space from lowest windows
4651 first, so we iterate over children from the last child
4653 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4656 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4657 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4661 c
= XWINDOW (child
);
4662 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4664 if (this_one
> delta
)
4667 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4671 /* Compute new positions. */
4672 last_top
= XINT (w
->top_line
);
4673 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4675 c
= XWINDOW (child
);
4676 c
->top_line
= make_number (last_top
);
4677 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4678 last_top
+= XFASTINT (c
->total_lines
);
4684 /* Save, restore, or check positions and sizes in the window tree
4685 rooted at W. ACTION says what to do.
4687 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4688 orig_total_lines members are valid for all windows in the window
4689 tree. Value is non-zero if they are valid.
4691 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4692 orig_top_line and orig_total_lines for all windows in the tree.
4694 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4695 stored in orig_top_line and orig_total_lines for all windows. */
4698 save_restore_orig_size (w
, action
)
4700 enum save_restore_action action
;
4706 if (!NILP (w
->hchild
))
4708 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4711 else if (!NILP (w
->vchild
))
4713 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4719 case CHECK_ORIG_SIZES
:
4720 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4724 case SAVE_ORIG_SIZES
:
4725 w
->orig_top_line
= w
->top_line
;
4726 w
->orig_total_lines
= w
->total_lines
;
4727 XSETFASTINT (w
->last_modified
, 0);
4728 XSETFASTINT (w
->last_overlay_modified
, 0);
4731 case RESTORE_ORIG_SIZES
:
4732 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4733 w
->top_line
= w
->orig_top_line
;
4734 w
->total_lines
= w
->orig_total_lines
;
4735 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4736 XSETFASTINT (w
->last_modified
, 0);
4737 XSETFASTINT (w
->last_overlay_modified
, 0);
4744 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4751 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4752 without deleting other windows. */
4755 grow_mini_window (w
, delta
)
4759 struct frame
*f
= XFRAME (w
->frame
);
4760 struct window
*root
;
4762 xassert (MINI_WINDOW_P (w
));
4763 xassert (delta
>= 0);
4765 /* Check values of window_min_width and window_min_height for
4767 check_min_window_sizes ();
4769 /* Compute how much we can enlarge the mini-window without deleting
4771 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4774 int min_height
= window_min_size (root
, 0, 0, 0);
4775 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4776 /* Note that the root window may already be smaller than
4778 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4783 /* Save original window sizes and positions, if not already done. */
4784 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4785 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4787 /* Shrink other windows. */
4788 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4790 /* Grow the mini-window. */
4791 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4792 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4793 XSETFASTINT (w
->last_modified
, 0);
4794 XSETFASTINT (w
->last_overlay_modified
, 0);
4801 /* Shrink mini-window W. If there is recorded info about window sizes
4802 before a call to grow_mini_window, restore recorded window sizes.
4803 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4807 shrink_mini_window (w
)
4810 struct frame
*f
= XFRAME (w
->frame
);
4811 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4813 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4815 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4817 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4818 windows_or_buffers_changed
= 1;
4820 else if (XFASTINT (w
->total_lines
) > 1)
4822 /* Distribute the additional lines of the mini-window
4823 among the other windows. */
4825 XSETWINDOW (window
, w
);
4826 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4832 /* Mark window cursors off for all windows in the window tree rooted
4833 at W by setting their phys_cursor_on_p flag to zero. Called from
4834 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4835 the frame are cleared. */
4838 mark_window_cursors_off (w
)
4843 if (!NILP (w
->hchild
))
4844 mark_window_cursors_off (XWINDOW (w
->hchild
));
4845 else if (!NILP (w
->vchild
))
4846 mark_window_cursors_off (XWINDOW (w
->vchild
));
4848 w
->phys_cursor_on_p
= 0;
4850 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4855 /* Return number of lines of text (not counting mode lines) in W. */
4858 window_internal_height (w
)
4861 int ht
= XFASTINT (w
->total_lines
);
4863 if (!MINI_WINDOW_P (w
))
4865 if (!NILP (w
->parent
)
4866 || !NILP (w
->vchild
)
4867 || !NILP (w
->hchild
)
4870 || WINDOW_WANTS_MODELINE_P (w
))
4873 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4881 /* Return the number of columns in W.
4882 Don't count columns occupied by scroll bars or the vertical bar
4883 separating W from the sibling to its right. */
4886 window_box_text_cols (w
)
4889 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4890 int width
= XINT (w
->total_cols
);
4892 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4893 /* Scroll bars occupy a few columns. */
4894 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4895 else if (!FRAME_WINDOW_P (f
)
4896 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4897 /* The column of `|' characters separating side-by-side windows
4898 occupies one column only. */
4901 if (FRAME_WINDOW_P (f
))
4902 /* On window-systems, fringes and display margins cannot be
4903 used for normal text. */
4904 width
-= (WINDOW_FRINGE_COLS (w
)
4905 + WINDOW_LEFT_MARGIN_COLS (w
)
4906 + WINDOW_RIGHT_MARGIN_COLS (w
));
4912 /************************************************************************
4914 ***********************************************************************/
4916 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4917 N screen-fulls, which is defined as the height of the window minus
4918 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4919 instead. Negative values of N mean scroll down. NOERROR non-zero
4920 means don't signal an error if we try to move over BEGV or ZV,
4924 window_scroll (window
, n
, whole
, noerror
)
4932 /* If we must, use the pixel-based version which is much slower than
4933 the line-based one but can handle varying line heights. */
4934 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4935 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4937 window_scroll_line_based (window
, n
, whole
, noerror
);
4943 /* Implementation of window_scroll that works based on pixel line
4944 heights. See the comment of window_scroll for parameter
4948 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4955 struct window
*w
= XWINDOW (window
);
4956 struct text_pos start
;
4957 int this_scroll_margin
;
4958 /* True if we fiddled the window vscroll field without really scrolling. */
4960 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4962 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4964 /* If PT is not visible in WINDOW, move back one half of
4965 the screen. Allow PT to be partially visible, otherwise
4966 something like (scroll-down 1) with PT in the line before
4967 the partially visible one would recenter. */
4969 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4971 /* Move backward half the height of the window. Performance note:
4972 vmotion used here is about 10% faster, but would give wrong
4973 results for variable height lines. */
4974 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4975 it
.current_y
= it
.last_visible_y
;
4976 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4978 /* The function move_iterator_vertically may move over more than
4979 the specified y-distance. If it->w is small, e.g. a
4980 mini-buffer window, we may end up in front of the window's
4981 display area. This is the case when Start displaying at the
4982 start of the line containing PT in this case. */
4983 if (it
.current_y
<= 0)
4985 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4986 move_it_vertically_backward (&it
, 0);
4990 start
= it
.current
.pos
;
4992 else if (auto_window_vscroll_p
)
4994 if (rtop
|| rbot
) /* partially visible */
4997 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4999 dy
= max ((window_box_height (w
)
5000 - next_screen_context_lines
* dy
),
5006 /* Only vscroll backwards if already vscrolled forwards. */
5007 if (w
->vscroll
< 0 && rtop
> 0)
5009 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
5010 Fset_window_vscroll (window
, make_number (px
), Qt
);
5016 /* Do vscroll if already vscrolled or only display line. */
5017 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
5019 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
5020 Fset_window_vscroll (window
, make_number (px
), Qt
);
5024 /* Maybe modify window start instead of scrolling. */
5025 if (rbot
> 0 || w
->vscroll
< 0)
5029 Fset_window_vscroll (window
, make_number (0), Qt
);
5030 /* If there are other text lines above the current row,
5031 move window start to current row. Else to next row. */
5033 spos
= XINT (Fline_beginning_position (Qnil
));
5035 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
5036 set_marker_restricted (w
->start
, make_number (spos
),
5038 w
->start_at_line_beg
= Qt
;
5039 w
->update_mode_line
= Qt
;
5040 XSETFASTINT (w
->last_modified
, 0);
5041 XSETFASTINT (w
->last_overlay_modified
, 0);
5042 /* Set force_start so that redisplay_window will run the
5043 window-scroll-functions. */
5044 w
->force_start
= Qt
;
5049 /* Cancel previous vscroll. */
5050 Fset_window_vscroll (window
, make_number (0), Qt
);
5053 /* If scroll_preserve_screen_position is non-nil, we try to set
5054 point in the same window line as it is now, so get that line. */
5055 if (!NILP (Vscroll_preserve_screen_position
))
5057 /* We preserve the goal pixel coordinate across consecutive
5058 calls to scroll-up or scroll-down. This avoids the
5059 possibility of point becoming "stuck" on a tall line when
5060 scrolling by one line. */
5061 if (window_scroll_pixel_based_preserve_y
< 0
5062 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5063 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5065 start_display (&it
, w
, start
);
5066 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5067 window_scroll_pixel_based_preserve_y
= it
.current_y
;
5071 window_scroll_pixel_based_preserve_y
= -1;
5073 /* Move iterator it from start the specified distance forward or
5074 backward. The result is the new window start. */
5075 start_display (&it
, w
, start
);
5078 int start_pos
= IT_CHARPOS (it
);
5079 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5080 dy
= max ((window_box_height (w
)
5081 - next_screen_context_lines
* dy
),
5084 /* Note that move_it_vertically always moves the iterator to the
5085 start of a line. So, if the last line doesn't have a newline,
5086 we would end up at the start of the line ending at ZV. */
5089 move_it_vertically_backward (&it
, -dy
);
5090 /* Ensure we actually do move, e.g. in case we are currently
5091 looking at an image that is taller that the window height. */
5092 while (start_pos
== IT_CHARPOS (it
)
5093 && start_pos
> BEGV
)
5094 move_it_by_lines (&it
, -1, 1);
5098 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
5099 MOVE_TO_POS
| MOVE_TO_Y
);
5100 /* Ensure we actually do move, e.g. in case we are currently
5101 looking at an image that is taller that the window height. */
5102 while (start_pos
== IT_CHARPOS (it
)
5104 move_it_by_lines (&it
, 1, 1);
5108 move_it_by_lines (&it
, n
, 1);
5110 /* We failed if we find ZV is already on the screen (scrolling up,
5111 means there's nothing past the end), or if we can't start any
5112 earlier (scrolling down, means there's nothing past the top). */
5113 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
5114 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
5116 if (IT_CHARPOS (it
) == ZV
)
5118 if (it
.current_y
< it
.last_visible_y
5119 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
5120 > it
.last_visible_y
))
5122 /* The last line was only partially visible, make it fully
5124 w
->vscroll
= (it
.last_visible_y
5125 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
5126 adjust_glyphs (it
.f
);
5130 else if (n
< 0) /* could happen with empty buffers */
5131 xsignal0 (Qbeginning_of_buffer
);
5133 xsignal0 (Qend_of_buffer
);
5137 if (w
->vscroll
!= 0)
5138 /* The first line was only partially visible, make it fully
5144 xsignal0 (Qbeginning_of_buffer
);
5147 /* If control gets here, then we vscrolled. */
5149 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5151 /* Don't try to change the window start below. */
5157 int pos
= IT_CHARPOS (it
);
5160 /* If in the middle of a multi-glyph character move forward to
5161 the next character. */
5162 if (in_display_vector_p (&it
))
5165 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5168 /* Set the window start, and set up the window for redisplay. */
5169 set_marker_restricted (w
->start
, make_number (pos
),
5171 bytepos
= XMARKER (w
->start
)->bytepos
;
5172 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5174 w
->update_mode_line
= Qt
;
5175 XSETFASTINT (w
->last_modified
, 0);
5176 XSETFASTINT (w
->last_overlay_modified
, 0);
5177 /* Set force_start so that redisplay_window will run the
5178 window-scroll-functions. */
5179 w
->force_start
= Qt
;
5182 /* The rest of this function uses current_y in a nonstandard way,
5183 not including the height of the header line if any. */
5184 it
.current_y
= it
.vpos
= 0;
5186 /* Move PT out of scroll margins.
5187 This code wants current_y to be zero at the window start position
5188 even if there is a header line. */
5189 this_scroll_margin
= max (0, scroll_margin
);
5190 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5191 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5195 /* We moved the window start towards ZV, so PT may be now
5196 in the scroll margin at the top. */
5197 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5198 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5199 && (NILP (Vscroll_preserve_screen_position
)
5200 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5201 /* We found PT at a legitimate height. Leave it alone. */
5203 else if (window_scroll_pixel_based_preserve_y
>= 0)
5205 /* If we have a header line, take account of it.
5206 This is necessary because we set it.current_y to 0, above. */
5207 move_it_to (&it
, -1, -1,
5208 window_scroll_pixel_based_preserve_y
5209 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5211 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5215 while (it
.current_y
< this_scroll_margin
)
5217 int prev
= it
.current_y
;
5218 move_it_by_lines (&it
, 1, 1);
5219 if (prev
== it
.current_y
)
5222 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5227 int charpos
, bytepos
;
5230 /* Save our position, for the
5231 window_scroll_pixel_based_preserve_y case. */
5232 charpos
= IT_CHARPOS (it
);
5233 bytepos
= IT_BYTEPOS (it
);
5235 /* We moved the window start towards BEGV, so PT may be now
5236 in the scroll margin at the bottom. */
5237 move_it_to (&it
, PT
, -1,
5238 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5239 - this_scroll_margin
- 1),
5241 MOVE_TO_POS
| MOVE_TO_Y
);
5243 /* Save our position, in case it's correct. */
5244 charpos
= IT_CHARPOS (it
);
5245 bytepos
= IT_BYTEPOS (it
);
5247 /* See if point is on a partially visible line at the end. */
5248 if (it
.what
== IT_EOB
)
5249 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5252 move_it_by_lines (&it
, 1, 1);
5253 partial_p
= it
.current_y
> it
.last_visible_y
;
5256 if (charpos
== PT
&& !partial_p
5257 && (NILP (Vscroll_preserve_screen_position
)
5258 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5259 /* We found PT before we found the display margin, so PT is ok. */
5261 else if (window_scroll_pixel_based_preserve_y
>= 0)
5263 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5264 start_display (&it
, w
, start
);
5265 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5266 here because we called start_display again and did not
5267 alter it.current_y this time. */
5268 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5270 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5275 /* The last line was only partially visible, so back up two
5276 lines to make sure we're on a fully visible line. */
5278 move_it_by_lines (&it
, -2, 0);
5279 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5282 /* No, the position we saved is OK, so use it. */
5283 SET_PT_BOTH (charpos
, bytepos
);
5289 /* Implementation of window_scroll that works based on screen lines.
5290 See the comment of window_scroll for parameter descriptions. */
5293 window_scroll_line_based (window
, n
, whole
, noerror
)
5299 register struct window
*w
= XWINDOW (window
);
5300 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5301 register int pos
, pos_byte
;
5302 register int ht
= window_internal_height (w
);
5303 register Lisp_Object tem
;
5307 struct position posit
;
5310 /* If scrolling screen-fulls, compute the number of lines to
5311 scroll from the window's height. */
5313 n
*= max (1, ht
- next_screen_context_lines
);
5315 startpos
= marker_position (w
->start
);
5317 posit
= *compute_motion (startpos
, 0, 0, 0,
5319 -1, XINT (w
->hscroll
),
5321 original_vpos
= posit
.vpos
;
5323 XSETFASTINT (tem
, PT
);
5324 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5328 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5333 lose
= n
< 0 && PT
== BEGV
;
5334 Fvertical_motion (make_number (n
), window
);
5338 SET_PT_BOTH (opoint
, opoint_byte
);
5345 xsignal0 (Qbeginning_of_buffer
);
5350 int this_scroll_margin
= scroll_margin
;
5352 /* Don't use a scroll margin that is negative or too large. */
5353 if (this_scroll_margin
< 0)
5354 this_scroll_margin
= 0;
5356 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5357 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5359 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5360 w
->start_at_line_beg
= bolp
;
5361 w
->update_mode_line
= Qt
;
5362 XSETFASTINT (w
->last_modified
, 0);
5363 XSETFASTINT (w
->last_overlay_modified
, 0);
5364 /* Set force_start so that redisplay_window will run
5365 the window-scroll-functions. */
5366 w
->force_start
= Qt
;
5368 if (!NILP (Vscroll_preserve_screen_position
)
5369 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5371 SET_PT_BOTH (pos
, pos_byte
);
5372 Fvertical_motion (make_number (original_vpos
), window
);
5374 /* If we scrolled forward, put point enough lines down
5375 that it is outside the scroll margin. */
5380 if (this_scroll_margin
> 0)
5382 SET_PT_BOTH (pos
, pos_byte
);
5383 Fvertical_motion (make_number (this_scroll_margin
), window
);
5389 if (top_margin
<= opoint
)
5390 SET_PT_BOTH (opoint
, opoint_byte
);
5391 else if (!NILP (Vscroll_preserve_screen_position
))
5393 SET_PT_BOTH (pos
, pos_byte
);
5394 Fvertical_motion (make_number (original_vpos
), window
);
5397 SET_PT (top_margin
);
5403 /* If we scrolled backward, put point near the end of the window
5404 but not within the scroll margin. */
5405 SET_PT_BOTH (pos
, pos_byte
);
5406 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5407 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5410 bottom_margin
= PT
+ 1;
5412 if (bottom_margin
> opoint
)
5413 SET_PT_BOTH (opoint
, opoint_byte
);
5416 if (!NILP (Vscroll_preserve_screen_position
))
5418 SET_PT_BOTH (pos
, pos_byte
);
5419 Fvertical_motion (make_number (original_vpos
), window
);
5422 Fvertical_motion (make_number (-1), window
);
5431 xsignal0 (Qend_of_buffer
);
5436 /* Scroll selected_window up or down. If N is nil, scroll a
5437 screen-full which is defined as the height of the window minus
5438 next_screen_context_lines. If N is the symbol `-', scroll.
5439 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5440 up. This is the guts of Fscroll_up and Fscroll_down. */
5443 scroll_command (n
, direction
)
5447 int count
= SPECPDL_INDEX ();
5449 xassert (abs (direction
) == 1);
5451 /* If selected window's buffer isn't current, make it current for
5452 the moment. But don't screw up if window_scroll gets an error. */
5453 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5455 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5456 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5458 /* Make redisplay consider other windows than just selected_window. */
5459 ++windows_or_buffers_changed
;
5463 window_scroll (selected_window
, direction
, 1, 0);
5464 else if (EQ (n
, Qminus
))
5465 window_scroll (selected_window
, -direction
, 1, 0);
5468 n
= Fprefix_numeric_value (n
);
5469 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5472 unbind_to (count
, Qnil
);
5475 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5476 doc
: /* Scroll text of current window upward ARG lines.
5477 If ARG is omitted or nil, scroll upward by a near full screen.
5478 A near full screen is `next-screen-context-lines' less than a full screen.
5479 Negative ARG means scroll downward.
5480 If ARG is the atom `-', scroll downward by nearly full screen.
5481 When calling from a program, supply as argument a number, nil, or `-'. */)
5485 scroll_command (arg
, 1);
5489 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5490 doc
: /* Scroll text of current window down ARG lines.
5491 If ARG is omitted or nil, scroll down by a near full screen.
5492 A near full screen is `next-screen-context-lines' less than a full screen.
5493 Negative ARG means scroll upward.
5494 If ARG is the atom `-', scroll upward by nearly full screen.
5495 When calling from a program, supply as argument a number, nil, or `-'. */)
5499 scroll_command (arg
, -1);
5503 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5504 doc
: /* Return the other window for \"other window scroll\" commands.
5505 If `other-window-scroll-buffer' is non-nil, a window
5506 showing that buffer is used.
5507 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5508 specifies the window. This takes precedence over
5509 `other-window-scroll-buffer'. */)
5514 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5515 && !NILP (Vminibuf_scroll_window
))
5516 window
= Vminibuf_scroll_window
;
5517 /* If buffer is specified, scroll that buffer. */
5518 else if (!NILP (Vother_window_scroll_buffer
))
5520 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5522 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5526 /* Nothing specified; look for a neighboring window on the same
5528 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5530 if (EQ (window
, selected_window
))
5531 /* That didn't get us anywhere; look for a window on another
5534 window
= Fnext_window (window
, Qnil
, Qt
);
5535 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5536 && ! EQ (window
, selected_window
));
5539 CHECK_LIVE_WINDOW (window
);
5541 if (EQ (window
, selected_window
))
5542 error ("There is no other window");
5547 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5548 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5549 A near full screen is `next-screen-context-lines' less than a full screen.
5550 The next window is the one below the current one; or the one at the top
5551 if the current one is at the bottom. Negative ARG means scroll downward.
5552 If ARG is the atom `-', scroll downward by nearly full screen.
5553 When calling from a program, supply as argument a number, nil, or `-'.
5555 If `other-window-scroll-buffer' is non-nil, scroll the window
5556 showing that buffer, popping the buffer up if necessary.
5557 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5558 specifies the window to scroll. This takes precedence over
5559 `other-window-scroll-buffer'. */)
5565 int count
= SPECPDL_INDEX ();
5567 window
= Fother_window_for_scrolling ();
5568 w
= XWINDOW (window
);
5570 /* Don't screw up if window_scroll gets an error. */
5571 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5572 ++windows_or_buffers_changed
;
5574 Fset_buffer (w
->buffer
);
5575 SET_PT (marker_position (w
->pointm
));
5578 window_scroll (window
, 1, 1, 1);
5579 else if (EQ (arg
, Qminus
))
5580 window_scroll (window
, -1, 1, 1);
5586 window_scroll (window
, XINT (arg
), 0, 1);
5589 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5590 unbind_to (count
, Qnil
);
5595 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5596 doc
: /* Scroll selected window display ARG columns left.
5597 Default for ARG is window width minus 2.
5598 Value is the total amount of leftward horizontal scrolling in
5599 effect after the change.
5600 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5601 lower bound for automatic scrolling, i.e. automatic scrolling
5602 will not scroll a window to a column less than the value returned
5603 by this function. This happens in an interactive call. */)
5605 register Lisp_Object arg
, set_minimum
;
5609 struct window
*w
= XWINDOW (selected_window
);
5612 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5614 arg
= Fprefix_numeric_value (arg
);
5616 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5617 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5619 if (!NILP (set_minimum
))
5620 w
->min_hscroll
= w
->hscroll
;
5625 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5626 doc
: /* Scroll selected window display ARG columns right.
5627 Default for ARG is window width minus 2.
5628 Value is the total amount of leftward horizontal scrolling in
5629 effect after the change.
5630 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5631 lower bound for automatic scrolling, i.e. automatic scrolling
5632 will not scroll a window to a column less than the value returned
5633 by this function. This happens in an interactive call. */)
5635 register Lisp_Object arg
, set_minimum
;
5639 struct window
*w
= XWINDOW (selected_window
);
5642 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5644 arg
= Fprefix_numeric_value (arg
);
5646 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5647 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5649 if (!NILP (set_minimum
))
5650 w
->min_hscroll
= w
->hscroll
;
5655 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5656 doc
: /* Return the window which was selected when entering the minibuffer.
5657 Returns nil, if current window is not a minibuffer window. */)
5660 if (minibuf_level
> 0
5661 && MINI_WINDOW_P (XWINDOW (selected_window
))
5662 && WINDOW_LIVE_P (minibuf_selected_window
))
5663 return minibuf_selected_window
;
5668 /* Value is the number of lines actually displayed in window W,
5669 as opposed to its height. */
5672 displayed_window_lines (w
)
5676 struct text_pos start
;
5677 int height
= window_box_height (w
);
5678 struct buffer
*old_buffer
;
5681 if (XBUFFER (w
->buffer
) != current_buffer
)
5683 old_buffer
= current_buffer
;
5684 set_buffer_internal (XBUFFER (w
->buffer
));
5689 /* In case W->start is out of the accessible range, do something
5690 reasonable. This happens in Info mode when Info-scroll-down
5691 calls (recenter -1) while W->start is 1. */
5692 if (XMARKER (w
->start
)->charpos
< BEGV
)
5693 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5694 else if (XMARKER (w
->start
)->charpos
> ZV
)
5695 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5697 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5699 start_display (&it
, w
, start
);
5700 move_it_vertically (&it
, height
);
5701 bottom_y
= line_bottom_y (&it
);
5703 /* rms: On a non-window display,
5704 the value of it.vpos at the bottom of the screen
5705 seems to be 1 larger than window_box_height (w).
5706 This kludge fixes a bug whereby (move-to-window-line -1)
5707 when ZV is on the last screen line
5708 moves to the previous screen line instead of the last one. */
5709 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5712 /* Add in empty lines at the bottom of the window. */
5713 if (bottom_y
< height
)
5715 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5716 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5720 set_buffer_internal (old_buffer
);
5726 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5727 doc
: /* Center point in window and redisplay frame.
5728 With prefix argument ARG, recenter putting point on screen line ARG
5729 relative to the current window. If ARG is negative, it counts up from the
5730 bottom of the window. (ARG should be less than the height of the window.)
5732 If ARG is omitted or nil, erase the entire frame and then
5733 redraw with point in the center of the current window.
5734 Just C-u as prefix means put point in the center of the window
5735 and redisplay normally--don't erase and redraw the frame. */)
5737 register Lisp_Object arg
;
5739 struct window
*w
= XWINDOW (selected_window
);
5740 struct buffer
*buf
= XBUFFER (w
->buffer
);
5741 struct buffer
*obuf
= current_buffer
;
5743 int charpos
, bytepos
;
5745 int this_scroll_margin
;
5747 /* If redisplay is suppressed due to an error, try again. */
5748 obuf
->display_error_modiff
= 0;
5754 /* Invalidate pixel data calculated for all compositions. */
5755 for (i
= 0; i
< n_compositions
; i
++)
5756 composition_table
[i
]->font
= NULL
;
5758 Fredraw_frame (w
->frame
);
5759 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5762 else if (CONSP (arg
)) /* Just C-u. */
5766 arg
= Fprefix_numeric_value (arg
);
5771 set_buffer_internal (buf
);
5773 /* Do this after making BUF current
5774 in case scroll_margin is buffer-local. */
5775 this_scroll_margin
= max (0, scroll_margin
);
5776 this_scroll_margin
= min (this_scroll_margin
,
5777 XFASTINT (w
->total_lines
) / 4);
5779 /* Handle centering on a graphical frame specially. Such frames can
5780 have variable-height lines and centering point on the basis of
5781 line counts would lead to strange effects. */
5782 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5789 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5790 start_display (&it
, w
, pt
);
5791 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5792 charpos
= IT_CHARPOS (it
);
5793 bytepos
= IT_BYTEPOS (it
);
5800 int extra_line_spacing
;
5801 int h
= window_box_height (w
);
5803 iarg
= - max (-iarg
, this_scroll_margin
);
5805 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5806 start_display (&it
, w
, pt
);
5808 /* Be sure we have the exact height of the full line containing PT. */
5809 move_it_by_lines (&it
, 0, 1);
5811 /* The amount of pixels we have to move back is the window
5812 height minus what's displayed in the line containing PT,
5813 and the lines below. */
5816 move_it_by_lines (&it
, nlines
, 1);
5818 if (it
.vpos
== nlines
)
5822 /* Last line has no newline */
5823 h
-= line_bottom_y (&it
);
5827 /* Don't reserve space for extra line spacing of last line. */
5828 extra_line_spacing
= it
.max_extra_line_spacing
;
5830 /* If we can't move down NLINES lines because we hit
5831 the end of the buffer, count in some empty lines. */
5832 if (it
.vpos
< nlines
)
5835 extra_line_spacing
= it
.extra_line_spacing
;
5836 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5841 /* Now find the new top line (starting position) of the window. */
5842 start_display (&it
, w
, pt
);
5844 move_it_vertically_backward (&it
, h
);
5846 /* If extra line spacing is present, we may move too far
5847 back. This causes the last line to be only partially
5848 visible (which triggers redisplay to recenter that line
5849 in the middle), so move forward.
5850 But ignore extra line spacing on last line, as it is not
5851 considered to be part of the visible height of the line.
5853 h
+= extra_line_spacing
;
5854 while (-it
.current_y
> h
)
5855 move_it_by_lines (&it
, 1, 1);
5857 charpos
= IT_CHARPOS (it
);
5858 bytepos
= IT_BYTEPOS (it
);
5862 struct position pos
;
5864 iarg
= max (iarg
, this_scroll_margin
);
5866 pos
= *vmotion (PT
, -iarg
, w
);
5867 charpos
= pos
.bufpos
;
5868 bytepos
= pos
.bytepos
;
5873 struct position pos
;
5874 int ht
= window_internal_height (w
);
5881 /* Don't let it get into the margin at either top or bottom. */
5882 iarg
= max (iarg
, this_scroll_margin
);
5883 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5885 pos
= *vmotion (PT
, - iarg
, w
);
5886 charpos
= pos
.bufpos
;
5887 bytepos
= pos
.bytepos
;
5890 /* Set the new window start. */
5891 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5892 w
->window_end_valid
= Qnil
;
5894 w
->optional_new_start
= Qt
;
5896 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5897 w
->start_at_line_beg
= Qt
;
5899 w
->start_at_line_beg
= Qnil
;
5901 set_buffer_internal (obuf
);
5906 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5908 doc
: /* Return the height in lines of the text display area of WINDOW.
5909 This doesn't include the mode-line (or header-line if any) or any
5910 partial-height lines in the text display area. */)
5914 struct window
*w
= decode_window (window
);
5915 int pixel_height
= window_box_height (w
);
5916 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5917 return make_number (line_height
);
5922 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5924 doc
: /* Position point relative to window.
5925 With no argument, position point at center of window.
5926 An argument specifies vertical position within the window;
5927 zero means top of window, negative means relative to bottom of window. */)
5931 struct window
*w
= XWINDOW (selected_window
);
5935 int this_scroll_margin
;
5938 window
= selected_window
;
5939 start
= marker_position (w
->start
);
5940 if (start
< BEGV
|| start
> ZV
)
5942 int height
= window_internal_height (w
);
5943 Fvertical_motion (make_number (- (height
/ 2)), window
);
5944 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5945 w
->start_at_line_beg
= Fbolp ();
5946 w
->force_start
= Qt
;
5949 Fgoto_char (w
->start
);
5951 lines
= displayed_window_lines (w
);
5954 this_scroll_margin
= max (0, scroll_margin
);
5955 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5959 XSETFASTINT (arg
, lines
/ 2);
5962 int iarg
= XINT (Fprefix_numeric_value (arg
));
5965 iarg
= iarg
+ lines
;
5967 #if 0 /* This code would prevent move-to-window-line from moving point
5968 to a place inside the scroll margins (which would cause the
5969 next redisplay to scroll). I wrote this code, but then concluded
5970 it is probably better not to install it. However, it is here
5971 inside #if 0 so as not to lose it. -- rms. */
5973 /* Don't let it get into the margin at either top or bottom. */
5974 iarg
= max (iarg
, this_scroll_margin
);
5975 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5978 arg
= make_number (iarg
);
5981 /* Skip past a partially visible first line. */
5983 XSETINT (arg
, XINT (arg
) + 1);
5985 return Fvertical_motion (arg
, window
);
5990 /***********************************************************************
5991 Window Configuration
5992 ***********************************************************************/
5994 struct save_window_data
5996 EMACS_INT size_from_Lisp_Vector_struct
;
5997 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5998 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5999 Lisp_Object frame_tool_bar_lines
;
6000 Lisp_Object selected_frame
;
6001 Lisp_Object current_window
;
6002 Lisp_Object current_buffer
;
6003 Lisp_Object minibuf_scroll_window
;
6004 Lisp_Object minibuf_selected_window
;
6005 Lisp_Object root_window
;
6006 Lisp_Object focus_frame
;
6007 /* Record the values of window-min-width and window-min-height
6008 so that window sizes remain consistent with them. */
6009 Lisp_Object min_width
, min_height
;
6010 /* A vector, each of whose elements is a struct saved_window
6012 Lisp_Object saved_windows
;
6015 /* This is saved as a Lisp_Vector */
6018 /* these first two must agree with struct Lisp_Vector in lisp.h */
6019 EMACS_INT size_from_Lisp_Vector_struct
;
6020 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6023 Lisp_Object buffer
, start
, pointm
, mark
;
6024 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
6025 Lisp_Object hscroll
, min_hscroll
;
6026 Lisp_Object parent
, prev
;
6027 Lisp_Object start_at_line_beg
;
6028 Lisp_Object display_table
;
6029 Lisp_Object orig_top_line
, orig_total_lines
;
6030 Lisp_Object left_margin_cols
, right_margin_cols
;
6031 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
6032 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
6033 Lisp_Object dedicated
;
6036 #define SAVED_WINDOW_N(swv,n) \
6037 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
6039 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
6040 doc
: /* Return t if OBJECT is a window-configuration object. */)
6044 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
6047 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
6048 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
6052 register struct save_window_data
*data
;
6053 struct Lisp_Vector
*saved_windows
;
6055 CHECK_WINDOW_CONFIGURATION (config
);
6057 data
= (struct save_window_data
*) XVECTOR (config
);
6058 saved_windows
= XVECTOR (data
->saved_windows
);
6059 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6062 DEFUN ("set-window-configuration", Fset_window_configuration
,
6063 Sset_window_configuration
, 1, 1, 0,
6064 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
6065 CONFIGURATION must be a value previously returned
6066 by `current-window-configuration' (which see).
6067 If CONFIGURATION was made from a frame that is now deleted,
6068 only frame-independent values can be restored. In this case,
6069 the return value is nil. Otherwise the value is t. */)
6071 Lisp_Object configuration
;
6073 register struct save_window_data
*data
;
6074 struct Lisp_Vector
*saved_windows
;
6075 Lisp_Object new_current_buffer
;
6080 CHECK_WINDOW_CONFIGURATION (configuration
);
6082 data
= (struct save_window_data
*) XVECTOR (configuration
);
6083 saved_windows
= XVECTOR (data
->saved_windows
);
6085 new_current_buffer
= data
->current_buffer
;
6086 if (NILP (XBUFFER (new_current_buffer
)->name
))
6087 new_current_buffer
= Qnil
;
6090 if (XBUFFER (new_current_buffer
) == current_buffer
)
6091 /* The code further down "preserves point" by saving here PT in
6092 old_point and then setting it later back into PT. When the
6093 current-selected-window and the final-selected-window both show
6094 the current buffer, this suffers from the problem that the
6095 current PT is the window-point of the current-selected-window,
6096 while the final PT is the point of the final-selected-window, so
6097 this copy from one PT to the other would end up moving the
6098 window-point of the final-selected-window to the window-point of
6099 the current-selected-window. So we have to be careful which
6100 point of the current-buffer we copy into old_point. */
6101 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6102 && WINDOWP (selected_window
)
6103 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
6104 && !EQ (selected_window
, data
->current_window
))
6105 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6109 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6110 point in new_current_buffer as of the last time this buffer was
6111 used. This can be non-deterministic since it can be changed by
6112 things like jit-lock by mere temporary selection of some random
6113 window that happens to show this buffer.
6114 So if possible we want this arbitrary choice of "which point" to
6115 be the one from the to-be-selected-window so as to prevent this
6116 window's cursor from being copied from another window. */
6117 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6118 /* If current_window = selected_window, its point is in BUF_PT. */
6119 && !EQ (selected_window
, data
->current_window
))
6120 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6122 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
6125 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6128 /* If f is a dead frame, don't bother rebuilding its window tree.
6129 However, there is other stuff we should still try to do below. */
6130 if (FRAME_LIVE_P (f
))
6132 register struct window
*w
;
6133 register struct saved_window
*p
;
6134 struct window
*root_window
;
6135 struct window
**leaf_windows
;
6139 /* If the frame has been resized since this window configuration was
6140 made, we change the frame to the size specified in the
6141 configuration, restore the configuration, and then resize it
6142 back. We keep track of the prevailing height in these variables. */
6143 int previous_frame_lines
= FRAME_LINES (f
);
6144 int previous_frame_cols
= FRAME_COLS (f
);
6145 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6146 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6148 /* The mouse highlighting code could get screwed up
6149 if it runs during this. */
6152 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
6153 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
6154 change_frame_size (f
, XFASTINT (data
->frame_lines
),
6155 XFASTINT (data
->frame_cols
), 0, 0, 0);
6156 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6157 if (XFASTINT (data
->frame_menu_bar_lines
)
6158 != previous_frame_menu_bar_lines
)
6159 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
6160 #ifdef HAVE_WINDOW_SYSTEM
6161 if (XFASTINT (data
->frame_tool_bar_lines
)
6162 != previous_frame_tool_bar_lines
)
6163 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
6167 /* "Swap out" point from the selected window's buffer
6168 into the window itself. (Normally the pointm of the selected
6169 window holds garbage.) We do this now, before
6170 restoring the window contents, and prevent it from
6171 being done later on when we select a new window. */
6172 if (! NILP (XWINDOW (selected_window
)->buffer
))
6174 w
= XWINDOW (selected_window
);
6175 set_marker_both (w
->pointm
,
6177 BUF_PT (XBUFFER (w
->buffer
)),
6178 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6181 windows_or_buffers_changed
++;
6182 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6184 /* Problem: Freeing all matrices and later allocating them again
6185 is a serious redisplay flickering problem. What we would
6186 really like to do is to free only those matrices not reused
6188 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6190 = (struct window
**) alloca (count_windows (root_window
)
6191 * sizeof (struct window
*));
6192 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6194 /* Temporarily avoid any problems with windows that are smaller
6195 than they are supposed to be. */
6196 window_min_height
= 1;
6197 window_min_width
= 1;
6200 Mark all windows now on frame as "deleted".
6201 Restoring the new configuration "undeletes" any that are in it.
6203 Save their current buffers in their height fields, since we may
6204 need it later, if a buffer saved in the configuration is now
6206 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6208 for (k
= 0; k
< saved_windows
->size
; k
++)
6210 p
= SAVED_WINDOW_N (saved_windows
, k
);
6211 w
= XWINDOW (p
->window
);
6214 if (!NILP (p
->parent
))
6215 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6216 XFASTINT (p
->parent
))->window
;
6220 if (!NILP (p
->prev
))
6222 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6223 XFASTINT (p
->prev
))->window
;
6224 XWINDOW (w
->prev
)->next
= p
->window
;
6229 if (!NILP (w
->parent
))
6231 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6233 XWINDOW (w
->parent
)->vchild
= p
->window
;
6234 XWINDOW (w
->parent
)->hchild
= Qnil
;
6238 XWINDOW (w
->parent
)->hchild
= p
->window
;
6239 XWINDOW (w
->parent
)->vchild
= Qnil
;
6244 /* If we squirreled away the buffer in the window's height,
6246 if (BUFFERP (w
->total_lines
))
6247 w
->buffer
= w
->total_lines
;
6248 w
->left_col
= p
->left_col
;
6249 w
->top_line
= p
->top_line
;
6250 w
->total_cols
= p
->total_cols
;
6251 w
->total_lines
= p
->total_lines
;
6252 w
->hscroll
= p
->hscroll
;
6253 w
->min_hscroll
= p
->min_hscroll
;
6254 w
->display_table
= p
->display_table
;
6255 w
->orig_top_line
= p
->orig_top_line
;
6256 w
->orig_total_lines
= p
->orig_total_lines
;
6257 w
->left_margin_cols
= p
->left_margin_cols
;
6258 w
->right_margin_cols
= p
->right_margin_cols
;
6259 w
->left_fringe_width
= p
->left_fringe_width
;
6260 w
->right_fringe_width
= p
->right_fringe_width
;
6261 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6262 w
->scroll_bar_width
= p
->scroll_bar_width
;
6263 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6264 w
->dedicated
= p
->dedicated
;
6265 XSETFASTINT (w
->last_modified
, 0);
6266 XSETFASTINT (w
->last_overlay_modified
, 0);
6268 /* Reinstall the saved buffer and pointers into it. */
6269 if (NILP (p
->buffer
))
6270 w
->buffer
= p
->buffer
;
6273 if (!NILP (XBUFFER (p
->buffer
)->name
))
6274 /* If saved buffer is alive, install it. */
6276 w
->buffer
= p
->buffer
;
6277 w
->start_at_line_beg
= p
->start_at_line_beg
;
6278 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6279 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6280 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6281 p
->mark
, w
->buffer
);
6283 /* As documented in Fcurrent_window_configuration, don't
6284 restore the location of point in the buffer which was
6285 current when the window configuration was recorded. */
6286 if (!EQ (p
->buffer
, new_current_buffer
)
6287 && XBUFFER (p
->buffer
) == current_buffer
)
6288 Fgoto_char (w
->pointm
);
6290 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6291 /* Else unless window has a live buffer, get one. */
6293 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6294 /* This will set the markers to beginning of visible
6296 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6297 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6298 w
->start_at_line_beg
= Qt
;
6301 /* Keeping window's old buffer; make sure the markers
6304 /* Set window markers at start of visible range. */
6305 if (XMARKER (w
->start
)->buffer
== 0)
6306 set_marker_restricted (w
->start
, make_number (0),
6308 if (XMARKER (w
->pointm
)->buffer
== 0)
6309 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6310 BUF_PT (XBUFFER (w
->buffer
)),
6311 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6312 w
->start_at_line_beg
= Qt
;
6317 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6318 /* Prevent "swapping out point" in the old selected window
6319 using the buffer that has been restored into it.
6320 We already swapped out point that from that window's old buffer. */
6321 selected_window
= Qnil
;
6323 /* Arrange *not* to restore point in the buffer that was
6324 current when the window configuration was saved. */
6325 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6326 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6327 make_number (old_point
),
6328 XWINDOW (data
->current_window
)->buffer
);
6330 Fselect_window (data
->current_window
, Qnil
);
6331 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6334 if (NILP (data
->focus_frame
)
6335 || (FRAMEP (data
->focus_frame
)
6336 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6337 Fredirect_frame_focus (frame
, data
->focus_frame
);
6339 #if 0 /* I don't understand why this is needed, and it causes problems
6340 when the frame's old selected window has been deleted. */
6341 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6342 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6346 /* Set the screen height to the value it had before this function. */
6347 if (previous_frame_lines
!= FRAME_LINES (f
)
6348 || previous_frame_cols
!= FRAME_COLS (f
))
6349 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6351 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6352 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6353 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6355 #ifdef HAVE_WINDOW_SYSTEM
6356 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6357 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6362 /* Now, free glyph matrices in windows that were not reused. */
6363 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6365 if (NILP (leaf_windows
[i
]->buffer
))
6367 /* Assert it's not reused as a combination. */
6368 xassert (NILP (leaf_windows
[i
]->hchild
)
6369 && NILP (leaf_windows
[i
]->vchild
));
6370 free_window_matrices (leaf_windows
[i
]);
6372 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6380 /* Fselect_window will have made f the selected frame, so we
6381 reselect the proper frame here. Fhandle_switch_frame will change the
6382 selected window too, but that doesn't make the call to
6383 Fselect_window above totally superfluous; it still sets f's
6385 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6386 do_switch_frame (data
->selected_frame
, 0, 0);
6388 if (! NILP (Vwindow_configuration_change_hook
)
6389 && ! NILP (Vrun_hooks
))
6390 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6393 if (!NILP (new_current_buffer
))
6394 Fset_buffer (new_current_buffer
);
6396 /* Restore the minimum heights recorded in the configuration. */
6397 window_min_height
= XINT (data
->min_height
);
6398 window_min_width
= XINT (data
->min_width
);
6400 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6401 minibuf_selected_window
= data
->minibuf_selected_window
;
6403 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6406 /* Mark all windows now on frame as deleted
6407 by setting their buffers to nil. */
6410 delete_all_subwindows (w
)
6411 register struct window
*w
;
6413 if (!NILP (w
->next
))
6414 delete_all_subwindows (XWINDOW (w
->next
));
6415 if (!NILP (w
->vchild
))
6416 delete_all_subwindows (XWINDOW (w
->vchild
));
6417 if (!NILP (w
->hchild
))
6418 delete_all_subwindows (XWINDOW (w
->hchild
));
6420 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6422 if (!NILP (w
->buffer
))
6425 /* We set all three of these fields to nil, to make sure that we can
6426 distinguish this dead window from any live window. Live leaf
6427 windows will have buffer set, and combination windows will have
6428 vchild or hchild set. */
6433 Vwindow_list
= Qnil
;
6437 count_windows (window
)
6438 register struct window
*window
;
6440 register int count
= 1;
6441 if (!NILP (window
->next
))
6442 count
+= count_windows (XWINDOW (window
->next
));
6443 if (!NILP (window
->vchild
))
6444 count
+= count_windows (XWINDOW (window
->vchild
));
6445 if (!NILP (window
->hchild
))
6446 count
+= count_windows (XWINDOW (window
->hchild
));
6451 /* Fill vector FLAT with leaf windows under W, starting at index I.
6452 Value is last index + 1. */
6455 get_leaf_windows (w
, flat
, i
)
6457 struct window
**flat
;
6462 if (!NILP (w
->hchild
))
6463 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6464 else if (!NILP (w
->vchild
))
6465 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6469 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6476 /* Return a pointer to the glyph W's physical cursor is on. Value is
6477 null if W's current matrix is invalid, so that no meaningfull glyph
6481 get_phys_cursor_glyph (w
)
6484 struct glyph_row
*row
;
6485 struct glyph
*glyph
;
6487 if (w
->phys_cursor
.vpos
>= 0
6488 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6489 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6491 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6492 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6501 save_window_save (window
, vector
, i
)
6503 struct Lisp_Vector
*vector
;
6506 register struct saved_window
*p
;
6507 register struct window
*w
;
6508 register Lisp_Object tem
;
6510 for (;!NILP (window
); window
= w
->next
)
6512 p
= SAVED_WINDOW_N (vector
, i
);
6513 w
= XWINDOW (window
);
6515 XSETFASTINT (w
->temslot
, i
); i
++;
6517 p
->buffer
= w
->buffer
;
6518 p
->left_col
= w
->left_col
;
6519 p
->top_line
= w
->top_line
;
6520 p
->total_cols
= w
->total_cols
;
6521 p
->total_lines
= w
->total_lines
;
6522 p
->hscroll
= w
->hscroll
;
6523 p
->min_hscroll
= w
->min_hscroll
;
6524 p
->display_table
= w
->display_table
;
6525 p
->orig_top_line
= w
->orig_top_line
;
6526 p
->orig_total_lines
= w
->orig_total_lines
;
6527 p
->left_margin_cols
= w
->left_margin_cols
;
6528 p
->right_margin_cols
= w
->right_margin_cols
;
6529 p
->left_fringe_width
= w
->left_fringe_width
;
6530 p
->right_fringe_width
= w
->right_fringe_width
;
6531 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6532 p
->scroll_bar_width
= w
->scroll_bar_width
;
6533 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6534 p
->dedicated
= w
->dedicated
;
6535 if (!NILP (w
->buffer
))
6537 /* Save w's value of point in the window configuration.
6538 If w is the selected window, then get the value of point
6539 from the buffer; pointm is garbage in the selected window. */
6540 if (EQ (window
, selected_window
))
6542 p
->pointm
= Fmake_marker ();
6543 set_marker_both (p
->pointm
, w
->buffer
,
6544 BUF_PT (XBUFFER (w
->buffer
)),
6545 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6548 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6550 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6551 p
->start_at_line_beg
= w
->start_at_line_beg
;
6553 tem
= XBUFFER (w
->buffer
)->mark
;
6554 p
->mark
= Fcopy_marker (tem
, Qnil
);
6561 p
->start_at_line_beg
= Qnil
;
6564 if (NILP (w
->parent
))
6567 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6572 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6574 if (!NILP (w
->vchild
))
6575 i
= save_window_save (w
->vchild
, vector
, i
);
6576 if (!NILP (w
->hchild
))
6577 i
= save_window_save (w
->hchild
, vector
, i
);
6583 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6584 Scurrent_window_configuration
, 0, 1, 0,
6585 doc
: /* Return an object representing the current window configuration of FRAME.
6586 If FRAME is nil or omitted, use the selected frame.
6587 This describes the number of windows, their sizes and current buffers,
6588 and for each displayed buffer, where display starts, and the positions of
6589 point and mark. An exception is made for point in the current buffer:
6590 its value is -not- saved.
6591 This also records the currently selected frame, and FRAME's focus
6592 redirection (see `redirect-frame-focus'). */)
6596 register Lisp_Object tem
;
6597 register int n_windows
;
6598 register struct save_window_data
*data
;
6599 register struct Lisp_Vector
*vec
;
6604 frame
= selected_frame
;
6605 CHECK_LIVE_FRAME (frame
);
6608 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6609 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6610 data
= (struct save_window_data
*)vec
;
6612 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6613 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6614 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6615 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6616 data
->selected_frame
= selected_frame
;
6617 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6618 XSETBUFFER (data
->current_buffer
, current_buffer
);
6619 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6620 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6621 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6622 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6623 XSETINT (data
->min_height
, window_min_height
);
6624 XSETINT (data
->min_width
, window_min_width
);
6625 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6626 data
->saved_windows
= tem
;
6627 for (i
= 0; i
< n_windows
; i
++)
6628 XVECTOR (tem
)->contents
[i
]
6629 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6630 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6631 XSETWINDOW_CONFIGURATION (tem
, data
);
6635 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6637 doc
: /* Execute BODY, preserving window sizes and contents.
6638 Return the value of the last form in BODY.
6639 Restore which buffer appears in which window, where display starts,
6640 and the value of point and mark for each window.
6641 Also restore the choice of selected window.
6642 Also restore which buffer is current.
6643 Does not restore the value of point in current buffer.
6644 usage: (save-window-excursion BODY ...) */)
6648 register Lisp_Object val
;
6649 register int count
= SPECPDL_INDEX ();
6651 record_unwind_protect (Fset_window_configuration
,
6652 Fcurrent_window_configuration (Qnil
));
6653 val
= Fprogn (args
);
6654 return unbind_to (count
, val
);
6659 /***********************************************************************
6661 ***********************************************************************/
6667 Lisp_Object tail
= Qnil
;
6668 Lisp_Object result
= Qnil
;
6675 if (!NILP (w
->hchild
))
6676 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6677 window_tree (XWINDOW (w
->hchild
))));
6678 else if (!NILP (w
->vchild
))
6679 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6680 window_tree (XWINDOW (w
->vchild
))));
6684 result
= tail
= Fcons (wn
, Qnil
);
6688 XSETCDR (tail
, Fcons (wn
, Qnil
));
6692 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6700 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6702 doc
: /* Return the window tree for frame FRAME.
6704 The return value is a list of the form (ROOT MINI), where ROOT
6705 represents the window tree of the frame's root window, and MINI
6706 is the frame's minibuffer window.
6708 If the root window is not split, ROOT is the root window itself.
6709 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6710 horizontal split, and t for a vertical split, EDGES gives the combined
6711 size and position of the subwindows in the split, and the rest of the
6712 elements are the subwindows in the split. Each of the subwindows may
6713 again be a window or a list representing a window split, and so on.
6714 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6716 If FRAME is nil or omitted, return information on the currently
6724 frame
= selected_frame
;
6726 CHECK_FRAME (frame
);
6729 if (!FRAME_LIVE_P (f
))
6732 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6736 /***********************************************************************
6738 ***********************************************************************/
6740 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6742 doc
: /* Set width of marginal areas of window WINDOW.
6743 If WINDOW is nil, set margins of the currently selected window.
6744 Second arg LEFT-WIDTH specifies the number of character cells to
6745 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6746 does the same for the right marginal area. A nil width parameter
6747 means no margin. */)
6748 (window
, left_width
, right_width
)
6749 Lisp_Object window
, left_width
, right_width
;
6751 struct window
*w
= decode_window (window
);
6753 /* Translate negative or zero widths to nil.
6754 Margins that are too wide have to be checked elsewhere. */
6756 if (!NILP (left_width
))
6758 CHECK_NUMBER (left_width
);
6759 if (XINT (left_width
) <= 0)
6763 if (!NILP (right_width
))
6765 CHECK_NUMBER (right_width
);
6766 if (XINT (right_width
) <= 0)
6770 if (!EQ (w
->left_margin_cols
, left_width
)
6771 || !EQ (w
->right_margin_cols
, right_width
))
6773 w
->left_margin_cols
= left_width
;
6774 w
->right_margin_cols
= right_width
;
6776 adjust_window_margins (w
);
6778 ++windows_or_buffers_changed
;
6779 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6786 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6788 doc
: /* Get width of marginal areas of window WINDOW.
6789 If WINDOW is omitted or nil, use the currently selected window.
6790 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6791 If a marginal area does not exist, its width will be returned
6796 struct window
*w
= decode_window (window
);
6797 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6802 /***********************************************************************
6804 ***********************************************************************/
6806 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6808 doc
: /* Set the fringe widths of window WINDOW.
6809 If WINDOW is nil, set the fringe widths of the currently selected
6811 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6812 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6813 fringe width. If a fringe width arg is nil, that means to use the
6814 frame's default fringe width. Default fringe widths can be set with
6815 the command `set-fringe-style'.
6816 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6817 outside of the display margins. By default, fringes are drawn between
6818 display marginal areas and the text area. */)
6819 (window
, left_width
, right_width
, outside_margins
)
6820 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6822 struct window
*w
= decode_window (window
);
6824 if (!NILP (left_width
))
6825 CHECK_NATNUM (left_width
);
6826 if (!NILP (right_width
))
6827 CHECK_NATNUM (right_width
);
6829 /* Do nothing on a tty. */
6830 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6831 && (!EQ (w
->left_fringe_width
, left_width
)
6832 || !EQ (w
->right_fringe_width
, right_width
)
6833 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6835 w
->left_fringe_width
= left_width
;
6836 w
->right_fringe_width
= right_width
;
6837 w
->fringes_outside_margins
= outside_margins
;
6839 adjust_window_margins (w
);
6841 clear_glyph_matrix (w
->current_matrix
);
6842 w
->window_end_valid
= Qnil
;
6844 ++windows_or_buffers_changed
;
6845 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6852 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6854 doc
: /* Get width of fringes of window WINDOW.
6855 If WINDOW is omitted or nil, use the currently selected window.
6856 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6860 struct window
*w
= decode_window (window
);
6862 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6863 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6864 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6865 ? Qt
: Qnil
), Qnil
)));
6870 /***********************************************************************
6872 ***********************************************************************/
6874 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6876 doc
: /* Set width and type of scroll bars of window WINDOW.
6877 If window is nil, set scroll bars of the currently selected window.
6878 Second parameter WIDTH specifies the pixel width for the scroll bar;
6879 this is automatically adjusted to a multiple of the frame column width.
6880 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6881 bar: left, right, or nil.
6882 If WIDTH is nil, use the frame's scroll-bar width.
6883 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6884 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6885 (window
, width
, vertical_type
, horizontal_type
)
6886 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6888 struct window
*w
= decode_window (window
);
6892 CHECK_NATNUM (width
);
6894 if (XINT (width
) == 0)
6895 vertical_type
= Qnil
;
6898 if (!(EQ (vertical_type
, Qnil
)
6899 || EQ (vertical_type
, Qleft
)
6900 || EQ (vertical_type
, Qright
)
6901 || EQ (vertical_type
, Qt
)))
6902 error ("Invalid type of vertical scroll bar");
6904 if (!EQ (w
->scroll_bar_width
, width
)
6905 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6907 w
->scroll_bar_width
= width
;
6908 w
->vertical_scroll_bar_type
= vertical_type
;
6910 adjust_window_margins (w
);
6912 clear_glyph_matrix (w
->current_matrix
);
6913 w
->window_end_valid
= Qnil
;
6915 ++windows_or_buffers_changed
;
6916 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6923 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6925 doc
: /* Get width and type of scroll bars of window WINDOW.
6926 If WINDOW is omitted or nil, use the currently selected window.
6927 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6928 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6933 struct window
*w
= decode_window (window
);
6934 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6935 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6936 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6937 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6938 Fcons (w
->vertical_scroll_bar_type
,
6939 Fcons (Qnil
, Qnil
))));
6944 /***********************************************************************
6946 ***********************************************************************/
6948 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6949 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6950 Use the selected window if WINDOW is nil or omitted.
6951 Normally, value is a multiple of the canonical character height of WINDOW;
6952 optional second arg PIXELS-P means value is measured in pixels. */)
6954 Lisp_Object window
, pixels_p
;
6961 window
= selected_window
;
6963 CHECK_WINDOW (window
);
6964 w
= XWINDOW (window
);
6965 f
= XFRAME (w
->frame
);
6967 if (FRAME_WINDOW_P (f
))
6968 result
= (NILP (pixels_p
)
6969 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6970 : make_number (-w
->vscroll
));
6972 result
= make_number (0);
6977 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6979 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6980 WINDOW nil means use the selected window. Normally, VSCROLL is a
6981 non-negative multiple of the canonical character height of WINDOW;
6982 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6983 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6984 corresponds to an integral number of pixels. The return value is the
6985 result of this rounding.
6986 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6987 (window
, vscroll
, pixels_p
)
6988 Lisp_Object window
, vscroll
, pixels_p
;
6994 window
= selected_window
;
6996 CHECK_WINDOW (window
);
6997 CHECK_NUMBER_OR_FLOAT (vscroll
);
6999 w
= XWINDOW (window
);
7000 f
= XFRAME (w
->frame
);
7002 if (FRAME_WINDOW_P (f
))
7004 int old_dy
= w
->vscroll
;
7006 w
->vscroll
= - (NILP (pixels_p
)
7007 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
7008 : XFLOATINT (vscroll
));
7009 w
->vscroll
= min (w
->vscroll
, 0);
7011 if (w
->vscroll
!= old_dy
)
7013 /* Adjust glyph matrix of the frame if the virtual display
7014 area becomes larger than before. */
7015 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
7018 /* Prevent redisplay shortcuts. */
7019 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
7023 return Fwindow_vscroll (window
, pixels_p
);
7027 /* Call FN for all leaf windows on frame F. FN is called with the
7028 first argument being a pointer to the leaf window, and with
7029 additional argument USER_DATA. Stops when FN returns 0. */
7032 foreach_window (f
, fn
, user_data
)
7034 int (* fn
) P_ ((struct window
*, void *));
7037 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
7038 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
7039 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
7043 /* Helper function for foreach_window. Call FN for all leaf windows
7044 reachable from W. FN is called with the first argument being a
7045 pointer to the leaf window, and with additional argument USER_DATA.
7046 Stop when FN returns 0. Value is 0 if stopped by FN. */
7049 foreach_window_1 (w
, fn
, user_data
)
7051 int (* fn
) P_ ((struct window
*, void *));
7056 for (cont
= 1; w
&& cont
;)
7058 if (!NILP (w
->hchild
))
7059 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
7060 else if (!NILP (w
->vchild
))
7061 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
7063 cont
= fn (w
, user_data
);
7065 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
7072 /* Freeze or unfreeze the window start of W unless it is a
7073 mini-window or the selected window. FREEZE_P non-null means freeze
7074 the window start. */
7077 freeze_window_start (w
, freeze_p
)
7081 if (w
== XWINDOW (selected_window
)
7082 || MINI_WINDOW_P (w
)
7083 || (MINI_WINDOW_P (XWINDOW (selected_window
))
7084 && ! NILP (Vminibuf_scroll_window
)
7085 && w
== XWINDOW (Vminibuf_scroll_window
)))
7088 w
->frozen_window_start_p
= freeze_p
!= NULL
;
7093 /* Freeze or unfreeze the window starts of all leaf windows on frame
7094 F, except the selected window and a mini-window. FREEZE_P non-zero
7095 means freeze the window start. */
7098 freeze_window_starts (f
, freeze_p
)
7102 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
7106 /***********************************************************************
7108 ***********************************************************************/
7110 /* Return 1 if window configurations C1 and C2
7111 describe the same state of affairs. This is used by Fequal. */
7114 compare_window_configurations (c1
, c2
, ignore_positions
)
7116 int ignore_positions
;
7118 register struct save_window_data
*d1
, *d2
;
7119 struct Lisp_Vector
*sw1
, *sw2
;
7122 CHECK_WINDOW_CONFIGURATION (c1
);
7123 CHECK_WINDOW_CONFIGURATION (c2
);
7125 d1
= (struct save_window_data
*) XVECTOR (c1
);
7126 d2
= (struct save_window_data
*) XVECTOR (c2
);
7127 sw1
= XVECTOR (d1
->saved_windows
);
7128 sw2
= XVECTOR (d2
->saved_windows
);
7130 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
7132 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
7134 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
7136 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
7138 /* Don't compare the current_window field directly.
7139 Instead see w1_is_current and w2_is_current, below. */
7140 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
7142 if (! ignore_positions
)
7144 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
7146 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
7149 /* Don't compare the root_window field.
7150 We don't require the two configurations
7151 to use the same window object,
7152 and the two root windows must be equivalent
7153 if everything else compares equal. */
7154 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
7156 if (! EQ (d1
->min_width
, d2
->min_width
))
7158 if (! EQ (d1
->min_height
, d2
->min_height
))
7161 /* Verify that the two confis have the same number of windows. */
7162 if (sw1
->size
!= sw2
->size
)
7165 for (i
= 0; i
< sw1
->size
; i
++)
7167 struct saved_window
*p1
, *p2
;
7168 int w1_is_current
, w2_is_current
;
7170 p1
= SAVED_WINDOW_N (sw1
, i
);
7171 p2
= SAVED_WINDOW_N (sw2
, i
);
7173 /* Verify that the current windows in the two
7174 configurations correspond to each other. */
7175 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7176 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7178 if (w1_is_current
!= w2_is_current
)
7181 /* Verify that the corresponding windows do match. */
7182 if (! EQ (p1
->buffer
, p2
->buffer
))
7184 if (! EQ (p1
->left_col
, p2
->left_col
))
7186 if (! EQ (p1
->top_line
, p2
->top_line
))
7188 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7190 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7192 if (! EQ (p1
->display_table
, p2
->display_table
))
7194 if (! EQ (p1
->parent
, p2
->parent
))
7196 if (! EQ (p1
->prev
, p2
->prev
))
7198 if (! ignore_positions
)
7200 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7202 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7204 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7206 if (NILP (Fequal (p1
->start
, p2
->start
)))
7208 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7210 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7213 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7215 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7217 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7219 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7221 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7223 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7225 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7232 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7233 Scompare_window_configurations
, 2, 2, 0,
7234 doc
: /* Compare two window configurations as regards the structure of windows.
7235 This function ignores details such as the values of point and mark
7236 and scrolling positions. */)
7240 if (compare_window_configurations (x
, y
, 1))
7248 struct frame
*f
= make_initial_frame ();
7249 XSETFRAME (selected_frame
, f
);
7250 Vterminal_frame
= selected_frame
;
7251 minibuf_window
= f
->minibuffer_window
;
7252 selected_window
= f
->selected_window
;
7253 last_nonminibuf_frame
= f
;
7255 window_initialized
= 1;
7261 Vwindow_list
= Qnil
;
7267 Qscroll_up
= intern ("scroll-up");
7268 staticpro (&Qscroll_up
);
7270 Qscroll_down
= intern ("scroll-down");
7271 staticpro (&Qscroll_down
);
7273 Qwindow_size_fixed
= intern ("window-size-fixed");
7274 staticpro (&Qwindow_size_fixed
);
7275 Fset (Qwindow_size_fixed
, Qnil
);
7277 staticpro (&Qwindow_configuration_change_hook
);
7278 Qwindow_configuration_change_hook
7279 = intern ("window-configuration-change-hook");
7281 Qwindowp
= intern ("windowp");
7282 staticpro (&Qwindowp
);
7284 Qwindow_configuration_p
= intern ("window-configuration-p");
7285 staticpro (&Qwindow_configuration_p
);
7287 Qwindow_live_p
= intern ("window-live-p");
7288 staticpro (&Qwindow_live_p
);
7290 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7291 staticpro (&Qtemp_buffer_show_hook
);
7293 staticpro (&Vwindow_list
);
7295 minibuf_selected_window
= Qnil
;
7296 staticpro (&minibuf_selected_window
);
7298 window_scroll_pixel_based_preserve_y
= -1;
7300 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7301 doc
: /* Non-nil means call as function to display a help buffer.
7302 The function is called with one argument, the buffer to be displayed.
7303 Used by `with-output-to-temp-buffer'.
7304 If this function is used, then it must do the entire job of showing
7305 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7306 Vtemp_buffer_show_function
= Qnil
;
7308 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7309 doc
: /* If non-nil, function to call to handle `display-buffer'.
7310 It will receive two args, the buffer and a flag which if non-nil means
7311 that the currently selected window is not acceptable.
7312 It should choose or create a window, display the specified buffer in it,
7313 and return the window.
7314 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7315 work using this function. */);
7316 Vdisplay_buffer_function
= Qnil
;
7318 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7319 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7320 If nil, `display-buffer' will leave the window configuration alone. */);
7321 Veven_window_heights
= Qt
;
7323 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7324 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7325 Vminibuf_scroll_window
= Qnil
;
7327 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7328 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7329 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7330 is displayed in the `mode-line' face. */);
7331 mode_line_in_non_selected_windows
= 1;
7333 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7334 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7335 Vother_window_scroll_buffer
= Qnil
;
7337 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7338 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7341 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7342 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7343 auto_window_vscroll_p
= 1;
7345 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7346 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7347 If the buffer in question is already displayed in a frame, raise that frame. */);
7348 display_buffer_reuse_frames
= 0;
7350 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7351 doc
: /* Function to call to handle automatic new frame creation.
7352 It is called with no arguments and should return a newly created frame.
7354 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7355 where `pop-up-frame-alist' would hold the default frame parameters. */);
7356 Vpop_up_frame_function
= Qnil
;
7358 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7359 doc
: /* *List of buffer names that should have their own special frames.
7360 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7361 if its name is in this list, makes a special frame for it
7362 using `special-display-function'. See also `special-display-regexps'.
7364 An element of the list can be a list instead of just a string.
7365 There are two ways to use a list as an element:
7366 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7367 In the first case, the FRAME-PARAMETERS are pairs of the form
7368 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7369 In the second case, FUNCTION is called with BUFFER as the first argument,
7370 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7371 All this is done by the function found in `special-display-function'.
7373 If the specified frame parameters include (same-buffer . t), the
7374 buffer is displayed in the currently selected window. Otherwise, if
7375 they include (same-frame . t), the buffer is displayed in a new window
7376 in the currently selected frame.
7378 If this variable appears \"not to work\", because you add a name to it
7379 but that buffer still appears in the selected window, look at the
7380 values of `same-window-buffer-names' and `same-window-regexps'.
7381 Those variables take precedence over this one. */);
7382 Vspecial_display_buffer_names
= Qnil
;
7384 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7385 doc
: /* *List of regexps saying which buffers should have their own special frames.
7386 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7387 if any regexp in this list matches the buffer name, it makes a
7388 special frame for the buffer by calling `special-display-function'.
7390 An element of the list can be a list instead of just a string.
7391 There are two ways to use a list as an element:
7392 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7393 In the first case, the FRAME-PARAMETERS are pairs of the form
7394 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7395 In the second case, FUNCTION is called with BUFFER as the first argument,
7396 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7397 All this is done by the function found in `special-display-function'.
7399 If the specified frame parameters include (same-buffer . t), the
7400 buffer is displayed in the currently selected window. Otherwise, if
7401 they include (same-frame . t), the buffer is displayed in a new window
7402 in the currently selected frame.
7404 If this variable appears \"not to work\", because you add a regexp to it
7405 but the matching buffers still appear in the selected window, look at the
7406 values of `same-window-buffer-names' and `same-window-regexps'.
7407 Those variables take precedence over this one. */);
7408 Vspecial_display_regexps
= Qnil
;
7410 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7411 doc
: /* Function to call to make a new frame for a special buffer.
7412 It is called with two arguments, the buffer and optional buffer specific
7413 data, and should return a window displaying that buffer.
7414 The default value normally makes a separate frame for the buffer,
7415 using `special-display-frame-alist' to specify the frame parameters.
7416 But if the buffer specific data includes (same-buffer . t) then the
7417 buffer is displayed in the current selected window.
7418 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7419 a new window in the currently selected frame.
7421 A buffer is special if it is listed in `special-display-buffer-names'
7422 or matches a regexp in `special-display-regexps'. */);
7423 Vspecial_display_function
= Qnil
;
7425 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7426 doc
: /* *List of buffer names that should appear in the selected window.
7427 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7428 switches to it in the selected window, rather than making it appear
7429 in some other window.
7431 An element of the list can be a cons cell instead of just a string.
7432 Then the car must be a string, which specifies the buffer name.
7433 This is for compatibility with `special-display-buffer-names';
7434 the cdr of the cons cell is ignored.
7436 See also `same-window-regexps'. */);
7437 Vsame_window_buffer_names
= Qnil
;
7439 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7440 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7441 If a buffer name matches one of these regexps, then displaying it
7442 using `display-buffer' or `pop-to-buffer' switches to it
7443 in the selected window, rather than making it appear in some other window.
7445 An element of the list can be a cons cell instead of just a string.
7446 Then the car must be a string, which specifies the buffer name.
7447 This is for compatibility with `special-display-buffer-names';
7448 the cdr of the cons cell is ignored.
7450 See also `same-window-buffer-names'. */);
7451 Vsame_window_regexps
= Qnil
;
7453 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7454 doc
: /* *Non-nil means display-buffer should make new windows. */);
7457 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7458 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7459 next_screen_context_lines
= 2;
7461 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7462 doc
: /* *A window must be at least this tall to be eligible for splitting
7463 by `display-buffer'. The value is in line units.
7464 If there is only one window, it is split regardless of this value. */);
7465 split_height_threshold
= 500;
7467 DEFVAR_INT ("window-min-height", &window_min_height
,
7468 doc
: /* *Delete any window less than this tall (including its mode line).
7469 The value is in line units. */);
7470 window_min_height
= 4;
7472 DEFVAR_INT ("window-min-width", &window_min_width
,
7473 doc
: /* *Delete any window less than this wide (measured in characters). */);
7474 window_min_width
= 10;
7476 DEFVAR_LISP ("scroll-preserve-screen-position",
7477 &Vscroll_preserve_screen_position
,
7478 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7479 A value of nil means point does not keep its screen position except
7480 at the scroll margin or window boundary respectively.
7481 A value of t means point keeps its screen position if the scroll
7482 command moved it vertically out of the window, e.g. when scrolling
7484 Any other value means point always keeps its screen position. */);
7485 Vscroll_preserve_screen_position
= Qnil
;
7487 DEFVAR_LISP ("window-configuration-change-hook",
7488 &Vwindow_configuration_change_hook
,
7489 doc
: /* Functions to call when window configuration changes.
7490 The selected frame is the one whose configuration has changed. */);
7491 Vwindow_configuration_change_hook
= Qnil
;
7493 defsubr (&Sselected_window
);
7494 defsubr (&Sminibuffer_window
);
7495 defsubr (&Swindow_minibuffer_p
);
7496 defsubr (&Swindowp
);
7497 defsubr (&Swindow_live_p
);
7498 defsubr (&Spos_visible_in_window_p
);
7499 defsubr (&Swindow_line_height
);
7500 defsubr (&Swindow_buffer
);
7501 defsubr (&Swindow_height
);
7502 defsubr (&Swindow_width
);
7503 defsubr (&Swindow_hscroll
);
7504 defsubr (&Sset_window_hscroll
);
7505 defsubr (&Swindow_redisplay_end_trigger
);
7506 defsubr (&Sset_window_redisplay_end_trigger
);
7507 defsubr (&Swindow_edges
);
7508 defsubr (&Swindow_pixel_edges
);
7509 defsubr (&Swindow_inside_edges
);
7510 defsubr (&Swindow_inside_pixel_edges
);
7511 defsubr (&Scoordinates_in_window_p
);
7512 defsubr (&Swindow_at
);
7513 defsubr (&Swindow_point
);
7514 defsubr (&Swindow_start
);
7515 defsubr (&Swindow_end
);
7516 defsubr (&Sset_window_point
);
7517 defsubr (&Sset_window_start
);
7518 defsubr (&Swindow_dedicated_p
);
7519 defsubr (&Sset_window_dedicated_p
);
7520 defsubr (&Swindow_display_table
);
7521 defsubr (&Sset_window_display_table
);
7522 defsubr (&Snext_window
);
7523 defsubr (&Sprevious_window
);
7524 defsubr (&Sother_window
);
7525 defsubr (&Sget_lru_window
);
7526 defsubr (&Sget_largest_window
);
7527 defsubr (&Sget_buffer_window
);
7528 defsubr (&Sdelete_other_windows
);
7529 defsubr (&Sdelete_windows_on
);
7530 defsubr (&Sreplace_buffer_in_windows
);
7531 defsubr (&Sdelete_window
);
7532 defsubr (&Sset_window_buffer
);
7533 defsubr (&Sselect_window
);
7534 defsubr (&Sspecial_display_p
);
7535 defsubr (&Ssame_window_p
);
7536 defsubr (&Sdisplay_buffer
);
7537 defsubr (&Sforce_window_update
);
7538 defsubr (&Ssplit_window
);
7539 defsubr (&Senlarge_window
);
7540 defsubr (&Sshrink_window
);
7541 defsubr (&Sadjust_window_trailing_edge
);
7542 defsubr (&Sscroll_up
);
7543 defsubr (&Sscroll_down
);
7544 defsubr (&Sscroll_left
);
7545 defsubr (&Sscroll_right
);
7546 defsubr (&Sother_window_for_scrolling
);
7547 defsubr (&Sscroll_other_window
);
7548 defsubr (&Sminibuffer_selected_window
);
7549 defsubr (&Srecenter
);
7550 defsubr (&Swindow_text_height
);
7551 defsubr (&Smove_to_window_line
);
7552 defsubr (&Swindow_configuration_p
);
7553 defsubr (&Swindow_configuration_frame
);
7554 defsubr (&Sset_window_configuration
);
7555 defsubr (&Scurrent_window_configuration
);
7556 defsubr (&Ssave_window_excursion
);
7557 defsubr (&Swindow_tree
);
7558 defsubr (&Sset_window_margins
);
7559 defsubr (&Swindow_margins
);
7560 defsubr (&Sset_window_fringes
);
7561 defsubr (&Swindow_fringes
);
7562 defsubr (&Sset_window_scroll_bars
);
7563 defsubr (&Swindow_scroll_bars
);
7564 defsubr (&Swindow_vscroll
);
7565 defsubr (&Sset_window_vscroll
);
7566 defsubr (&Scompare_window_configurations
);
7567 defsubr (&Swindow_list
);
7573 initial_define_key (control_x_map
, '1', "delete-other-windows");
7574 initial_define_key (control_x_map
, '2', "split-window");
7575 initial_define_key (control_x_map
, '0', "delete-window");
7576 initial_define_key (control_x_map
, 'o', "other-window");
7577 initial_define_key (control_x_map
, '^', "enlarge-window");
7578 initial_define_key (control_x_map
, '<', "scroll-left");
7579 initial_define_key (control_x_map
, '>', "scroll-right");
7581 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7582 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7583 initial_define_key (meta_map
, 'v', "scroll-down");
7585 initial_define_key (global_map
, Ctl('L'), "recenter");
7586 initial_define_key (meta_map
, 'r', "move-to-window-line");
7589 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7590 (do not change this comment) */