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, 2007 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).
543 WINDOW defaults to the selected window. */)
547 return decode_any_window (window
)->total_lines
;
550 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
551 doc
: /* Return the number of display columns in WINDOW.
552 This is the width that is usable columns available for text in WINDOW.
553 If you want to find out how many columns WINDOW takes up,
554 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
558 return make_number (window_box_text_cols (decode_any_window (window
)));
561 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
562 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
563 WINDOW defaults to the selected window. */)
567 return decode_window (window
)->hscroll
;
570 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
571 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
572 Return NCOL. NCOL should be zero or positive.
574 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
575 window so that the location of point moves off-window. */)
577 Lisp_Object window
, ncol
;
579 struct window
*w
= decode_window (window
);
583 hscroll
= max (0, XINT (ncol
));
585 /* Prevent redisplay shortcuts when changing the hscroll. */
586 if (XINT (w
->hscroll
) != hscroll
)
587 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
589 w
->hscroll
= make_number (hscroll
);
593 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
594 Swindow_redisplay_end_trigger
, 0, 1, 0,
595 doc
: /* Return WINDOW's redisplay end trigger value.
596 WINDOW defaults to the selected window.
597 See `set-window-redisplay-end-trigger' for more information. */)
601 return decode_window (window
)->redisplay_end_trigger
;
604 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
605 Sset_window_redisplay_end_trigger
, 2, 2, 0,
606 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
607 VALUE should be a buffer position (typically a marker) or nil.
608 If it is a buffer position, then if redisplay in WINDOW reaches a position
609 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
610 with two arguments: WINDOW, and the end trigger value.
611 Afterwards the end-trigger value is reset to nil. */)
613 register Lisp_Object window
, value
;
615 register struct window
*w
;
617 w
= decode_window (window
);
618 w
->redisplay_end_trigger
= value
;
622 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
623 doc
: /* Return a list of the edge coordinates of WINDOW.
624 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
625 RIGHT is one more than the rightmost column occupied by WINDOW,
626 and BOTTOM is one more than the bottommost row occupied by WINDOW.
627 The edges include the space used by the window's scroll bar,
628 display margins, fringes, header line, and mode line, if it has them.
629 To get the edges of the actual text area, use `window-inside-edges'. */)
633 register struct window
*w
= decode_any_window (window
);
635 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
636 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
637 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
638 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
642 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
643 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
644 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
645 RIGHT is one more than the rightmost x position occupied by WINDOW,
646 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
647 The pixel edges include the space used by the window's scroll bar,
648 display margins, fringes, header line, and mode line, if it has them.
649 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
653 register struct window
*w
= decode_any_window (window
);
655 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
656 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
657 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
658 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
662 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
663 doc
: /* Return a list of the edge coordinates of WINDOW.
664 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
665 RIGHT is one more than the rightmost column used by text in WINDOW,
666 and BOTTOM is one more than the bottommost row used by text in WINDOW.
667 The inside edges do not include the space used by the window's scroll bar,
668 display margins, fringes, header line, and/or mode line. */)
672 register struct window
*w
= decode_any_window (window
);
674 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
675 + WINDOW_LEFT_MARGIN_COLS (w
)
676 + WINDOW_LEFT_FRINGE_COLS (w
)),
677 make_number (WINDOW_TOP_EDGE_LINE (w
)
678 + WINDOW_HEADER_LINE_LINES (w
)),
679 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
680 - WINDOW_RIGHT_MARGIN_COLS (w
)
681 - WINDOW_RIGHT_FRINGE_COLS (w
)),
682 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
683 - WINDOW_MODE_LINE_LINES (w
)));
686 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
687 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
688 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
689 RIGHT is one more than the rightmost x position used by text in WINDOW,
690 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
691 The inside edges do not include the space used by the window's scroll bar,
692 display margins, fringes, header line, and/or mode line. */)
696 register struct window
*w
= decode_any_window (window
);
698 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
699 + WINDOW_LEFT_MARGIN_WIDTH (w
)
700 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
701 make_number (WINDOW_TOP_EDGE_Y (w
)
702 + WINDOW_HEADER_LINE_HEIGHT (w
)),
703 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
704 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
705 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
706 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
707 - WINDOW_MODE_LINE_HEIGHT (w
)));
710 /* Test if the character at column *X, row *Y is within window W.
711 If it is not, return ON_NOTHING;
712 if it is in the window's text area,
713 set *x and *y to its location relative to the upper left corner
716 if it is on the window's modeline, return ON_MODE_LINE;
717 if it is on the border between the window and its right sibling,
718 return ON_VERTICAL_BORDER.
719 if it is on a scroll bar,
720 return ON_SCROLL_BAR.
721 if it is on the window's top line, return ON_HEADER_LINE;
722 if it is in left or right fringe of the window,
723 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
724 to window-relative coordinates;
725 if it is in the marginal area to the left/right of the window,
726 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
727 to window-relative coordinates.
729 X and Y are frame relative pixel coordinates. */
731 static enum window_part
732 coordinates_in_window (w
, x
, y
)
733 register struct window
*w
;
736 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
737 int left_x
, right_x
, top_y
, bottom_y
;
738 enum window_part part
;
739 int ux
= FRAME_COLUMN_WIDTH (f
);
740 int x0
= WINDOW_LEFT_EDGE_X (w
);
741 int x1
= WINDOW_RIGHT_EDGE_X (w
);
742 /* The width of the area where the vertical line can be dragged.
743 (Between mode lines for instance. */
744 int grabbable_width
= ux
;
745 int lmargin_width
, rmargin_width
, text_left
, text_right
;
747 /* In what's below, we subtract 1 when computing right_x because we
748 want the rightmost pixel, which is given by left_pixel+width-1. */
749 if (w
->pseudo_window_p
)
752 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
753 top_y
= WINDOW_TOP_EDGE_Y (w
);
754 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
758 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
759 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
760 top_y
= WINDOW_TOP_EDGE_Y (w
);
761 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
764 /* Outside any interesting row? */
765 if (*y
< top_y
|| *y
>= bottom_y
)
768 /* On the mode line or header line? If it's near the start of
769 the mode or header line of window that's has a horizontal
770 sibling, say it's on the vertical line. That's to be able
771 to resize windows horizontally in case we're using toolkit
774 if (WINDOW_WANTS_MODELINE_P (w
)
775 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
779 header_vertical_border_check
:
780 /* We're somewhere on the mode line. We consider the place
781 between mode lines of horizontally adjacent mode lines
782 as the vertical border. If scroll bars on the left,
783 return the right window. */
784 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
785 || WINDOW_RIGHTMOST_P (w
))
787 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
789 /* Convert X and Y to window relative coordinates.
790 Vertical border is at the left edge of window. */
791 *x
= max (0, *x
- x0
);
793 return ON_VERTICAL_BORDER
;
798 if (abs (*x
- x1
) < grabbable_width
)
800 /* Convert X and Y to window relative coordinates.
801 Vertical border is at the right edge of window. */
802 *x
= min (x1
, *x
) - x0
;
804 return ON_VERTICAL_BORDER
;
808 if (*x
< x0
|| *x
>= x1
)
811 /* Convert X and Y to window relative coordinates.
812 Mode line starts at left edge of window. */
818 if (WINDOW_WANTS_HEADER_LINE_P (w
)
819 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
821 part
= ON_HEADER_LINE
;
822 goto header_vertical_border_check
;
825 if (*x
< x0
|| *x
>= x1
)
828 /* Outside any interesting column? */
829 if (*x
< left_x
|| *x
> right_x
)
832 return ON_SCROLL_BAR
;
835 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
836 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
838 text_left
= window_box_left (w
, TEXT_AREA
);
839 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
841 if (FRAME_WINDOW_P (f
))
843 if (!w
->pseudo_window_p
844 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
845 && !WINDOW_RIGHTMOST_P (w
)
846 && (abs (*x
- right_x
) < grabbable_width
))
848 /* Convert X and Y to window relative coordinates.
849 Vertical border is at the right edge of window. */
850 *x
= min (right_x
, *x
) - left_x
;
852 return ON_VERTICAL_BORDER
;
857 /* Need to say "*x > right_x" rather than >=, since on character
858 terminals, the vertical line's x coordinate is right_x. */
859 if (!w
->pseudo_window_p
860 && !WINDOW_RIGHTMOST_P (w
)
861 && *x
> right_x
- ux
)
863 /* On the border on the right side of the window? Assume that
864 this area begins at RIGHT_X minus a canonical char width. */
865 *x
= min (right_x
, *x
) - left_x
;
867 return ON_VERTICAL_BORDER
;
873 if (lmargin_width
> 0
874 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
875 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
876 : (*x
< left_x
+ lmargin_width
)))
879 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
880 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
882 return ON_LEFT_MARGIN
;
885 /* Convert X and Y to window-relative pixel coordinates. */
888 return ON_LEFT_FRINGE
;
891 if (*x
>= text_right
)
893 if (rmargin_width
> 0
894 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
895 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
896 : (*x
>= right_x
- rmargin_width
)))
898 *x
-= right_x
- rmargin_width
;
899 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
900 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
902 return ON_RIGHT_MARGIN
;
905 /* Convert X and Y to window-relative pixel coordinates. */
906 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
908 return ON_RIGHT_FRINGE
;
911 /* Everything special ruled out - must be on text area */
918 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
919 Scoordinates_in_window_p
, 2, 2, 0,
920 doc
: /* Return non-nil if COORDINATES are in WINDOW.
921 COORDINATES is a cons of the form (X . Y), X and Y being distances
922 measured in characters from the upper-left corner of the frame.
923 \(0 . 0) denotes the character in the upper left corner of the
925 If COORDINATES are in the text portion of WINDOW,
926 the coordinates relative to the window are returned.
927 If they are in the mode line of WINDOW, `mode-line' is returned.
928 If they are in the top mode line of WINDOW, `header-line' is returned.
929 If they are in the left fringe of WINDOW, `left-fringe' is returned.
930 If they are in the right fringe of WINDOW, `right-fringe' is returned.
931 If they are on the border between WINDOW and its right sibling,
932 `vertical-line' is returned.
933 If they are in the windows's left or right marginal areas, `left-margin'\n\
934 or `right-margin' is returned. */)
935 (coordinates
, window
)
936 register Lisp_Object coordinates
, window
;
943 CHECK_WINDOW (window
);
944 w
= XWINDOW (window
);
945 f
= XFRAME (w
->frame
);
946 CHECK_CONS (coordinates
);
947 lx
= Fcar (coordinates
);
948 ly
= Fcdr (coordinates
);
949 CHECK_NUMBER_OR_FLOAT (lx
);
950 CHECK_NUMBER_OR_FLOAT (ly
);
951 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
952 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
954 switch (coordinates_in_window (w
, &x
, &y
))
960 /* X and Y are now window relative pixel coordinates. Convert
961 them to canonical char units before returning them. */
962 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
963 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
968 case ON_VERTICAL_BORDER
:
969 return Qvertical_line
;
977 case ON_RIGHT_FRINGE
:
978 return Qright_fringe
;
983 case ON_RIGHT_MARGIN
:
984 return Qright_margin
;
987 /* Historically we are supposed to return nil in this case. */
996 /* Callback for foreach_window, used in window_from_coordinates.
997 Check if window W contains coordinates specified by USER_DATA which
998 is actually a pointer to a struct check_window_data CW.
1000 Check if window W contains coordinates *CW->x and *CW->y. If it
1001 does, return W in *CW->window, as Lisp_Object, and return in
1002 *CW->part the part of the window under coordinates *X,*Y. Return
1003 zero from this function to stop iterating over windows. */
1005 struct check_window_data
1007 Lisp_Object
*window
;
1009 enum window_part
*part
;
1013 check_window_containing (w
, user_data
)
1017 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1018 enum window_part found
;
1021 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1022 if (found
!= ON_NOTHING
)
1025 XSETWINDOW (*cw
->window
, w
);
1033 /* Find the window containing frame-relative pixel position X/Y and
1034 return it as a Lisp_Object.
1036 If X, Y is on one of the window's special `window_part' elements,
1037 set *PART to the id of that element, and return X and Y converted
1038 to window relative coordinates in WX and WY.
1040 If there is no window under X, Y return nil and leave *PART
1041 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1043 This function was previously implemented with a loop cycling over
1044 windows with Fnext_window, and starting with the frame's selected
1045 window. It turned out that this doesn't work with an
1046 implementation of next_window using Vwindow_list, because
1047 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1048 tree of F when this function is called asynchronously from
1049 note_mouse_highlight. The original loop didn't terminate in this
1053 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
1056 enum window_part
*part
;
1061 struct check_window_data cw
;
1062 enum window_part dummy
;
1068 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1069 foreach_window (f
, check_window_containing
, &cw
);
1071 /* If not found above, see if it's in the tool bar window, if a tool
1075 && WINDOWP (f
->tool_bar_window
)
1076 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1077 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1081 window
= f
->tool_bar_window
;
1090 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1091 doc
: /* Return window containing coordinates X and Y on FRAME.
1092 If omitted, FRAME defaults to the currently selected frame.
1093 The top left corner of the frame is considered to be row 0,
1096 Lisp_Object x
, y
, frame
;
1101 frame
= selected_frame
;
1102 CHECK_LIVE_FRAME (frame
);
1105 /* Check that arguments are integers or floats. */
1106 CHECK_NUMBER_OR_FLOAT (x
);
1107 CHECK_NUMBER_OR_FLOAT (y
);
1109 return window_from_coordinates (f
,
1110 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1111 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1112 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1113 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1117 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1118 doc
: /* Return current value of point in WINDOW.
1119 WINDOW defaults to the selected window.
1121 For a nonselected window, this is the value point would have
1122 if that window were selected.
1124 Note that, when WINDOW is the selected window and its buffer
1125 is also currently selected, the value returned is the same as (point).
1126 It would be more strictly correct to return the `top-level' value
1127 of point, outside of any save-excursion forms.
1128 But that is hard to define. */)
1132 register struct window
*w
= decode_window (window
);
1134 if (w
== XWINDOW (selected_window
)
1135 && current_buffer
== XBUFFER (w
->buffer
))
1137 return Fmarker_position (w
->pointm
);
1140 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1141 doc
: /* Return position at which display currently starts in WINDOW.
1142 WINDOW defaults to the selected window.
1143 This is updated by redisplay or by calling `set-window-start'. */)
1147 return Fmarker_position (decode_window (window
)->start
);
1150 /* This is text temporarily removed from the doc string below.
1152 This function returns nil if the position is not currently known.
1153 That happens when redisplay is preempted and doesn't finish.
1154 If in that case you want to compute where the end of the window would
1155 have been if redisplay had finished, do this:
1157 (goto-char (window-start window))
1158 (vertical-motion (1- (window-height window)) window)
1161 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1162 doc
: /* Return position at which display currently ends in WINDOW.
1163 WINDOW defaults to the selected window.
1164 This is updated by redisplay, when it runs to completion.
1165 Simply changing the buffer text or setting `window-start'
1166 does not update this value.
1167 Return nil if there is no recorded value. \(This can happen if the
1168 last redisplay of WINDOW was preempted, and did not finish.)
1169 If UPDATE is non-nil, compute the up-to-date position
1170 if it isn't already recorded. */)
1172 Lisp_Object window
, update
;
1175 struct window
*w
= decode_window (window
);
1183 #if 0 /* This change broke some things. We should make it later. */
1184 /* If we don't know the end position, return nil.
1185 The user can compute it with vertical-motion if he wants to.
1186 It would be nicer to do it automatically,
1187 but that's so slow that it would probably bother people. */
1188 if (NILP (w
->window_end_valid
))
1193 && ! (! NILP (w
->window_end_valid
)
1194 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1195 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1198 struct text_pos startp
;
1200 struct buffer
*old_buffer
= NULL
;
1202 /* Cannot use Fvertical_motion because that function doesn't
1203 cope with variable-height lines. */
1204 if (b
!= current_buffer
)
1206 old_buffer
= current_buffer
;
1207 set_buffer_internal (b
);
1210 /* In case W->start is out of the range, use something
1211 reasonable. This situation occurred when loading a file with
1212 `-l' containing a call to `rmail' with subsequent other
1213 commands. At the end, W->start happened to be BEG, while
1214 rmail had already narrowed the buffer. */
1215 if (XMARKER (w
->start
)->charpos
< BEGV
)
1216 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1217 else if (XMARKER (w
->start
)->charpos
> ZV
)
1218 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1220 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1222 start_display (&it
, w
, startp
);
1223 move_it_vertically (&it
, window_box_height (w
));
1224 if (it
.current_y
< it
.last_visible_y
)
1225 move_it_past_eol (&it
);
1226 value
= make_number (IT_CHARPOS (it
));
1229 set_buffer_internal (old_buffer
);
1232 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1237 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1238 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1241 Lisp_Object window
, pos
;
1243 register struct window
*w
= decode_window (window
);
1245 CHECK_NUMBER_COERCE_MARKER (pos
);
1246 if (w
== XWINDOW (selected_window
)
1247 && XBUFFER (w
->buffer
) == current_buffer
)
1250 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1252 /* We have to make sure that redisplay updates the window to show
1253 the new value of point. */
1254 if (!EQ (window
, selected_window
))
1255 ++windows_or_buffers_changed
;
1260 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1261 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1263 Optional third arg NOFORCE non-nil inhibits next redisplay
1264 from overriding motion of point in order to display at this exact start. */)
1265 (window
, pos
, noforce
)
1266 Lisp_Object window
, pos
, noforce
;
1268 register struct window
*w
= decode_window (window
);
1270 CHECK_NUMBER_COERCE_MARKER (pos
);
1271 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1272 /* this is not right, but much easier than doing what is right. */
1273 w
->start_at_line_beg
= Qnil
;
1275 w
->force_start
= Qt
;
1276 w
->update_mode_line
= Qt
;
1277 XSETFASTINT (w
->last_modified
, 0);
1278 XSETFASTINT (w
->last_overlay_modified
, 0);
1279 if (!EQ (window
, selected_window
))
1280 windows_or_buffers_changed
++;
1285 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1287 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1288 See also `set-window-dedicated-p'. */)
1292 return decode_window (window
)->dedicated
;
1295 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1296 Sset_window_dedicated_p
, 2, 2, 0,
1297 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1298 If it is dedicated, Emacs will not automatically change
1299 which buffer appears in it.
1300 The second argument is the new value for the dedication flag;
1301 non-nil means yes. */)
1303 Lisp_Object window
, arg
;
1305 register struct window
*w
= decode_window (window
);
1309 return w
->dedicated
;
1312 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1314 doc
: /* Return the display-table that WINDOW is using.
1315 WINDOW defaults to the selected window. */)
1319 return decode_window (window
)->display_table
;
1322 /* Get the display table for use on window W. This is either W's
1323 display table or W's buffer's display table. Ignore the specified
1324 tables if they are not valid; if no valid table is specified,
1327 struct Lisp_Char_Table
*
1328 window_display_table (w
)
1331 struct Lisp_Char_Table
*dp
= NULL
;
1333 if (DISP_TABLE_P (w
->display_table
))
1334 dp
= XCHAR_TABLE (w
->display_table
);
1335 else if (BUFFERP (w
->buffer
))
1337 struct buffer
*b
= XBUFFER (w
->buffer
);
1339 if (DISP_TABLE_P (b
->display_table
))
1340 dp
= XCHAR_TABLE (b
->display_table
);
1341 else if (DISP_TABLE_P (Vstandard_display_table
))
1342 dp
= XCHAR_TABLE (Vstandard_display_table
);
1348 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1349 doc
: /* Set WINDOW's display-table to TABLE. */)
1351 register Lisp_Object window
, table
;
1353 register struct window
*w
;
1355 w
= decode_window (window
);
1356 w
->display_table
= table
;
1360 /* Record info on buffer window w is displaying
1361 when it is about to cease to display that buffer. */
1364 register struct window
*w
;
1371 if (b
!= XMARKER (w
->pointm
)->buffer
)
1375 if (w
== XWINDOW (selected_window
)
1376 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1377 /* Do this except when the selected window's buffer
1378 is being removed from some other window. */
1380 /* last_window_start records the start position that this buffer
1381 had in the last window to be disconnected from it.
1382 Now that this statement is unconditional,
1383 it is possible for the buffer to be displayed in the
1384 selected window, while last_window_start reflects another
1385 window which was recently showing the same buffer.
1386 Some people might say that might be a good thing. Let's see. */
1387 b
->last_window_start
= marker_position (w
->start
);
1389 /* Point in the selected window's buffer
1390 is actually stored in that buffer, and the window's pointm isn't used.
1391 So don't clobber point in that buffer. */
1392 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1393 /* This line helps to fix Horsley's testbug.el bug. */
1394 && !(WINDOWP (b
->last_selected_window
)
1395 && w
!= XWINDOW (b
->last_selected_window
)
1396 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1397 temp_set_point_both (b
,
1398 clip_to_bounds (BUF_BEGV (b
),
1399 XMARKER (w
->pointm
)->charpos
,
1401 clip_to_bounds (BUF_BEGV_BYTE (b
),
1402 marker_byte_position (w
->pointm
),
1405 if (WINDOWP (b
->last_selected_window
)
1406 && w
== XWINDOW (b
->last_selected_window
))
1407 b
->last_selected_window
= Qnil
;
1410 /* Put replacement into the window structure in place of old. */
1412 replace_window (old
, replacement
)
1413 Lisp_Object old
, replacement
;
1415 register Lisp_Object tem
;
1416 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1418 /* If OLD is its frame's root_window, then replacement is the new
1419 root_window for that frame. */
1421 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1422 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1424 p
->left_col
= o
->left_col
;
1425 p
->top_line
= o
->top_line
;
1426 p
->total_cols
= o
->total_cols
;
1427 p
->total_lines
= o
->total_lines
;
1428 p
->desired_matrix
= p
->current_matrix
= 0;
1430 bzero (&p
->cursor
, sizeof (p
->cursor
));
1431 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1432 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1433 p
->phys_cursor_type
= -1;
1434 p
->phys_cursor_width
= -1;
1435 p
->must_be_updated_p
= 0;
1436 p
->pseudo_window_p
= 0;
1437 XSETFASTINT (p
->window_end_vpos
, 0);
1438 XSETFASTINT (p
->window_end_pos
, 0);
1439 p
->window_end_valid
= Qnil
;
1440 p
->frozen_window_start_p
= 0;
1441 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1443 p
->next
= tem
= o
->next
;
1445 XWINDOW (tem
)->prev
= replacement
;
1447 p
->prev
= tem
= o
->prev
;
1449 XWINDOW (tem
)->next
= replacement
;
1451 p
->parent
= tem
= o
->parent
;
1454 if (EQ (XWINDOW (tem
)->vchild
, old
))
1455 XWINDOW (tem
)->vchild
= replacement
;
1456 if (EQ (XWINDOW (tem
)->hchild
, old
))
1457 XWINDOW (tem
)->hchild
= replacement
;
1460 /*** Here, if replacement is a vertical combination
1461 and so is its new parent, we should make replacement's
1462 children be children of that parent instead. ***/
1465 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1466 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1468 register Lisp_Object window
;
1470 delete_window (window
);
1472 if (! NILP (Vwindow_configuration_change_hook
)
1473 && ! NILP (Vrun_hooks
))
1474 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1480 delete_window (window
)
1481 register Lisp_Object window
;
1483 register Lisp_Object tem
, parent
, sib
;
1484 register struct window
*p
;
1485 register struct window
*par
;
1488 /* Because this function is called by other C code on non-leaf
1489 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1490 so we can't decode_window here. */
1492 window
= selected_window
;
1494 CHECK_WINDOW (window
);
1495 p
= XWINDOW (window
);
1497 /* It's a no-op to delete an already-deleted window. */
1498 if (NILP (p
->buffer
)
1500 && NILP (p
->vchild
))
1505 error ("Attempt to delete minibuffer or sole ordinary window");
1506 par
= XWINDOW (parent
);
1508 windows_or_buffers_changed
++;
1509 Vwindow_list
= Qnil
;
1510 f
= XFRAME (WINDOW_FRAME (p
));
1511 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1513 /* Are we trying to delete any frame's selected window? */
1515 Lisp_Object swindow
, pwindow
;
1517 /* See if the frame's selected window is either WINDOW
1518 or any subwindow of it, by finding all that window's parents
1519 and comparing each one with WINDOW. */
1520 swindow
= FRAME_SELECTED_WINDOW (f
);
1525 while (!NILP (pwindow
))
1527 if (EQ (window
, pwindow
))
1529 pwindow
= XWINDOW (pwindow
)->parent
;
1532 /* If the window being deleted is not a parent of SWINDOW,
1533 then SWINDOW is ok as the new selected window. */
1534 if (!EQ (window
, pwindow
))
1536 /* Otherwise, try another window for SWINDOW. */
1537 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1539 /* If we get back to the frame's selected window,
1540 it means there was no acceptable alternative,
1541 so we cannot delete. */
1542 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1543 error ("Cannot delete window");
1546 /* If we need to change SWINDOW, do it. */
1547 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1549 /* If we're about to delete the selected window on the
1550 selected frame, then we should use Fselect_window to select
1551 the new window. On the other hand, if we're about to
1552 delete the selected window on any other frame, we shouldn't do
1553 anything but set the frame's selected_window slot. */
1554 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1555 Fselect_window (swindow
, Qnil
);
1557 FRAME_SELECTED_WINDOW (f
) = swindow
;
1561 /* Now we know we can delete this one. */
1562 window_deletion_count
++;
1565 /* tem is null for dummy parent windows
1566 (which have inferiors but not any contents themselves) */
1570 unchain_marker (XMARKER (p
->pointm
));
1571 unchain_marker (XMARKER (p
->start
));
1574 /* Free window glyph matrices. It is sure that they are allocated
1575 again when ADJUST_GLYPHS is called. Block input so that expose
1576 events and other events that access glyph matrices are not
1577 processed while we are changing them. */
1579 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1583 XWINDOW (tem
)->prev
= p
->prev
;
1587 XWINDOW (tem
)->next
= p
->next
;
1589 if (EQ (window
, par
->hchild
))
1590 par
->hchild
= p
->next
;
1591 if (EQ (window
, par
->vchild
))
1592 par
->vchild
= p
->next
;
1594 /* Find one of our siblings to give our space to. */
1598 /* If p gives its space to its next sibling, that sibling needs
1599 to have its top/left side pulled back to where p's is.
1600 set_window_{height,width} will re-position the sibling's
1603 XWINDOW (sib
)->top_line
= p
->top_line
;
1604 XWINDOW (sib
)->left_col
= p
->left_col
;
1607 /* Stretch that sibling. */
1608 if (!NILP (par
->vchild
))
1609 set_window_height (sib
,
1610 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1612 if (!NILP (par
->hchild
))
1613 set_window_width (sib
,
1614 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1617 /* If parent now has only one child,
1618 put the child into the parent's place. */
1622 if (NILP (XWINDOW (tem
)->next
)) {
1623 replace_window (parent
, tem
);
1624 par
= XWINDOW (tem
);
1627 /* Since we may be deleting combination windows, we must make sure that
1628 not only p but all its children have been marked as deleted. */
1629 if (! NILP (p
->hchild
))
1630 delete_all_subwindows (XWINDOW (p
->hchild
));
1631 else if (! NILP (p
->vchild
))
1632 delete_all_subwindows (XWINDOW (p
->vchild
));
1634 /* Mark this window as deleted. */
1635 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1637 if (! NILP (par
->parent
))
1638 par
= XWINDOW (par
->parent
);
1640 /* Check if we have a v/hchild with a v/hchild. In that case remove
1643 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1645 p
= XWINDOW (par
->vchild
);
1646 par
->vchild
= p
->vchild
;
1649 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1651 p
= XWINDOW (par
->hchild
);
1652 par
->hchild
= p
->hchild
;
1660 while (! NILP (tem
)) {
1661 XWINDOW (tem
)->parent
= p
->parent
;
1662 if (NILP (XWINDOW (tem
)->next
))
1664 tem
= XWINDOW (tem
)->next
;
1667 /* The next of the v/hchild we are removing is now the next of the
1668 last child for the v/hchild:
1669 Before v/hchild -> v/hchild -> next1 -> next2
1672 After: v/hchild -> next1 -> next2 -> next3
1674 XWINDOW (tem
)->next
= p
->next
;
1675 if (! NILP (p
->next
))
1676 XWINDOW (p
->next
)->prev
= tem
;
1678 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1682 /* Adjust glyph matrices. */
1689 /***********************************************************************
1691 ***********************************************************************/
1693 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1694 pointer. This is a callback function for foreach_window, used in
1695 function window_list. */
1698 add_window_to_list (w
, user_data
)
1702 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1704 XSETWINDOW (window
, w
);
1705 *list
= Fcons (window
, *list
);
1710 /* Return a list of all windows, for use by next_window. If
1711 Vwindow_list is a list, return that list. Otherwise, build a new
1712 list, cache it in Vwindow_list, and return that. */
1717 if (!CONSP (Vwindow_list
))
1721 Vwindow_list
= Qnil
;
1722 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1724 Lisp_Object args
[2];
1726 /* We are visiting windows in canonical order, and add
1727 new windows at the front of args[1], which means we
1728 have to reverse this list at the end. */
1730 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1731 args
[0] = Vwindow_list
;
1732 args
[1] = Fnreverse (args
[1]);
1733 Vwindow_list
= Fnconc (2, args
);
1737 return Vwindow_list
;
1741 /* Value is non-zero if WINDOW satisfies the constraints given by
1742 OWINDOW, MINIBUF and ALL_FRAMES.
1744 MINIBUF t means WINDOW may be minibuffer windows.
1745 `lambda' means WINDOW may not be a minibuffer window.
1746 a window means a specific minibuffer window
1748 ALL_FRAMES t means search all frames,
1749 nil means search just current frame,
1750 `visible' means search just visible frames,
1751 0 means search visible and iconified frames,
1752 a window means search the frame that window belongs to,
1753 a frame means consider windows on that frame, only. */
1756 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1757 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1759 struct window
*w
= XWINDOW (window
);
1760 struct frame
*f
= XFRAME (w
->frame
);
1761 int candidate_p
= 1;
1763 if (!BUFFERP (w
->buffer
))
1765 else if (MINI_WINDOW_P (w
)
1766 && (EQ (minibuf
, Qlambda
)
1767 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1769 /* If MINIBUF is `lambda' don't consider any mini-windows.
1770 If it is a window, consider only that one. */
1773 else if (EQ (all_frames
, Qt
))
1775 else if (NILP (all_frames
))
1777 xassert (WINDOWP (owindow
));
1778 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1780 else if (EQ (all_frames
, Qvisible
))
1782 FRAME_SAMPLE_VISIBILITY (f
);
1783 candidate_p
= FRAME_VISIBLE_P (f
);
1785 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1787 FRAME_SAMPLE_VISIBILITY (f
);
1788 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1790 else if (WINDOWP (all_frames
))
1791 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1792 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1793 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1794 else if (FRAMEP (all_frames
))
1795 candidate_p
= EQ (all_frames
, w
->frame
);
1801 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1802 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1806 decode_next_window_args (window
, minibuf
, all_frames
)
1807 Lisp_Object
*window
, *minibuf
, *all_frames
;
1810 *window
= selected_window
;
1812 CHECK_LIVE_WINDOW (*window
);
1814 /* MINIBUF nil may or may not include minibuffers. Decide if it
1816 if (NILP (*minibuf
))
1817 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1818 else if (!EQ (*minibuf
, Qt
))
1821 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1822 => count none of them, or a specific minibuffer window (the
1823 active one) to count. */
1825 /* ALL_FRAMES nil doesn't specify which frames to include. */
1826 if (NILP (*all_frames
))
1827 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1828 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1830 else if (EQ (*all_frames
, Qvisible
))
1832 else if (EQ (*all_frames
, make_number (0)))
1834 else if (FRAMEP (*all_frames
))
1836 else if (!EQ (*all_frames
, Qt
))
1839 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1840 search just current frame, `visible' meaning search just visible
1841 frames, 0 meaning search visible and iconified frames, or a
1842 window, meaning search the frame that window belongs to, or a
1843 frame, meaning consider windows on that frame, only. */
1847 /* Return the next or previous window of WINDOW in canonical ordering
1848 of windows. NEXT_P non-zero means return the next window. See the
1849 documentation string of next-window for the meaning of MINIBUF and
1853 next_window (window
, minibuf
, all_frames
, next_p
)
1854 Lisp_Object window
, minibuf
, all_frames
;
1857 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1859 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1860 return the first window on the frame. */
1861 if (FRAMEP (all_frames
)
1862 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1863 return Fframe_first_window (all_frames
);
1869 /* Find WINDOW in the list of all windows. */
1870 list
= Fmemq (window
, window_list ());
1872 /* Scan forward from WINDOW to the end of the window list. */
1874 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1875 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1878 /* Scan from the start of the window list up to WINDOW. */
1880 for (list
= Vwindow_list
;
1881 CONSP (list
) && !EQ (XCAR (list
), window
);
1883 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1887 window
= XCAR (list
);
1891 Lisp_Object candidate
, list
;
1893 /* Scan through the list of windows for candidates. If there are
1894 candidate windows in front of WINDOW, the last one of these
1895 is the one we want. If there are candidates following WINDOW
1896 in the list, again the last one of these is the one we want. */
1898 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1900 if (EQ (XCAR (list
), window
))
1902 if (WINDOWP (candidate
))
1905 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1907 candidate
= XCAR (list
);
1910 if (WINDOWP (candidate
))
1918 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1919 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1920 If omitted, WINDOW defaults to the selected window.
1922 Optional second arg MINIBUF t means count the minibuffer window even
1923 if not active. MINIBUF nil or omitted means count the minibuffer iff
1924 it is active. MINIBUF neither t nor nil means not to count the
1925 minibuffer even if it is active.
1927 Several frames may share a single minibuffer; if the minibuffer
1928 counts, all windows on all frames that share that minibuffer count
1929 too. Therefore, `next-window' can be used to iterate through the
1930 set of windows even when the minibuffer is on another frame. If the
1931 minibuffer does not count, only windows from WINDOW's frame count.
1933 Optional third arg ALL-FRAMES t means include windows on all frames.
1934 ALL-FRAMES nil or omitted means cycle within the frames as specified
1935 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1936 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1937 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1938 Anything else means restrict to WINDOW's frame.
1940 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1941 `next-window' to iterate through the entire cycle of acceptable
1942 windows, eventually ending up back at the window you started with.
1943 `previous-window' traverses the same cycle, in the reverse order. */)
1944 (window
, minibuf
, all_frames
)
1945 Lisp_Object window
, minibuf
, all_frames
;
1947 return next_window (window
, minibuf
, all_frames
, 1);
1951 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1952 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1953 If omitted, WINDOW defaults to the selected window.
1955 Optional second arg MINIBUF t means count the minibuffer window even
1956 if not active. MINIBUF nil or omitted means count the minibuffer iff
1957 it is active. MINIBUF neither t nor nil means not to count the
1958 minibuffer even if it is active.
1960 Several frames may share a single minibuffer; if the minibuffer
1961 counts, all windows on all frames that share that minibuffer count
1962 too. Therefore, `previous-window' can be used to iterate through
1963 the set of windows even when the minibuffer is on another frame. If
1964 the minibuffer does not count, only windows from WINDOW's frame count
1966 Optional third arg ALL-FRAMES t means include windows on all frames.
1967 ALL-FRAMES nil or omitted means cycle within the frames as specified
1968 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1969 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1970 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1971 Anything else means restrict to WINDOW's frame.
1973 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1974 `previous-window' to iterate through the entire cycle of acceptable
1975 windows, eventually ending up back at the window you started with.
1976 `next-window' traverses the same cycle, in the reverse order. */)
1977 (window
, minibuf
, all_frames
)
1978 Lisp_Object window
, minibuf
, all_frames
;
1980 return next_window (window
, minibuf
, all_frames
, 0);
1984 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1985 doc
: /* Select the ARG'th different window on this frame.
1986 All windows on current frame are arranged in a cyclic order.
1987 This command selects the window ARG steps away in that order.
1988 A negative ARG moves in the opposite order. The optional second
1989 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1991 Lisp_Object arg
, all_frames
;
1997 window
= selected_window
;
1999 for (i
= XINT (arg
); i
> 0; --i
)
2000 window
= Fnext_window (window
, Qnil
, all_frames
);
2002 window
= Fprevious_window (window
, Qnil
, all_frames
);
2004 Fselect_window (window
, Qnil
);
2009 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2010 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2011 FRAME nil or omitted means use the selected frame.
2012 WINDOW nil or omitted means use the selected window.
2013 MINIBUF t means include the minibuffer window, even if it isn't active.
2014 MINIBUF nil or omitted means include the minibuffer window only
2016 MINIBUF neither nil nor t means never include the minibuffer window. */)
2017 (frame
, minibuf
, window
)
2018 Lisp_Object frame
, minibuf
, window
;
2021 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2022 CHECK_WINDOW (window
);
2024 frame
= selected_frame
;
2026 if (!EQ (frame
, XWINDOW (window
)->frame
))
2027 error ("Window is on a different frame");
2029 return window_list_1 (window
, minibuf
, frame
);
2033 /* Return a list of windows in canonical ordering. Arguments are like
2034 for `next-window'. */
2037 window_list_1 (window
, minibuf
, all_frames
)
2038 Lisp_Object window
, minibuf
, all_frames
;
2040 Lisp_Object tail
, list
, rest
;
2042 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2045 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2046 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2047 list
= Fcons (XCAR (tail
), list
);
2049 /* Rotate the list to start with WINDOW. */
2050 list
= Fnreverse (list
);
2051 rest
= Fmemq (window
, list
);
2052 if (!NILP (rest
) && !EQ (rest
, list
))
2054 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2056 XSETCDR (tail
, Qnil
);
2057 list
= nconc2 (rest
, list
);
2064 /* Look at all windows, performing an operation specified by TYPE
2066 If FRAMES is Qt, look at all frames;
2067 Qnil, look at just the selected frame;
2068 Qvisible, look at visible frames;
2069 a frame, just look at windows on that frame.
2070 If MINI is non-zero, perform the operation on minibuffer windows too. */
2075 GET_BUFFER_WINDOW
, /* Arg is buffer */
2076 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2077 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2078 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2080 UNSHOW_BUFFER
, /* Arg is buffer */
2081 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2086 window_loop (type
, obj
, mini
, frames
)
2087 enum window_loop type
;
2088 Lisp_Object obj
, frames
;
2091 Lisp_Object window
, windows
, best_window
, frame_arg
;
2093 struct gcpro gcpro1
;
2095 /* If we're only looping through windows on a particular frame,
2096 frame points to that frame. If we're looping through windows
2097 on all frames, frame is 0. */
2098 if (FRAMEP (frames
))
2099 f
= XFRAME (frames
);
2100 else if (NILP (frames
))
2101 f
= SELECTED_FRAME ();
2106 frame_arg
= Qlambda
;
2107 else if (EQ (frames
, make_number (0)))
2109 else if (EQ (frames
, Qvisible
))
2114 /* frame_arg is Qlambda to stick to one frame,
2115 Qvisible to consider all visible frames,
2118 /* Pick a window to start with. */
2122 window
= FRAME_SELECTED_WINDOW (f
);
2124 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2126 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2130 for (; CONSP (windows
); windows
= XCDR (windows
))
2134 window
= XCAR (windows
);
2135 w
= XWINDOW (window
);
2137 /* Note that we do not pay attention here to whether the frame
2138 is visible, since Fwindow_list skips non-visible frames if
2139 that is desired, under the control of frame_arg. */
2140 if (!MINI_WINDOW_P (w
)
2141 /* For UNSHOW_BUFFER, we must always consider all windows. */
2142 || type
== UNSHOW_BUFFER
2143 || (mini
&& minibuf_level
> 0))
2146 case GET_BUFFER_WINDOW
:
2147 if (EQ (w
->buffer
, obj
)
2148 /* Don't find any minibuffer window
2149 except the one that is currently in use. */
2150 && (MINI_WINDOW_P (w
)
2151 ? EQ (window
, minibuf_window
)
2154 if (NILP (best_window
))
2155 best_window
= window
;
2156 else if (EQ (window
, selected_window
))
2157 /* For compatibility with 20.x, prefer to return
2159 best_window
= window
;
2163 case GET_LRU_WINDOW
:
2164 /* `obj' is an integer encoding a bitvector.
2165 `obj & 1' means consider only full-width windows.
2166 `obj & 2' means consider also dedicated windows. */
2167 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2168 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2169 /* Minibuffer windows are always ignored. */
2170 || MINI_WINDOW_P (w
))
2172 if (NILP (best_window
)
2173 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2174 > XFASTINT (w
->use_time
)))
2175 best_window
= window
;
2178 case DELETE_OTHER_WINDOWS
:
2179 if (!EQ (window
, obj
))
2180 Fdelete_window (window
);
2183 case DELETE_BUFFER_WINDOWS
:
2184 if (EQ (w
->buffer
, obj
))
2186 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2188 /* If this window is dedicated, and in a frame of its own,
2190 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2191 && !NILP (w
->dedicated
)
2192 && other_visible_frames (f
))
2194 /* Skip the other windows on this frame.
2195 There might be one, the minibuffer! */
2196 while (CONSP (XCDR (windows
))
2197 && EQ (XWINDOW (XCAR (windows
))->frame
,
2198 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2199 windows
= XCDR (windows
);
2201 /* Now we can safely delete the frame. */
2202 Fdelete_frame (w
->frame
, Qnil
);
2204 else if (NILP (w
->parent
))
2206 /* If we're deleting the buffer displayed in the
2207 only window on the frame, find a new buffer to
2210 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2211 Fset_window_buffer (window
, buffer
, Qnil
);
2212 if (EQ (window
, selected_window
))
2213 Fset_buffer (w
->buffer
);
2216 Fdelete_window (window
);
2220 case GET_LARGEST_WINDOW
:
2221 { /* nil `obj' means to ignore dedicated windows. */
2222 /* Ignore dedicated windows and minibuffers. */
2223 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2226 if (NILP (best_window
))
2227 best_window
= window
;
2230 struct window
*b
= XWINDOW (best_window
);
2231 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2232 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2233 best_window
= window
;
2239 if (EQ (w
->buffer
, obj
))
2242 struct frame
*f
= XFRAME (w
->frame
);
2244 /* Find another buffer to show in this window. */
2245 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2247 /* If this window is dedicated, and in a frame of its own,
2249 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2250 && !NILP (w
->dedicated
)
2251 && other_visible_frames (f
))
2253 /* Skip the other windows on this frame.
2254 There might be one, the minibuffer! */
2255 while (CONSP (XCDR (windows
))
2256 && EQ (XWINDOW (XCAR (windows
))->frame
,
2257 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2258 windows
= XCDR (windows
);
2260 /* Now we can safely delete the frame. */
2261 Fdelete_frame (w
->frame
, Qnil
);
2263 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2266 XSETWINDOW (window
, w
);
2267 /* If this window is dedicated and not the only window
2268 in its frame, then kill it. */
2269 Fdelete_window (window
);
2273 /* Otherwise show a different buffer in the window. */
2274 w
->dedicated
= Qnil
;
2275 Fset_window_buffer (window
, buffer
, Qnil
);
2276 if (EQ (window
, selected_window
))
2277 Fset_buffer (w
->buffer
);
2282 case REDISPLAY_BUFFER_WINDOWS
:
2283 if (EQ (w
->buffer
, obj
))
2285 mark_window_display_accurate (window
, 0);
2286 w
->update_mode_line
= Qt
;
2287 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2288 ++update_mode_lines
;
2289 best_window
= window
;
2293 /* Check for a window that has a killed buffer. */
2294 case CHECK_ALL_WINDOWS
:
2295 if (! NILP (w
->buffer
)
2296 && NILP (XBUFFER (w
->buffer
)->name
))
2300 case WINDOW_LOOP_UNUSED
:
2309 /* Used for debugging. Abort if any window has a dead buffer. */
2312 check_all_windows ()
2314 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2317 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2318 doc
: /* Return the window least recently selected or used for display.
2319 \(LRU means Least Recently Used.)
2321 Return a full-width window if possible.
2322 A minibuffer window is never a candidate.
2323 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2324 so if all windows are dedicated, the value is nil.
2325 If optional argument FRAME is `visible', search all visible frames.
2326 If FRAME is 0, search all visible and iconified frames.
2327 If FRAME is t, search all frames.
2328 If FRAME is nil, search only the selected frame.
2329 If FRAME is a frame, search only that frame. */)
2331 Lisp_Object frame
, dedicated
;
2333 register Lisp_Object w
;
2334 /* First try for a window that is full-width */
2335 w
= window_loop (GET_LRU_WINDOW
,
2336 NILP (dedicated
) ? make_number (1) : make_number (3),
2338 if (!NILP (w
) && !EQ (w
, selected_window
))
2340 /* If none of them, try the rest */
2341 return window_loop (GET_LRU_WINDOW
,
2342 NILP (dedicated
) ? make_number (0) : make_number (2),
2346 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2347 doc
: /* Return the largest window in area.
2348 A minibuffer window is never a candidate.
2349 A dedicated window is never a candidate unless DEDICATED is non-nil,
2350 so if all windows are dedicated, the value is nil.
2351 If optional argument FRAME is `visible', search all visible frames.
2352 If FRAME is 0, search all visible and iconified frames.
2353 If FRAME is t, search all frames.
2354 If FRAME is nil, search only the selected frame.
2355 If FRAME is a frame, search only that frame. */)
2357 Lisp_Object frame
, dedicated
;
2359 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2363 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2364 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2365 BUFFER can be a buffer or a buffer name.
2366 If optional argument FRAME is `visible', search all visible frames.
2367 If optional argument FRAME is 0, search all visible and iconified frames.
2368 If FRAME is t, search all frames.
2369 If FRAME is nil, search only the selected frame.
2370 If FRAME is a frame, search only that frame. */)
2372 Lisp_Object buffer
, frame
;
2374 buffer
= Fget_buffer (buffer
);
2375 if (BUFFERP (buffer
))
2376 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2381 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2383 doc
: /* Make WINDOW (or the selected window) fill its frame.
2384 Only the frame WINDOW is on is affected.
2385 This function tries to reduce display jumps
2386 by keeping the text previously visible in WINDOW
2387 in the same place on the frame. Doing this depends on
2388 the value of (window-start WINDOW), so if calling this function
2389 in a program gives strange scrolling, make sure the window-start
2390 value is reasonable when this function is called. */)
2399 window
= selected_window
;
2401 CHECK_LIVE_WINDOW (window
);
2402 w
= XWINDOW (window
);
2404 startpos
= marker_position (w
->start
);
2405 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2407 if (MINI_WINDOW_P (w
) && top
> 0)
2408 error ("Can't expand minibuffer to full frame");
2410 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2412 /* Try to minimize scrolling, by setting the window start to the point
2413 will cause the text at the old window start to be at the same place
2414 on the frame. But don't try to do this if the window start is
2415 outside the visible portion (as might happen when the display is
2416 not current, due to typeahead). */
2417 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2419 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2420 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2422 struct position pos
;
2423 struct buffer
*obuf
= current_buffer
;
2425 Fset_buffer (w
->buffer
);
2426 /* This computation used to temporarily move point, but that can
2427 have unwanted side effects due to text properties. */
2428 pos
= *vmotion (startpos
, -top
, w
);
2430 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2431 w
->window_end_valid
= Qnil
;
2432 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2433 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2435 /* We need to do this, so that the window-scroll-functions
2437 w
->optional_new_start
= Qt
;
2439 set_buffer_internal (obuf
);
2445 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2446 1, 2, "bDelete windows on (buffer): ",
2447 doc
: /* Delete all windows showing BUFFER.
2448 BUFFER must be a buffer or the name of an existing buffer.
2449 Optional second argument FRAME controls which frames are affected.
2450 If optional argument FRAME is `visible', search all visible frames.
2451 If FRAME is 0, search all visible and iconified frames.
2452 If FRAME is nil, search all frames.
2453 If FRAME is t, search only the selected frame.
2454 If FRAME is a frame, search only that frame. */)
2456 Lisp_Object buffer
, frame
;
2458 /* FRAME uses t and nil to mean the opposite of what window_loop
2462 else if (EQ (frame
, Qt
))
2467 buffer
= Fget_buffer (buffer
);
2468 CHECK_BUFFER (buffer
);
2469 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2475 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2476 Sreplace_buffer_in_windows
,
2477 1, 1, "bReplace buffer in windows: ",
2478 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2479 BUFFER may be a buffer or the name of an existing buffer. */)
2485 buffer
= Fget_buffer (buffer
);
2486 CHECK_BUFFER (buffer
);
2487 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2492 /* Replace BUFFER with some other buffer in all windows
2493 of all frames, even those on other keyboards. */
2496 replace_buffer_in_all_windows (buffer
)
2500 Lisp_Object tail
, frame
;
2502 /* A single call to window_loop won't do the job
2503 because it only considers frames on the current keyboard.
2504 So loop manually over frames, and handle each one. */
2505 FOR_EACH_FRAME (tail
, frame
)
2506 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2508 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2512 /* Set the height of WINDOW and all its inferiors. */
2514 /* The smallest acceptable dimensions for a window. Anything smaller
2515 might crash Emacs. */
2517 #define MIN_SAFE_WINDOW_WIDTH (2)
2518 #define MIN_SAFE_WINDOW_HEIGHT (1)
2520 /* Make sure that window_min_height and window_min_width are
2521 not too small; if they are, set them to safe minima. */
2524 check_min_window_sizes ()
2526 /* Smaller values might permit a crash. */
2527 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2528 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2529 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2530 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2533 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2534 minimum allowable size. */
2537 check_frame_size (frame
, rows
, cols
)
2541 /* For height, we have to see:
2542 how many windows the frame has at minimum (one or two),
2543 and whether it has a menu bar or other special stuff at the top. */
2545 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2546 ? MIN_SAFE_WINDOW_HEIGHT
2547 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2549 if (FRAME_TOP_MARGIN (frame
) > 0)
2550 min_height
+= FRAME_TOP_MARGIN (frame
);
2552 if (*rows
< min_height
)
2554 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2555 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2559 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2560 check if W's width can be changed, otherwise check W's height.
2561 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2562 siblings, too. If none of the siblings is resizable, WINDOW isn't
2566 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2568 int width_p
, check_siblings_p
;
2573 if (!NILP (w
->hchild
))
2575 c
= XWINDOW (w
->hchild
);
2579 /* A horiz. combination is fixed-width if all of if its
2581 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2582 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2583 fixed_p
= c
== NULL
;
2587 /* A horiz. combination is fixed-height if one of if its
2589 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2590 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2591 fixed_p
= c
!= NULL
;
2594 else if (!NILP (w
->vchild
))
2596 c
= XWINDOW (w
->vchild
);
2600 /* A vert. combination is fixed-width if one of if its
2602 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2603 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2604 fixed_p
= c
!= NULL
;
2608 /* A vert. combination is fixed-height if all of if its
2610 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2611 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2612 fixed_p
= c
== NULL
;
2615 else if (BUFFERP (w
->buffer
))
2617 struct buffer
*old
= current_buffer
;
2620 current_buffer
= XBUFFER (w
->buffer
);
2621 val
= find_symbol_value (Qwindow_size_fixed
);
2622 current_buffer
= old
;
2625 if (!EQ (val
, Qunbound
))
2627 fixed_p
= !NILP (val
);
2630 && ((EQ (val
, Qheight
) && width_p
)
2631 || (EQ (val
, Qwidth
) && !width_p
)))
2635 /* Can't tell if this one is resizable without looking at
2636 siblings. If all siblings are fixed-size this one is too. */
2637 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2641 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2642 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2646 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2647 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2661 /* Return the minimum size of window W, not taking fixed-width windows
2662 into account. WIDTH_P non-zero means return the minimum width,
2663 otherwise return the minimum height. If W is a combination window,
2664 compute the minimum size from the minimum sizes of W's children. */
2667 window_min_size_1 (w
, width_p
)
2674 if (!NILP (w
->hchild
))
2676 c
= XWINDOW (w
->hchild
);
2681 /* The min width of a horizontal combination is
2682 the sum of the min widths of its children. */
2685 size
+= window_min_size_1 (c
, width_p
);
2686 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2691 /* The min height a horizontal combination equals
2692 the maximum of all min height of its children. */
2695 int min_size
= window_min_size_1 (c
, width_p
);
2696 size
= max (min_size
, size
);
2697 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2701 else if (!NILP (w
->vchild
))
2703 c
= XWINDOW (w
->vchild
);
2708 /* The min width of a vertical combination is
2709 the maximum of the min widths of its children. */
2712 int min_size
= window_min_size_1 (c
, width_p
);
2713 size
= max (min_size
, size
);
2714 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2719 /* The min height of a vertical combination equals
2720 the sum of the min height of its children. */
2723 size
+= window_min_size_1 (c
, width_p
);
2724 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2731 size
= max (window_min_width
,
2732 (MIN_SAFE_WINDOW_WIDTH
2733 + WINDOW_FRINGE_COLS (w
)
2734 + WINDOW_SCROLL_BAR_COLS (w
)));
2737 if (MINI_WINDOW_P (w
)
2738 || (!WINDOW_WANTS_MODELINE_P (w
)
2739 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2742 size
= window_min_height
;
2750 /* Return the minimum size of window W, taking fixed-size windows into
2751 account. WIDTH_P non-zero means return the minimum width,
2752 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2753 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2754 unless FIXED is null. */
2757 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2759 int width_p
, ignore_fixed_p
, *fixed
;
2766 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2772 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2774 size
= window_min_size_1 (w
, width_p
);
2780 /* Adjust the margins of window W if text area is too small.
2781 Return 1 if window width is ok after adjustment; 0 if window
2782 is still too narrow. */
2785 adjust_window_margins (w
)
2788 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2789 - WINDOW_FRINGE_COLS (w
)
2790 - WINDOW_SCROLL_BAR_COLS (w
));
2791 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2792 + WINDOW_RIGHT_MARGIN_COLS (w
));
2794 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2797 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2800 /* Window's text area is too narrow, but reducing the window
2801 margins will fix that. */
2802 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2803 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2805 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2806 w
->left_margin_cols
= w
->right_margin_cols
2807 = make_number (margin_cols
/2);
2809 w
->right_margin_cols
= make_number (margin_cols
);
2812 w
->left_margin_cols
= make_number (margin_cols
);
2816 /* Calculate new sizes for windows in the list FORWARD when the window size
2817 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2818 The number of windows in FORWARD is NCHILDREN, and the number that
2819 can shrink is SHRINKABLE.
2820 The minimum size a window can have is MIN_SIZE.
2821 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2822 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2825 This function returns an allocated array of new sizes that the caller
2826 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2827 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2828 the second, and so on.
2830 This function tries to keep windows at least at the minimum size
2831 and resize other windows before it resizes any window to zero (i.e.
2832 delete that window).
2834 Windows are resized proportional to their size, so bigger windows
2835 shrink more than smaller windows. */
2837 shrink_windows (total
, size
, nchildren
, shrinkable
,
2838 min_size
, resize_fixed_p
, forward
, width_p
)
2839 int total
, size
, nchildren
, shrinkable
, min_size
;
2840 int resize_fixed_p
, width_p
;
2841 Lisp_Object forward
;
2843 int available_resize
= 0;
2847 int smallest
= total
;
2848 int total_removed
= 0;
2849 int total_shrink
= total
- size
;
2852 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2854 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2858 c
= XWINDOW (child
);
2859 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2861 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2865 new_sizes
[i
] = child_size
;
2866 if (child_size
> min_size
)
2867 available_resize
+= child_size
- min_size
;
2870 /* We might need to shrink some windows to zero. Find the smallest
2871 windows and set them to 0 until we can fulfil the new size. */
2873 while (shrinkable
> 1 && size
+ available_resize
< total
)
2875 for (i
= 0; i
< nchildren
; ++i
)
2876 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2877 smallest
= new_sizes
[i
];
2879 for (i
= 0; i
< nchildren
; ++i
)
2880 if (new_sizes
[i
] == smallest
)
2882 /* Resize this window down to zero. */
2884 if (smallest
> min_size
)
2885 available_resize
-= smallest
- min_size
;
2886 available_resize
+= smallest
;
2888 total_removed
+= smallest
;
2890 /* We don't know what the smallest is now. */
2893 /* Out of for, just remove one window at the time and
2894 check again if we have enough space. */
2899 /* Now, calculate the new sizes. Try to shrink each window
2900 proportional to its size. */
2901 for (i
= 0; i
< nchildren
; ++i
)
2903 if (new_sizes
[i
] > min_size
)
2905 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2906 if (new_sizes
[i
] - to_shrink
< min_size
)
2907 to_shrink
= new_sizes
[i
] - min_size
;
2908 new_sizes
[i
] -= to_shrink
;
2909 total_removed
+= to_shrink
;
2913 /* Any reminder due to rounding, we just subtract from windows
2914 that are left and still can be shrunk. */
2915 while (total_shrink
> total_removed
)
2917 int nonzero_sizes
= 0;
2918 int nonzero_idx
= -1;
2920 for (i
= 0; i
< nchildren
; ++i
)
2921 if (new_sizes
[i
] > 0)
2927 for (i
= 0; i
< nchildren
; ++i
)
2928 if (new_sizes
[i
] > min_size
)
2933 /* Out of for, just shrink one window at the time and
2934 check again if we have enough space. */
2939 /* Special case, only one window left. */
2940 if (nonzero_sizes
== 1)
2944 /* Any surplus due to rounding, we add to windows that are left. */
2945 while (total_shrink
< total_removed
)
2947 for (i
= 0; i
< nchildren
; ++i
)
2949 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2961 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2962 WINDOW's width. Resize WINDOW's children, if any, so that they
2963 keep their proportionate size relative to WINDOW.
2965 If FIRST_ONLY is 1, change only the first of WINDOW's children when
2966 they are in series. If LAST_ONLY is 1, change only the last of
2967 WINDOW's children when they are in series.
2969 Propagate WINDOW's top or left edge position to children. Delete
2970 windows that become too small unless NODELETE_P is non-zero.
2972 If NODELETE_P is 2, that means we do delete windows that are
2973 too small, even if they were too small before! */
2976 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
2978 int size
, width_p
, nodelete_p
;
2979 int first_only
, last_only
;
2981 struct window
*w
= XWINDOW (window
);
2983 Lisp_Object child
, *forward
, *sideward
;
2984 int old_size
, min_size
, safe_min_size
;
2986 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2987 seems like it's too soon to do this here. ++KFS. */
2988 if (nodelete_p
== 2)
2991 check_min_window_sizes ();
2992 size
= max (0, size
);
2994 /* If the window has been "too small" at one point,
2995 don't delete it for being "too small" in the future.
2996 Preserve it as long as that is at all possible. */
2999 old_size
= WINDOW_TOTAL_COLS (w
);
3000 min_size
= window_min_width
;
3001 /* Ensure that there is room for the scroll bar and fringes!
3002 We may reduce display margins though. */
3003 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
3004 + WINDOW_FRINGE_COLS (w
)
3005 + WINDOW_SCROLL_BAR_COLS (w
));
3009 old_size
= XINT (w
->total_lines
);
3010 min_size
= window_min_height
;
3011 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
3014 if (old_size
< min_size
&& nodelete_p
!= 2)
3015 w
->too_small_ok
= Qt
;
3017 /* Maybe delete WINDOW if it's too small. */
3018 if (nodelete_p
!= 1 && !NILP (w
->parent
))
3020 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
3021 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
3022 if (min_size
< safe_min_size
)
3023 min_size
= safe_min_size
;
3024 if (size
< min_size
)
3026 delete_window (window
);
3031 /* Set redisplay hints. */
3032 w
->last_modified
= make_number (0);
3033 w
->last_overlay_modified
= make_number (0);
3034 windows_or_buffers_changed
++;
3035 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3039 sideward
= &w
->vchild
;
3040 forward
= &w
->hchild
;
3041 w
->total_cols
= make_number (size
);
3042 adjust_window_margins (w
);
3046 sideward
= &w
->hchild
;
3047 forward
= &w
->vchild
;
3048 w
->total_lines
= make_number (size
);
3049 w
->orig_total_lines
= Qnil
;
3052 if (!NILP (*sideward
))
3054 /* We have a chain of parallel siblings whose size should all change. */
3055 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3057 c
= XWINDOW (child
);
3059 c
->left_col
= w
->left_col
;
3061 c
->top_line
= w
->top_line
;
3062 size_window (child
, size
, width_p
, nodelete_p
,
3063 first_only
, last_only
);
3066 else if (!NILP (*forward
) && last_only
)
3068 /* Change the last in a series of siblings. */
3069 Lisp_Object last_child
;
3072 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3074 c
= XWINDOW (child
);
3078 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3079 size_window (last_child
,
3080 size
- old_size
+ child_size
,
3081 width_p
, nodelete_p
, first_only
, last_only
);
3083 else if (!NILP (*forward
) && first_only
)
3085 /* Change the first in a series of siblings. */
3089 c
= XWINDOW (child
);
3092 c
->left_col
= w
->left_col
;
3094 c
->top_line
= w
->top_line
;
3096 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3098 size
- old_size
+ child_size
,
3099 width_p
, nodelete_p
, first_only
, last_only
);
3101 else if (!NILP (*forward
))
3103 int fixed_size
, each
, extra
, n
;
3104 int resize_fixed_p
, nfixed
;
3105 int last_pos
, first_pos
, nchildren
, total
;
3106 int *new_sizes
= NULL
;
3108 /* Determine the fixed-size portion of this window, and the
3109 number of child windows. */
3110 fixed_size
= nchildren
= nfixed
= total
= 0;
3111 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3115 c
= XWINDOW (child
);
3116 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3117 total
+= child_size
;
3119 if (window_fixed_size_p (c
, width_p
, 0))
3121 fixed_size
+= child_size
;
3126 /* If the new size is smaller than fixed_size, or if there
3127 aren't any resizable windows, allow resizing fixed-size
3129 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3131 /* Compute how many lines/columns to add/remove to each child. The
3132 value of extra takes care of rounding errors. */
3133 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3134 if (size
< total
&& n
> 1)
3135 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
3136 resize_fixed_p
, *forward
, width_p
);
3139 each
= (size
- total
) / n
;
3140 extra
= (size
- total
) - n
* each
;
3143 /* Compute new children heights and edge positions. */
3144 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3145 last_pos
= first_pos
;
3146 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3148 int new_size
, old_size
;
3150 c
= XWINDOW (child
);
3151 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
3152 new_size
= old_size
;
3154 /* The top or left edge position of this child equals the
3155 bottom or right edge of its predecessor. */
3157 c
->left_col
= make_number (last_pos
);
3159 c
->top_line
= make_number (last_pos
);
3161 /* If this child can be resized, do it. */
3162 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3164 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3168 /* Set new height. Note that size_window also propagates
3169 edge positions to children, so it's not a no-op if we
3170 didn't change the child's size. */
3171 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3173 /* Remember the bottom/right edge position of this child; it
3174 will be used to set the top/left edge of the next child. */
3175 last_pos
+= new_size
;
3178 if (new_sizes
) xfree (new_sizes
);
3180 /* We should have covered the parent exactly with child windows. */
3181 xassert (size
== last_pos
- first_pos
);
3183 /* Now delete any children that became too small. */
3185 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3188 c
= XWINDOW (child
);
3189 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3190 size_window (child
, child_size
, width_p
, 2, first_only
, last_only
);
3195 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3196 WINDOW's children. NODELETE non-zero means don't delete windows
3197 that become too small in the process. (The caller should check
3198 later and do so if appropriate.) */
3201 set_window_height (window
, height
, nodelete
)
3206 size_window (window
, height
, 0, nodelete
, 0, 0);
3210 /* Set WINDOW's width to WIDTH, and recursively change the width of
3211 WINDOW's children. NODELETE non-zero means don't delete windows
3212 that become too small in the process. (The caller should check
3213 later and do so if appropriate.) */
3216 set_window_width (window
, width
, nodelete
)
3221 size_window (window
, width
, 1, nodelete
, 0, 0);
3224 /* Change window heights in windows rooted in WINDOW by N lines. */
3227 change_window_heights (window
, n
)
3231 struct window
*w
= XWINDOW (window
);
3233 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3234 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3236 if (INTEGERP (w
->orig_top_line
))
3237 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3238 if (INTEGERP (w
->orig_total_lines
))
3239 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3241 /* Handle just the top child in a vertical split. */
3242 if (!NILP (w
->vchild
))
3243 change_window_heights (w
->vchild
, n
);
3245 /* Adjust all children in a horizontal split. */
3246 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3248 w
= XWINDOW (window
);
3249 change_window_heights (window
, n
);
3254 int window_select_count
;
3257 Fset_window_buffer_unwind (obuf
)
3264 EXFUN (Fset_window_fringes
, 4);
3265 EXFUN (Fset_window_scroll_bars
, 4);
3267 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3268 means it's allowed to run hooks. See make_frame for a case where
3269 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3270 margins, fringes, and scroll-bar settings of the window are not
3271 reset from the buffer's local settings. */
3274 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3275 Lisp_Object window
, buffer
;
3276 int run_hooks_p
, keep_margins_p
;
3278 struct window
*w
= XWINDOW (window
);
3279 struct buffer
*b
= XBUFFER (buffer
);
3280 int count
= SPECPDL_INDEX ();
3284 if (EQ (window
, selected_window
))
3285 b
->last_selected_window
= window
;
3287 /* Let redisplay errors through. */
3288 b
->display_error_modiff
= 0;
3290 /* Update time stamps of buffer display. */
3291 if (INTEGERP (b
->display_count
))
3292 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3293 b
->display_time
= Fcurrent_time ();
3295 XSETFASTINT (w
->window_end_pos
, 0);
3296 XSETFASTINT (w
->window_end_vpos
, 0);
3297 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3298 w
->window_end_valid
= Qnil
;
3299 w
->hscroll
= w
->min_hscroll
= make_number (0);
3301 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3302 set_marker_restricted (w
->start
,
3303 make_number (b
->last_window_start
),
3305 w
->start_at_line_beg
= Qnil
;
3306 w
->force_start
= Qnil
;
3307 XSETFASTINT (w
->last_modified
, 0);
3308 XSETFASTINT (w
->last_overlay_modified
, 0);
3309 windows_or_buffers_changed
++;
3311 /* We must select BUFFER for running the window-scroll-functions.
3312 If WINDOW is selected, switch permanently.
3313 Otherwise, switch but go back to the ambient buffer afterward. */
3314 if (EQ (window
, selected_window
))
3315 Fset_buffer (buffer
);
3316 /* We can't check ! NILP (Vwindow_scroll_functions) here
3317 because that might itself be a local variable. */
3318 else if (window_initialized
)
3320 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3321 Fset_buffer (buffer
);
3324 if (!keep_margins_p
)
3326 /* Set left and right marginal area width etc. from buffer. */
3328 /* This may call adjust_window_margins three times, so
3329 temporarily disable window margins. */
3330 Lisp_Object save_left
= w
->left_margin_cols
;
3331 Lisp_Object save_right
= w
->right_margin_cols
;
3333 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3335 Fset_window_fringes (window
,
3336 b
->left_fringe_width
, b
->right_fringe_width
,
3337 b
->fringes_outside_margins
);
3339 Fset_window_scroll_bars (window
,
3340 b
->scroll_bar_width
,
3341 b
->vertical_scroll_bar_type
, Qnil
);
3343 w
->left_margin_cols
= save_left
;
3344 w
->right_margin_cols
= save_right
;
3346 Fset_window_margins (window
,
3347 b
->left_margin_cols
, b
->right_margin_cols
);
3352 if (! NILP (Vwindow_scroll_functions
))
3353 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3354 Fmarker_position (w
->start
));
3356 if (! NILP (Vwindow_configuration_change_hook
)
3357 && ! NILP (Vrun_hooks
))
3358 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3361 unbind_to (count
, Qnil
);
3365 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3366 doc
: /* Make WINDOW display BUFFER as its contents.
3367 BUFFER can be a buffer or the name of an existing buffer.
3368 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3369 display margins, fringe widths, and scroll bar settings are maintained;
3370 the default is to reset these from BUFFER's local settings or the frame
3373 This function runs the hook `window-scroll-functions'. */)
3374 (window
, buffer
, keep_margins
)
3375 register Lisp_Object window
, buffer
, keep_margins
;
3377 register Lisp_Object tem
;
3378 register struct window
*w
= decode_window (window
);
3380 XSETWINDOW (window
, w
);
3381 buffer
= Fget_buffer (buffer
);
3382 CHECK_BUFFER (buffer
);
3384 if (NILP (XBUFFER (buffer
)->name
))
3385 error ("Attempt to display deleted buffer");
3389 error ("Window is deleted");
3390 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3391 is first being set up. */
3393 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3394 error ("Window is dedicated to `%s'",
3395 SDATA (XBUFFER (tem
)->name
));
3400 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3404 /* Note that selected_window can be nil
3405 when this is called from Fset_window_configuration. */
3407 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3408 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3409 If WINDOW is not already selected, make WINDOW's buffer current
3410 and make WINDOW the frame's selected window. Return WINDOW.
3411 Optional second arg NORECORD non-nil means
3412 do not put this buffer at the front of the list of recently selected ones.
3414 Note that the main editor command loop
3415 selects the buffer of the selected window before each command. */)
3417 register Lisp_Object window
, norecord
;
3419 register struct window
*w
;
3420 register struct window
*ow
;
3423 CHECK_LIVE_WINDOW (window
);
3425 w
= XWINDOW (window
);
3426 w
->frozen_window_start_p
= 0;
3428 ++window_select_count
;
3429 XSETFASTINT (w
->use_time
, window_select_count
);
3430 if (EQ (window
, selected_window
))
3433 /* Store the current buffer's actual point into the
3434 old selected window. It belongs to that window,
3435 and when the window is not selected, must be in the window. */
3436 if (!NILP (selected_window
))
3438 ow
= XWINDOW (selected_window
);
3439 if (! NILP (ow
->buffer
))
3440 set_marker_both (ow
->pointm
, ow
->buffer
,
3441 BUF_PT (XBUFFER (ow
->buffer
)),
3442 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3445 selected_window
= window
;
3446 sf
= SELECTED_FRAME ();
3447 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3449 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3450 /* Use this rather than Fhandle_switch_frame
3451 so that FRAME_FOCUS_FRAME is moved appropriately as we
3452 move around in the state where a minibuffer in a separate
3454 Fselect_frame (WINDOW_FRAME (w
));
3457 sf
->selected_window
= window
;
3459 if (NILP (norecord
))
3460 record_buffer (w
->buffer
);
3461 Fset_buffer (w
->buffer
);
3463 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3465 /* Go to the point recorded in the window.
3466 This is important when the buffer is in more
3467 than one window. It also matters when
3468 redisplay_window has altered point after scrolling,
3469 because it makes the change only in the window. */
3471 register int new_point
= marker_position (w
->pointm
);
3472 if (new_point
< BEGV
)
3474 else if (new_point
> ZV
)
3480 windows_or_buffers_changed
++;
3485 select_window_norecord (window
)
3488 return Fselect_window (window
, Qt
);
3491 /* Deiconify the frame containing the window WINDOW,
3492 unless it is the selected frame;
3495 The reason for the exception for the selected frame
3496 is that it seems better not to change the selected frames visibility
3497 merely because of displaying a different buffer in it.
3498 The deiconification is useful when a buffer gets shown in
3499 another frame that you were not using lately. */
3502 display_buffer_1 (window
)
3505 Lisp_Object frame
= XWINDOW (window
)->frame
;
3506 FRAME_PTR f
= XFRAME (frame
);
3508 FRAME_SAMPLE_VISIBILITY (f
);
3510 if (EQ (frame
, selected_frame
))
3511 ; /* Assume the selected frame is already visible enough. */
3512 else if (minibuf_level
> 0
3513 && MINI_WINDOW_P (XWINDOW (selected_window
))
3514 && WINDOW_LIVE_P (minibuf_selected_window
)
3515 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3516 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3519 if (FRAME_ICONIFIED_P (f
))
3520 Fmake_frame_visible (frame
);
3521 else if (FRAME_VISIBLE_P (f
))
3522 Fraise_frame (frame
);
3528 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3529 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3530 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3531 special frame for that buffer using the default frame parameters.
3533 If the value is a list, it is a list of frame parameters that would be used
3534 to make a frame for that buffer.
3535 The variables `special-display-buffer-names'
3536 and `special-display-regexps' control this. */)
3538 Lisp_Object buffer_name
;
3542 CHECK_STRING (buffer_name
);
3544 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3548 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3552 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3554 Lisp_Object car
= XCAR (tem
);
3556 && fast_string_match (car
, buffer_name
) >= 0)
3558 else if (CONSP (car
)
3559 && STRINGP (XCAR (car
))
3560 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3566 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3567 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3568 More precisely, if `display-buffer' or `pop-to-buffer' would display
3569 that buffer in the selected window rather than (as usual) in some other window.
3570 See `same-window-buffer-names' and `same-window-regexps'. */)
3572 Lisp_Object buffer_name
;
3576 CHECK_STRING (buffer_name
);
3578 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3582 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3586 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3588 Lisp_Object car
= XCAR (tem
);
3590 && fast_string_match (car
, buffer_name
) >= 0)
3592 else if (CONSP (car
)
3593 && STRINGP (XCAR (car
))
3594 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3600 /* Use B so the default is (other-buffer). */
3601 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3602 "BDisplay buffer: \nP",
3603 doc
: /* Make BUFFER appear in some window but don't select it.
3604 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3606 If BUFFER is shown already in some window, just use that one,
3607 unless the window is the selected window and the optional second
3608 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3609 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3610 Returns the window displaying BUFFER.
3611 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3612 displaying BUFFER, then simply raise that frame.
3614 The variables `special-display-buffer-names',
3615 `special-display-regexps', `same-window-buffer-names', and
3616 `same-window-regexps' customize how certain buffer names are handled.
3617 The latter two take effect only if NOT-THIS-WINDOW is nil.
3619 If optional argument FRAME is `visible', check all visible frames
3620 for a window to use.
3621 If FRAME is 0, check all visible and iconified frames.
3622 If FRAME is t, check all frames.
3623 If FRAME is a frame, check only that frame.
3624 If FRAME is nil, check only the selected frame
3625 (actually the last nonminibuffer frame),
3626 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3627 which means search visible and iconified frames.
3629 If a full-width window on a splittable frame is available to display
3630 the buffer, it may be split, subject to the value of the variable
3631 `split-height-threshold'.
3633 If `even-window-heights' is non-nil, window heights will be evened out
3634 if displaying the buffer causes two vertically adjacent windows to be
3636 (buffer
, not_this_window
, frame
)
3637 register Lisp_Object buffer
, not_this_window
, frame
;
3639 register Lisp_Object window
, tem
, swp
;
3643 buffer
= Fget_buffer (buffer
);
3644 CHECK_BUFFER (buffer
);
3646 if (!NILP (Vdisplay_buffer_function
))
3647 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3649 if (NILP (not_this_window
)
3650 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3651 return display_buffer_1 (selected_window
);
3653 /* See if the user has specified this buffer should appear
3654 in the selected window. */
3655 if (NILP (not_this_window
))
3657 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3658 if (!NILP (swp
) && !no_switch_window (selected_window
))
3660 Fswitch_to_buffer (buffer
, Qnil
);
3661 return display_buffer_1 (selected_window
);
3665 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3666 look for a window showing BUFFER on any visible or iconified frame.
3667 Otherwise search only the current frame. */
3670 else if (pop_up_frames
3671 || display_buffer_reuse_frames
3672 || last_nonminibuf_frame
== 0)
3673 XSETFASTINT (tem
, 0);
3675 XSETFRAME (tem
, last_nonminibuf_frame
);
3677 window
= Fget_buffer_window (buffer
, tem
);
3679 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3680 return display_buffer_1 (window
);
3682 /* Certain buffer names get special handling. */
3683 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3685 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3687 return call1 (Vspecial_display_function
, buffer
);
3689 return call2 (Vspecial_display_function
, buffer
, tem
);
3692 /* If there are no frames open that have more than a minibuffer,
3693 we need to create a new frame. */
3694 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3696 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3697 Fset_window_buffer (window
, buffer
, Qnil
);
3698 return display_buffer_1 (window
);
3701 f
= SELECTED_FRAME ();
3703 || FRAME_MINIBUF_ONLY_P (f
)
3704 /* If the current frame is a special display frame,
3705 don't try to reuse its windows. */
3706 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3711 if (FRAME_MINIBUF_ONLY_P (f
))
3712 XSETFRAME (frames
, last_nonminibuf_frame
);
3713 /* Don't try to create a window if we would get an error. */
3714 if (split_height_threshold
< window_min_height
<< 1)
3715 split_height_threshold
= window_min_height
<< 1;
3717 /* Note that both Fget_largest_window and Fget_lru_window
3718 ignore minibuffers and dedicated windows.
3719 This means they can return nil. */
3721 /* If the frame we would try to split cannot be split,
3722 try other frames. */
3723 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3725 /* Try visible frames first. */
3726 window
= Fget_largest_window (Qvisible
, Qt
);
3727 /* If that didn't work, try iconified frames. */
3729 window
= Fget_largest_window (make_number (0), Qt
);
3730 #if 0 /* Don't try windows on other displays. */
3732 window
= Fget_largest_window (Qt
, Qt
);
3736 window
= Fget_largest_window (frames
, Qt
);
3738 /* If we got a tall enough full-width window that can be split,
3741 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3742 && window_height (window
) >= split_height_threshold
3743 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3744 window
= Fsplit_window (window
, Qnil
, Qnil
);
3747 Lisp_Object upper
, lower
, other
;
3749 window
= Fget_lru_window (frames
, Qt
);
3750 /* If the LRU window is selected, and big enough,
3751 and can be split, split it. */
3753 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3754 && (EQ (window
, selected_window
)
3755 || EQ (XWINDOW (window
)->parent
, Qnil
))
3756 && window_height (window
) >= window_min_height
<< 1)
3757 window
= Fsplit_window (window
, Qnil
, Qnil
);
3759 window
= Fget_lru_window (frames
, Qnil
);
3760 /* If Fget_lru_window returned nil, try other approaches. */
3762 /* Try visible frames first. */
3764 window
= Fget_buffer_window (buffer
, Qvisible
);
3766 window
= Fget_largest_window (Qvisible
, Qnil
);
3767 /* If that didn't work, try iconified frames. */
3769 window
= Fget_buffer_window (buffer
, make_number (0));
3771 window
= Fget_largest_window (make_number (0), Qnil
);
3773 #if 0 /* Don't try frames on other displays. */
3775 window
= Fget_buffer_window (buffer
, Qt
);
3777 window
= Fget_largest_window (Qt
, Qnil
);
3779 /* As a last resort, make a new frame. */
3781 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3782 /* If window appears above or below another,
3783 even out their heights. */
3784 other
= upper
= lower
= Qnil
;
3785 if (!NILP (XWINDOW (window
)->prev
))
3786 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3787 if (!NILP (XWINDOW (window
)->next
))
3788 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3790 && !NILP (Veven_window_heights
)
3791 /* Check that OTHER and WINDOW are vertically arrayed. */
3792 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3793 && (XFASTINT (XWINDOW (other
)->total_lines
)
3794 > XFASTINT (XWINDOW (window
)->total_lines
)))
3796 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3797 + XFASTINT (XWINDOW (window
)->total_lines
));
3798 enlarge_window (upper
,
3799 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3805 window
= Fget_lru_window (Qnil
, Qnil
);
3807 Fset_window_buffer (window
, buffer
, Qnil
);
3808 return display_buffer_1 (window
);
3812 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3814 doc
: /* Force all windows to be updated on next redisplay.
3815 If optional arg OBJECT is a window, force redisplay of that window only.
3816 If OBJECT is a buffer or buffer name, force redisplay of all windows
3817 displaying that buffer. */)
3823 windows_or_buffers_changed
++;
3824 update_mode_lines
++;
3828 if (WINDOWP (object
))
3830 struct window
*w
= XWINDOW (object
);
3831 mark_window_display_accurate (object
, 0);
3832 w
->update_mode_line
= Qt
;
3833 if (BUFFERP (w
->buffer
))
3834 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3835 ++update_mode_lines
;
3839 if (STRINGP (object
))
3840 object
= Fget_buffer (object
);
3841 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3843 /* Walk all windows looking for buffer, and force update
3844 of each of those windows. */
3846 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3847 return NILP (object
) ? Qnil
: Qt
;
3850 /* If nothing suitable was found, just return.
3851 We could signal an error, but this feature will typically be used
3852 asynchronously in timers or process sentinels, so we don't. */
3858 temp_output_buffer_show (buf
)
3859 register Lisp_Object buf
;
3861 register struct buffer
*old
= current_buffer
;
3862 register Lisp_Object window
;
3863 register struct window
*w
;
3865 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3868 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3872 #if 0 /* rms: there should be no reason for this. */
3873 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3875 set_buffer_internal (old
);
3877 if (!NILP (Vtemp_buffer_show_function
))
3878 call1 (Vtemp_buffer_show_function
, buf
);
3881 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3883 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3884 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3885 Vminibuf_scroll_window
= window
;
3886 w
= XWINDOW (window
);
3887 XSETFASTINT (w
->hscroll
, 0);
3888 XSETFASTINT (w
->min_hscroll
, 0);
3889 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3890 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3892 /* Run temp-buffer-show-hook, with the chosen window selected
3893 and its buffer current. */
3895 if (!NILP (Vrun_hooks
)
3896 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3897 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3899 int count
= SPECPDL_INDEX ();
3900 Lisp_Object prev_window
, prev_buffer
;
3901 prev_window
= selected_window
;
3902 XSETBUFFER (prev_buffer
, old
);
3904 /* Select the window that was chosen, for running the hook.
3905 Note: Both Fselect_window and select_window_norecord may
3906 set-buffer to the buffer displayed in the window,
3907 so we need to save the current buffer. --stef */
3908 record_unwind_protect (Fset_buffer
, prev_buffer
);
3909 record_unwind_protect (select_window_norecord
, prev_window
);
3910 Fselect_window (window
, Qt
);
3911 Fset_buffer (w
->buffer
);
3912 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3913 unbind_to (count
, Qnil
);
3919 make_dummy_parent (window
)
3923 register struct window
*o
, *p
;
3926 o
= XWINDOW (window
);
3927 p
= allocate_window ();
3928 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3929 ((struct Lisp_Vector
*) p
)->contents
[i
]
3930 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3931 XSETWINDOW (new, p
);
3934 XSETFASTINT (p
->sequence_number
, sequence_number
);
3936 /* Put new into window structure in place of window */
3937 replace_window (window
, new);
3950 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3951 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3952 WINDOW defaults to selected one and SIZE to half its size.
3953 If optional third arg HORFLAG is non-nil, split side by side
3954 and put SIZE columns in the first of the pair. In that case,
3955 SIZE includes that window's scroll bar, or the divider column to its right.
3956 Interactively, all arguments are nil.
3958 Returns the newly created window (which is the lower or rightmost one).
3959 The upper or leftmost window is the original one, and remains selected
3960 if it was selected before.
3962 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3963 (window
, size
, horflag
)
3964 Lisp_Object window
, size
, horflag
;
3966 register Lisp_Object
new;
3967 register struct window
*o
, *p
;
3969 register int size_int
;
3972 window
= selected_window
;
3974 CHECK_LIVE_WINDOW (window
);
3976 o
= XWINDOW (window
);
3977 fo
= XFRAME (WINDOW_FRAME (o
));
3981 if (!NILP (horflag
))
3982 /* Calculate the size of the left-hand window, by dividing
3983 the usable space in columns by two.
3984 We round up, since the left-hand window may include
3985 a dividing line, while the right-hand may not. */
3986 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3988 size_int
= XFASTINT (o
->total_lines
) >> 1;
3992 CHECK_NUMBER (size
);
3993 size_int
= XINT (size
);
3996 if (MINI_WINDOW_P (o
))
3997 error ("Attempt to split minibuffer window");
3998 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3999 error ("Attempt to split fixed-size window");
4001 check_min_window_sizes ();
4005 if (size_int
< window_min_height
)
4006 error ("Window height %d too small (after splitting)", size_int
);
4007 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
4008 error ("Window height %d too small (after splitting)",
4009 XFASTINT (o
->total_lines
) - size_int
);
4010 if (NILP (o
->parent
)
4011 || NILP (XWINDOW (o
->parent
)->vchild
))
4013 make_dummy_parent (window
);
4015 XWINDOW (new)->vchild
= window
;
4020 if (size_int
< window_min_width
)
4021 error ("Window width %d too small (after splitting)", size_int
);
4023 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
4024 error ("Window width %d too small (after splitting)",
4025 XFASTINT (o
->total_cols
) - size_int
);
4026 if (NILP (o
->parent
)
4027 || NILP (XWINDOW (o
->parent
)->hchild
))
4029 make_dummy_parent (window
);
4031 XWINDOW (new)->hchild
= window
;
4035 /* Now we know that window's parent is a vertical combination
4036 if we are dividing vertically, or a horizontal combination
4037 if we are making side-by-side windows */
4039 windows_or_buffers_changed
++;
4040 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
4041 new = make_window ();
4044 p
->frame
= o
->frame
;
4046 if (!NILP (p
->next
))
4047 XWINDOW (p
->next
)->prev
= new;
4050 p
->parent
= o
->parent
;
4052 p
->window_end_valid
= Qnil
;
4053 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
4055 /* Duplicate special geometry settings. */
4057 p
->left_margin_cols
= o
->left_margin_cols
;
4058 p
->right_margin_cols
= o
->right_margin_cols
;
4059 p
->left_fringe_width
= o
->left_fringe_width
;
4060 p
->right_fringe_width
= o
->right_fringe_width
;
4061 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
4062 p
->scroll_bar_width
= o
->scroll_bar_width
;
4063 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
4065 /* Apportion the available frame space among the two new windows */
4067 if (!NILP (horflag
))
4069 p
->total_lines
= o
->total_lines
;
4070 p
->top_line
= o
->top_line
;
4071 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
4072 XSETFASTINT (o
->total_cols
, size_int
);
4073 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
4074 adjust_window_margins (p
);
4075 adjust_window_margins (o
);
4079 p
->left_col
= o
->left_col
;
4080 p
->total_cols
= o
->total_cols
;
4081 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
4082 XSETFASTINT (o
->total_lines
, size_int
);
4083 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
4086 /* Adjust glyph matrices. */
4089 Fset_window_buffer (new, o
->buffer
, Qt
);
4093 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
4094 doc
: /* Make current window ARG lines bigger.
4095 From program, optional second arg non-nil means grow sideways ARG columns.
4096 Interactively, if an argument is not given, make the window one line bigger.
4097 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
4098 This function can delete windows, even the second window, if they get
4101 Lisp_Object arg
, horizontal
;
4104 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
4106 if (! NILP (Vwindow_configuration_change_hook
))
4107 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4112 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
4113 doc
: /* Make current window ARG lines smaller.
4114 From program, optional second arg non-nil means shrink sideways arg columns.
4115 Interactively, if an argument is not given, make the window one line smaller. Only
4116 siblings to the right or below are changed. */)
4118 Lisp_Object arg
, side
;
4121 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
4123 if (! NILP (Vwindow_configuration_change_hook
))
4124 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4130 window_height (window
)
4133 register struct window
*p
= XWINDOW (window
);
4134 return WINDOW_TOTAL_LINES (p
);
4138 window_width (window
)
4141 register struct window
*p
= XWINDOW (window
);
4142 return WINDOW_TOTAL_COLS (p
);
4147 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4149 #define CURSIZE(w) \
4150 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4153 /* Enlarge WINDOW by DELTA.
4154 HORIZ_FLAG nonzero means enlarge it horizontally;
4155 zero means do it vertically.
4157 Siblings of the selected window are resized to fulfill the size
4158 request. If they become too small in the process, they will be
4162 enlarge_window (window
, delta
, horiz_flag
)
4164 int delta
, horiz_flag
;
4166 Lisp_Object parent
, next
, prev
;
4170 int (*sizefun
) P_ ((Lisp_Object
))
4171 = horiz_flag
? window_width
: window_height
;
4172 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
4173 = (horiz_flag
? set_window_width
: set_window_height
);
4175 /* Check values of window_min_width and window_min_height for
4177 check_min_window_sizes ();
4179 /* Give up if this window cannot be resized. */
4180 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4181 error ("Window is not resizable");
4183 /* Find the parent of the selected window. */
4186 p
= XWINDOW (window
);
4192 error ("No other window to side of this one");
4197 ? !NILP (XWINDOW (parent
)->hchild
)
4198 : !NILP (XWINDOW (parent
)->vchild
))
4204 sizep
= &CURSIZE (window
);
4207 register int maxdelta
;
4209 /* Compute the maximum size increment this window can have. */
4211 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4212 /* This is a main window followed by a minibuffer. */
4213 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4214 - window_min_size (XWINDOW (p
->next
),
4216 /* This is a minibuffer following a main window. */
4217 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4218 - window_min_size (XWINDOW (p
->prev
),
4220 /* This is a frame with only one window, a minibuffer-only
4221 or a minibufferless frame. */
4224 if (delta
> maxdelta
)
4225 /* This case traps trying to make the minibuffer
4226 the full frame, or make the only window aside from the
4227 minibuffer the full frame. */
4231 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4233 delete_window (window
);
4240 /* Find the total we can get from other siblings without deleting them. */
4242 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4243 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4245 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4246 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4249 /* If we can get it all from them without deleting them, do so. */
4250 if (delta
<= maximum
)
4252 Lisp_Object first_unaffected
;
4253 Lisp_Object first_affected
;
4258 first_affected
= window
;
4259 /* Look at one sibling at a time,
4260 moving away from this window in both directions alternately,
4261 and take as much as we can get without deleting that sibling. */
4263 && (!NILP (next
) || !NILP (prev
)))
4267 int this_one
= ((*sizefun
) (next
)
4268 - window_min_size (XWINDOW (next
),
4269 horiz_flag
, 0, &fixed_p
));
4272 if (this_one
> delta
)
4275 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4276 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4281 next
= XWINDOW (next
)->next
;
4289 int this_one
= ((*sizefun
) (prev
)
4290 - window_min_size (XWINDOW (prev
),
4291 horiz_flag
, 0, &fixed_p
));
4294 if (this_one
> delta
)
4297 first_affected
= prev
;
4299 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4300 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4305 prev
= XWINDOW (prev
)->prev
;
4309 xassert (delta
== 0);
4311 /* Now recalculate the edge positions of all the windows affected,
4312 based on the new sizes. */
4313 first_unaffected
= next
;
4314 prev
= first_affected
;
4315 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4316 prev
= next
, next
= XWINDOW (next
)->next
)
4318 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4319 /* This does not change size of NEXT,
4320 but it propagates the new top edge to its children */
4321 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4326 register int delta1
;
4327 register int opht
= (*sizefun
) (parent
);
4329 if (opht
<= XINT (*sizep
) + delta
)
4331 /* If trying to grow this window to or beyond size of the parent,
4332 just delete all the sibling windows. */
4333 Lisp_Object start
, tem
, next
;
4335 start
= XWINDOW (parent
)->vchild
;
4337 start
= XWINDOW (parent
)->hchild
;
4339 /* Delete any siblings that come after WINDOW. */
4340 tem
= XWINDOW (window
)->next
;
4341 while (! NILP (tem
))
4343 next
= XWINDOW (tem
)->next
;
4344 delete_window (tem
);
4348 /* Delete any siblings that come after WINDOW.
4349 Note that if START is not WINDOW, then WINDOW still
4350 Fhas siblings, so WINDOW has not yet replaced its parent. */
4352 while (! EQ (tem
, window
))
4354 next
= XWINDOW (tem
)->next
;
4355 delete_window (tem
);
4361 /* Otherwise, make delta1 just right so that if we add
4362 delta1 lines to this window and to the parent, and then
4363 shrink the parent back to its original size, the new
4364 proportional size of this window will increase by delta.
4366 The function size_window will compute the new height h'
4367 of the window from delta1 as:
4370 x = delta1 - delta1/n * n for the 1st resizable child
4373 where n is the number of children that can be resized.
4374 We can ignore x by choosing a delta1 that is a multiple of
4375 n. We want the height of this window to come out as
4385 The number of children n equals the number of resizable
4386 children of this window + 1 because we know window itself
4387 is resizable (otherwise we would have signalled an error). */
4389 struct window
*w
= XWINDOW (window
);
4393 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4394 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4396 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4397 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4402 /* Add delta1 lines or columns to this window, and to the parent,
4403 keeping things consistent while not affecting siblings. */
4404 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4405 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4407 /* Squeeze out delta1 lines or columns from our parent,
4408 shriking this window and siblings proportionately.
4409 This brings parent back to correct size.
4410 Delta1 was calculated so this makes this window the desired size,
4411 taking it all out of the siblings. */
4412 (*setsizefun
) (parent
, opht
, 0);
4417 XSETFASTINT (p
->last_modified
, 0);
4418 XSETFASTINT (p
->last_overlay_modified
, 0);
4420 /* Adjust glyph matrices. */
4421 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4425 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4426 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4427 zero means adjust the height, moving the bottom edge.
4429 Following siblings of the selected window are resized to fulfill
4430 the size request. If they become too small in the process, they
4431 are not deleted; instead, we signal an error. */
4434 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4436 int delta
, horiz_flag
;
4438 Lisp_Object parent
, child
;
4440 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4441 int delcount
= window_deletion_count
;
4443 /* Check values of window_min_width and window_min_height for
4445 check_min_window_sizes ();
4448 window
= Fselected_window ();
4450 CHECK_WINDOW (window
);
4452 /* Give up if this window cannot be resized. */
4453 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4454 error ("Window is not resizable");
4458 Lisp_Object first_parallel
= Qnil
;
4462 /* This happens if WINDOW on the previous iteration was
4463 at top level of the window tree. */
4464 Fset_window_configuration (old_config
);
4465 error ("Specified window edge is fixed");
4468 p
= XWINDOW (window
);
4471 /* See if this level has windows in parallel in the specified
4472 direction. If so, set FIRST_PARALLEL to the first one. */
4475 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4476 first_parallel
= XWINDOW (parent
)->vchild
;
4477 else if (NILP (parent
) && !NILP (p
->next
))
4479 /* Handle the vertical chain of main window and minibuffer
4480 which has no parent. */
4481 first_parallel
= window
;
4482 while (! NILP (XWINDOW (first_parallel
)->prev
))
4483 first_parallel
= XWINDOW (first_parallel
)->prev
;
4488 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4489 first_parallel
= XWINDOW (parent
)->hchild
;
4492 /* If this level's succession is in the desired dimension,
4493 and this window is the last one, and there is no higher level,
4494 its trailing edge is fixed. */
4495 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4498 Fset_window_configuration (old_config
);
4499 error ("Specified window edge is fixed");
4502 /* Don't make this window too small. */
4503 if (XINT (CURSIZE (window
)) + delta
4504 < (horiz_flag
? window_min_width
: window_min_height
))
4506 Fset_window_configuration (old_config
);
4507 error ("Cannot adjust window size as specified");
4510 /* Clear out some redisplay caches. */
4511 XSETFASTINT (p
->last_modified
, 0);
4512 XSETFASTINT (p
->last_overlay_modified
, 0);
4514 /* Adjust this window's edge. */
4515 XSETINT (CURSIZE (window
),
4516 XINT (CURSIZE (window
)) + delta
);
4518 /* If this window has following siblings in the desired dimension,
4519 make them smaller, and exit the loop.
4521 (If we reach the top of the tree and can never do this,
4522 we will fail and report an error, above.) */
4523 if (NILP (first_parallel
))
4525 if (!NILP (p
->next
))
4527 /* This may happen for the minibuffer. In that case
4528 the window_deletion_count check below does not work. */
4529 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4531 Fset_window_configuration (old_config
);
4532 error ("Cannot adjust window size as specified");
4535 XSETINT (CURBEG (p
->next
),
4536 XINT (CURBEG (p
->next
)) + delta
);
4537 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4538 horiz_flag
, 0, 1, 0);
4543 /* Here we have a chain of parallel siblings, in the other dimension.
4544 Change the size of the other siblings. */
4545 for (child
= first_parallel
;
4547 child
= XWINDOW (child
)->next
)
4548 if (! EQ (child
, window
))
4549 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4550 horiz_flag
, 0, 0, 1);
4555 /* If we made a window so small it got deleted,
4556 we failed. Report failure. */
4557 if (delcount
!= window_deletion_count
)
4559 Fset_window_configuration (old_config
);
4560 error ("Cannot adjust window size as specified");
4563 /* Adjust glyph matrices. */
4564 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4570 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4571 Sadjust_window_trailing_edge
, 3, 3, 0,
4572 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4573 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4574 Otherwise, adjust the height, moving the bottom edge.
4576 Following siblings of the selected window are resized to fulfill
4577 the size request. If they become too small in the process, they
4578 are not deleted; instead, we signal an error. */)
4579 (window
, delta
, horizontal
)
4580 Lisp_Object window
, delta
, horizontal
;
4582 CHECK_NUMBER (delta
);
4583 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4585 if (! NILP (Vwindow_configuration_change_hook
))
4586 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4593 /***********************************************************************
4594 Resizing Mini-Windows
4595 ***********************************************************************/
4597 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4599 enum save_restore_action
4606 static int save_restore_orig_size
P_ ((struct window
*,
4607 enum save_restore_action
));
4609 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4610 from lowest windows first. */
4613 shrink_window_lowest_first (w
, height
)
4621 xassert (!MINI_WINDOW_P (w
));
4623 /* Set redisplay hints. */
4624 XSETFASTINT (w
->last_modified
, 0);
4625 XSETFASTINT (w
->last_overlay_modified
, 0);
4626 windows_or_buffers_changed
++;
4627 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4629 old_height
= XFASTINT (w
->total_lines
);
4630 XSETFASTINT (w
->total_lines
, height
);
4632 if (!NILP (w
->hchild
))
4634 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4636 c
= XWINDOW (child
);
4637 c
->top_line
= w
->top_line
;
4638 shrink_window_lowest_first (c
, height
);
4641 else if (!NILP (w
->vchild
))
4643 Lisp_Object last_child
;
4644 int delta
= old_height
- height
;
4649 /* Find the last child. We are taking space from lowest windows
4650 first, so we iterate over children from the last child
4652 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4655 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4656 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4660 c
= XWINDOW (child
);
4661 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4663 if (this_one
> delta
)
4666 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4670 /* Compute new positions. */
4671 last_top
= XINT (w
->top_line
);
4672 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4674 c
= XWINDOW (child
);
4675 c
->top_line
= make_number (last_top
);
4676 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4677 last_top
+= XFASTINT (c
->total_lines
);
4683 /* Save, restore, or check positions and sizes in the window tree
4684 rooted at W. ACTION says what to do.
4686 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4687 orig_total_lines members are valid for all windows in the window
4688 tree. Value is non-zero if they are valid.
4690 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4691 orig_top_line and orig_total_lines for all windows in the tree.
4693 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4694 stored in orig_top_line and orig_total_lines for all windows. */
4697 save_restore_orig_size (w
, action
)
4699 enum save_restore_action action
;
4705 if (!NILP (w
->hchild
))
4707 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4710 else if (!NILP (w
->vchild
))
4712 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4718 case CHECK_ORIG_SIZES
:
4719 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4723 case SAVE_ORIG_SIZES
:
4724 w
->orig_top_line
= w
->top_line
;
4725 w
->orig_total_lines
= w
->total_lines
;
4726 XSETFASTINT (w
->last_modified
, 0);
4727 XSETFASTINT (w
->last_overlay_modified
, 0);
4730 case RESTORE_ORIG_SIZES
:
4731 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4732 w
->top_line
= w
->orig_top_line
;
4733 w
->total_lines
= w
->orig_total_lines
;
4734 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4735 XSETFASTINT (w
->last_modified
, 0);
4736 XSETFASTINT (w
->last_overlay_modified
, 0);
4743 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4750 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4751 without deleting other windows. */
4754 grow_mini_window (w
, delta
)
4758 struct frame
*f
= XFRAME (w
->frame
);
4759 struct window
*root
;
4761 xassert (MINI_WINDOW_P (w
));
4762 xassert (delta
>= 0);
4764 /* Check values of window_min_width and window_min_height for
4766 check_min_window_sizes ();
4768 /* Compute how much we can enlarge the mini-window without deleting
4770 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4773 int min_height
= window_min_size (root
, 0, 0, 0);
4774 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4775 /* Note that the root window may already be smaller than
4777 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4782 /* Save original window sizes and positions, if not already done. */
4783 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4784 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4786 /* Shrink other windows. */
4787 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4789 /* Grow the mini-window. */
4790 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4791 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4792 XSETFASTINT (w
->last_modified
, 0);
4793 XSETFASTINT (w
->last_overlay_modified
, 0);
4800 /* Shrink mini-window W. If there is recorded info about window sizes
4801 before a call to grow_mini_window, restore recorded window sizes.
4802 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4806 shrink_mini_window (w
)
4809 struct frame
*f
= XFRAME (w
->frame
);
4810 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4812 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4814 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4816 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4817 windows_or_buffers_changed
= 1;
4819 else if (XFASTINT (w
->total_lines
) > 1)
4821 /* Distribute the additional lines of the mini-window
4822 among the other windows. */
4824 XSETWINDOW (window
, w
);
4825 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4831 /* Mark window cursors off for all windows in the window tree rooted
4832 at W by setting their phys_cursor_on_p flag to zero. Called from
4833 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4834 the frame are cleared. */
4837 mark_window_cursors_off (w
)
4842 if (!NILP (w
->hchild
))
4843 mark_window_cursors_off (XWINDOW (w
->hchild
));
4844 else if (!NILP (w
->vchild
))
4845 mark_window_cursors_off (XWINDOW (w
->vchild
));
4847 w
->phys_cursor_on_p
= 0;
4849 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4854 /* Return number of lines of text (not counting mode lines) in W. */
4857 window_internal_height (w
)
4860 int ht
= XFASTINT (w
->total_lines
);
4862 if (!MINI_WINDOW_P (w
))
4864 if (!NILP (w
->parent
)
4865 || !NILP (w
->vchild
)
4866 || !NILP (w
->hchild
)
4869 || WINDOW_WANTS_MODELINE_P (w
))
4872 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4880 /* Return the number of columns in W.
4881 Don't count columns occupied by scroll bars or the vertical bar
4882 separating W from the sibling to its right. */
4885 window_box_text_cols (w
)
4888 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4889 int width
= XINT (w
->total_cols
);
4891 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4892 /* Scroll bars occupy a few columns. */
4893 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4894 else if (!FRAME_WINDOW_P (f
)
4895 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4896 /* The column of `|' characters separating side-by-side windows
4897 occupies one column only. */
4900 if (FRAME_WINDOW_P (f
))
4901 /* On window-systems, fringes and display margins cannot be
4902 used for normal text. */
4903 width
-= (WINDOW_FRINGE_COLS (w
)
4904 + WINDOW_LEFT_MARGIN_COLS (w
)
4905 + WINDOW_RIGHT_MARGIN_COLS (w
));
4911 /************************************************************************
4913 ***********************************************************************/
4915 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4916 N screen-fulls, which is defined as the height of the window minus
4917 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4918 instead. Negative values of N mean scroll down. NOERROR non-zero
4919 means don't signal an error if we try to move over BEGV or ZV,
4923 window_scroll (window
, n
, whole
, noerror
)
4931 /* If we must, use the pixel-based version which is much slower than
4932 the line-based one but can handle varying line heights. */
4933 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4934 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4936 window_scroll_line_based (window
, n
, whole
, noerror
);
4942 /* Implementation of window_scroll that works based on pixel line
4943 heights. See the comment of window_scroll for parameter
4947 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4954 struct window
*w
= XWINDOW (window
);
4955 struct text_pos start
;
4956 int this_scroll_margin
;
4957 /* True if we fiddled the window vscroll field without really scrolling. */
4959 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4961 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4963 /* If PT is not visible in WINDOW, move back one half of
4964 the screen. Allow PT to be partially visible, otherwise
4965 something like (scroll-down 1) with PT in the line before
4966 the partially visible one would recenter. */
4968 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4970 /* Move backward half the height of the window. Performance note:
4971 vmotion used here is about 10% faster, but would give wrong
4972 results for variable height lines. */
4973 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4974 it
.current_y
= it
.last_visible_y
;
4975 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4977 /* The function move_iterator_vertically may move over more than
4978 the specified y-distance. If it->w is small, e.g. a
4979 mini-buffer window, we may end up in front of the window's
4980 display area. This is the case when Start displaying at the
4981 start of the line containing PT in this case. */
4982 if (it
.current_y
<= 0)
4984 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4985 move_it_vertically_backward (&it
, 0);
4989 start
= it
.current
.pos
;
4991 else if (auto_window_vscroll_p
)
4993 if (rtop
|| rbot
) /* partially visible */
4996 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4998 dy
= max ((window_box_height (w
)
4999 - next_screen_context_lines
* dy
),
5005 /* Only vscroll backwards if already vscrolled forwards. */
5006 if (w
->vscroll
< 0 && rtop
> 0)
5008 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
5009 Fset_window_vscroll (window
, make_number (px
), Qt
);
5015 /* Do vscroll if already vscrolled or only display line. */
5016 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
5018 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
5019 Fset_window_vscroll (window
, make_number (px
), Qt
);
5023 /* Maybe modify window start instead of scrolling. */
5024 if (rbot
> 0 || w
->vscroll
< 0)
5028 Fset_window_vscroll (window
, make_number (0), Qt
);
5029 /* If there are other text lines above the current row,
5030 move window start to current row. Else to next row. */
5032 spos
= XINT (Fline_beginning_position (Qnil
));
5034 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
5035 set_marker_restricted (w
->start
, make_number (spos
),
5037 w
->start_at_line_beg
= Qt
;
5038 w
->update_mode_line
= Qt
;
5039 XSETFASTINT (w
->last_modified
, 0);
5040 XSETFASTINT (w
->last_overlay_modified
, 0);
5041 /* Set force_start so that redisplay_window will run the
5042 window-scroll-functions. */
5043 w
->force_start
= Qt
;
5048 /* Cancel previous vscroll. */
5049 Fset_window_vscroll (window
, make_number (0), Qt
);
5052 /* If scroll_preserve_screen_position is non-nil, we try to set
5053 point in the same window line as it is now, so get that line. */
5054 if (!NILP (Vscroll_preserve_screen_position
))
5056 /* We preserve the goal pixel coordinate across consecutive
5057 calls to scroll-up or scroll-down. This avoids the
5058 possibility of point becoming "stuck" on a tall line when
5059 scrolling by one line. */
5060 if (window_scroll_pixel_based_preserve_y
< 0
5061 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5062 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5064 start_display (&it
, w
, start
);
5065 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5066 window_scroll_pixel_based_preserve_y
= it
.current_y
;
5070 window_scroll_pixel_based_preserve_y
= -1;
5072 /* Move iterator it from start the specified distance forward or
5073 backward. The result is the new window start. */
5074 start_display (&it
, w
, start
);
5077 int start_pos
= IT_CHARPOS (it
);
5078 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5079 dy
= max ((window_box_height (w
)
5080 - next_screen_context_lines
* dy
),
5083 /* Note that move_it_vertically always moves the iterator to the
5084 start of a line. So, if the last line doesn't have a newline,
5085 we would end up at the start of the line ending at ZV. */
5088 move_it_vertically_backward (&it
, -dy
);
5089 /* Ensure we actually do move, e.g. in case we are currently
5090 looking at an image that is taller that the window height. */
5091 while (start_pos
== IT_CHARPOS (it
)
5092 && start_pos
> BEGV
)
5093 move_it_by_lines (&it
, -1, 1);
5097 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
5098 MOVE_TO_POS
| MOVE_TO_Y
);
5099 /* Ensure we actually do move, e.g. in case we are currently
5100 looking at an image that is taller that the window height. */
5101 while (start_pos
== IT_CHARPOS (it
)
5103 move_it_by_lines (&it
, 1, 1);
5107 move_it_by_lines (&it
, n
, 1);
5109 /* We failed if we find ZV is already on the screen (scrolling up,
5110 means there's nothing past the end), or if we can't start any
5111 earlier (scrolling down, means there's nothing past the top). */
5112 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
5113 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
5115 if (IT_CHARPOS (it
) == ZV
)
5117 if (it
.current_y
< it
.last_visible_y
5118 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
5119 > it
.last_visible_y
))
5121 /* The last line was only partially visible, make it fully
5123 w
->vscroll
= (it
.last_visible_y
5124 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
5125 adjust_glyphs (it
.f
);
5129 else if (n
< 0) /* could happen with empty buffers */
5130 xsignal0 (Qbeginning_of_buffer
);
5132 xsignal0 (Qend_of_buffer
);
5136 if (w
->vscroll
!= 0)
5137 /* The first line was only partially visible, make it fully
5143 xsignal0 (Qbeginning_of_buffer
);
5146 /* If control gets here, then we vscrolled. */
5148 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5150 /* Don't try to change the window start below. */
5156 int pos
= IT_CHARPOS (it
);
5159 /* If in the middle of a multi-glyph character move forward to
5160 the next character. */
5161 if (in_display_vector_p (&it
))
5164 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5167 /* Set the window start, and set up the window for redisplay. */
5168 set_marker_restricted (w
->start
, make_number (pos
),
5170 bytepos
= XMARKER (w
->start
)->bytepos
;
5171 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5173 w
->update_mode_line
= Qt
;
5174 XSETFASTINT (w
->last_modified
, 0);
5175 XSETFASTINT (w
->last_overlay_modified
, 0);
5176 /* Set force_start so that redisplay_window will run the
5177 window-scroll-functions. */
5178 w
->force_start
= Qt
;
5181 /* The rest of this function uses current_y in a nonstandard way,
5182 not including the height of the header line if any. */
5183 it
.current_y
= it
.vpos
= 0;
5185 /* Move PT out of scroll margins.
5186 This code wants current_y to be zero at the window start position
5187 even if there is a header line. */
5188 this_scroll_margin
= max (0, scroll_margin
);
5189 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5190 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5194 /* We moved the window start towards ZV, so PT may be now
5195 in the scroll margin at the top. */
5196 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5197 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5198 && (NILP (Vscroll_preserve_screen_position
)
5199 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5200 /* We found PT at a legitimate height. Leave it alone. */
5202 else if (window_scroll_pixel_based_preserve_y
>= 0)
5204 /* If we have a header line, take account of it.
5205 This is necessary because we set it.current_y to 0, above. */
5206 move_it_to (&it
, -1, -1,
5207 window_scroll_pixel_based_preserve_y
5208 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5210 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5214 while (it
.current_y
< this_scroll_margin
)
5216 int prev
= it
.current_y
;
5217 move_it_by_lines (&it
, 1, 1);
5218 if (prev
== it
.current_y
)
5221 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5226 int charpos
, bytepos
;
5229 /* Save our position, for the
5230 window_scroll_pixel_based_preserve_y case. */
5231 charpos
= IT_CHARPOS (it
);
5232 bytepos
= IT_BYTEPOS (it
);
5234 /* We moved the window start towards BEGV, so PT may be now
5235 in the scroll margin at the bottom. */
5236 move_it_to (&it
, PT
, -1,
5237 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5238 - this_scroll_margin
- 1),
5240 MOVE_TO_POS
| MOVE_TO_Y
);
5242 /* Save our position, in case it's correct. */
5243 charpos
= IT_CHARPOS (it
);
5244 bytepos
= IT_BYTEPOS (it
);
5246 /* See if point is on a partially visible line at the end. */
5247 if (it
.what
== IT_EOB
)
5248 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5251 move_it_by_lines (&it
, 1, 1);
5252 partial_p
= it
.current_y
> it
.last_visible_y
;
5255 if (charpos
== PT
&& !partial_p
5256 && (NILP (Vscroll_preserve_screen_position
)
5257 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5258 /* We found PT before we found the display margin, so PT is ok. */
5260 else if (window_scroll_pixel_based_preserve_y
>= 0)
5262 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5263 start_display (&it
, w
, start
);
5264 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5265 here because we called start_display again and did not
5266 alter it.current_y this time. */
5267 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5269 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5274 /* The last line was only partially visible, so back up two
5275 lines to make sure we're on a fully visible line. */
5277 move_it_by_lines (&it
, -2, 0);
5278 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5281 /* No, the position we saved is OK, so use it. */
5282 SET_PT_BOTH (charpos
, bytepos
);
5288 /* Implementation of window_scroll that works based on screen lines.
5289 See the comment of window_scroll for parameter descriptions. */
5292 window_scroll_line_based (window
, n
, whole
, noerror
)
5298 register struct window
*w
= XWINDOW (window
);
5299 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5300 register int pos
, pos_byte
;
5301 register int ht
= window_internal_height (w
);
5302 register Lisp_Object tem
;
5306 struct position posit
;
5309 /* If scrolling screen-fulls, compute the number of lines to
5310 scroll from the window's height. */
5312 n
*= max (1, ht
- next_screen_context_lines
);
5314 startpos
= marker_position (w
->start
);
5316 posit
= *compute_motion (startpos
, 0, 0, 0,
5318 -1, XINT (w
->hscroll
),
5320 original_vpos
= posit
.vpos
;
5322 XSETFASTINT (tem
, PT
);
5323 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5327 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5332 lose
= n
< 0 && PT
== BEGV
;
5333 Fvertical_motion (make_number (n
), window
);
5337 SET_PT_BOTH (opoint
, opoint_byte
);
5344 xsignal0 (Qbeginning_of_buffer
);
5349 int this_scroll_margin
= scroll_margin
;
5351 /* Don't use a scroll margin that is negative or too large. */
5352 if (this_scroll_margin
< 0)
5353 this_scroll_margin
= 0;
5355 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5356 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5358 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5359 w
->start_at_line_beg
= bolp
;
5360 w
->update_mode_line
= Qt
;
5361 XSETFASTINT (w
->last_modified
, 0);
5362 XSETFASTINT (w
->last_overlay_modified
, 0);
5363 /* Set force_start so that redisplay_window will run
5364 the window-scroll-functions. */
5365 w
->force_start
= Qt
;
5367 if (!NILP (Vscroll_preserve_screen_position
)
5368 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5370 SET_PT_BOTH (pos
, pos_byte
);
5371 Fvertical_motion (make_number (original_vpos
), window
);
5373 /* If we scrolled forward, put point enough lines down
5374 that it is outside the scroll margin. */
5379 if (this_scroll_margin
> 0)
5381 SET_PT_BOTH (pos
, pos_byte
);
5382 Fvertical_motion (make_number (this_scroll_margin
), window
);
5388 if (top_margin
<= opoint
)
5389 SET_PT_BOTH (opoint
, opoint_byte
);
5390 else if (!NILP (Vscroll_preserve_screen_position
))
5392 SET_PT_BOTH (pos
, pos_byte
);
5393 Fvertical_motion (make_number (original_vpos
), window
);
5396 SET_PT (top_margin
);
5402 /* If we scrolled backward, put point near the end of the window
5403 but not within the scroll margin. */
5404 SET_PT_BOTH (pos
, pos_byte
);
5405 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5406 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5409 bottom_margin
= PT
+ 1;
5411 if (bottom_margin
> opoint
)
5412 SET_PT_BOTH (opoint
, opoint_byte
);
5415 if (!NILP (Vscroll_preserve_screen_position
))
5417 SET_PT_BOTH (pos
, pos_byte
);
5418 Fvertical_motion (make_number (original_vpos
), window
);
5421 Fvertical_motion (make_number (-1), window
);
5430 xsignal0 (Qend_of_buffer
);
5435 /* Scroll selected_window up or down. If N is nil, scroll a
5436 screen-full which is defined as the height of the window minus
5437 next_screen_context_lines. If N is the symbol `-', scroll.
5438 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5439 up. This is the guts of Fscroll_up and Fscroll_down. */
5442 scroll_command (n
, direction
)
5446 int count
= SPECPDL_INDEX ();
5448 xassert (abs (direction
) == 1);
5450 /* If selected window's buffer isn't current, make it current for
5451 the moment. But don't screw up if window_scroll gets an error. */
5452 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5454 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5455 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5457 /* Make redisplay consider other windows than just selected_window. */
5458 ++windows_or_buffers_changed
;
5462 window_scroll (selected_window
, direction
, 1, 0);
5463 else if (EQ (n
, Qminus
))
5464 window_scroll (selected_window
, -direction
, 1, 0);
5467 n
= Fprefix_numeric_value (n
);
5468 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5471 unbind_to (count
, Qnil
);
5474 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5475 doc
: /* Scroll text of current window upward ARG lines.
5476 If ARG is omitted or nil, scroll upward by a near full screen.
5477 A near full screen is `next-screen-context-lines' less than a full screen.
5478 Negative ARG means scroll downward.
5479 If ARG is the atom `-', scroll downward by nearly full screen.
5480 When calling from a program, supply as argument a number, nil, or `-'. */)
5484 scroll_command (arg
, 1);
5488 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5489 doc
: /* Scroll text of current window down ARG lines.
5490 If ARG is omitted or nil, scroll down by a near full screen.
5491 A near full screen is `next-screen-context-lines' less than a full screen.
5492 Negative ARG means scroll upward.
5493 If ARG is the atom `-', scroll upward by nearly full screen.
5494 When calling from a program, supply as argument a number, nil, or `-'. */)
5498 scroll_command (arg
, -1);
5502 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5503 doc
: /* Return the other window for \"other window scroll\" commands.
5504 If `other-window-scroll-buffer' is non-nil, a window
5505 showing that buffer is used.
5506 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5507 specifies the window. This takes precedence over
5508 `other-window-scroll-buffer'. */)
5513 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5514 && !NILP (Vminibuf_scroll_window
))
5515 window
= Vminibuf_scroll_window
;
5516 /* If buffer is specified, scroll that buffer. */
5517 else if (!NILP (Vother_window_scroll_buffer
))
5519 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5521 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5525 /* Nothing specified; look for a neighboring window on the same
5527 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5529 if (EQ (window
, selected_window
))
5530 /* That didn't get us anywhere; look for a window on another
5533 window
= Fnext_window (window
, Qnil
, Qt
);
5534 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5535 && ! EQ (window
, selected_window
));
5538 CHECK_LIVE_WINDOW (window
);
5540 if (EQ (window
, selected_window
))
5541 error ("There is no other window");
5546 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5547 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5548 A near full screen is `next-screen-context-lines' less than a full screen.
5549 The next window is the one below the current one; or the one at the top
5550 if the current one is at the bottom. Negative ARG means scroll downward.
5551 If ARG is the atom `-', scroll downward by nearly full screen.
5552 When calling from a program, supply as argument a number, nil, or `-'.
5554 If `other-window-scroll-buffer' is non-nil, scroll the window
5555 showing that buffer, popping the buffer up if necessary.
5556 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5557 specifies the window to scroll. This takes precedence over
5558 `other-window-scroll-buffer'. */)
5564 int count
= SPECPDL_INDEX ();
5566 window
= Fother_window_for_scrolling ();
5567 w
= XWINDOW (window
);
5569 /* Don't screw up if window_scroll gets an error. */
5570 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5571 ++windows_or_buffers_changed
;
5573 Fset_buffer (w
->buffer
);
5574 SET_PT (marker_position (w
->pointm
));
5577 window_scroll (window
, 1, 1, 1);
5578 else if (EQ (arg
, Qminus
))
5579 window_scroll (window
, -1, 1, 1);
5585 window_scroll (window
, XINT (arg
), 0, 1);
5588 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5589 unbind_to (count
, Qnil
);
5594 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5595 doc
: /* Scroll selected window display ARG columns left.
5596 Default for ARG is window width minus 2.
5597 Value is the total amount of leftward horizontal scrolling in
5598 effect after the change.
5599 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5600 lower bound for automatic scrolling, i.e. automatic scrolling
5601 will not scroll a window to a column less than the value returned
5602 by this function. This happens in an interactive call. */)
5604 register Lisp_Object arg
, set_minimum
;
5608 struct window
*w
= XWINDOW (selected_window
);
5611 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5613 arg
= Fprefix_numeric_value (arg
);
5615 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5616 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5618 if (!NILP (set_minimum
))
5619 w
->min_hscroll
= w
->hscroll
;
5624 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5625 doc
: /* Scroll selected window display ARG columns right.
5626 Default for ARG is window width minus 2.
5627 Value is the total amount of leftward horizontal scrolling in
5628 effect after the change.
5629 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5630 lower bound for automatic scrolling, i.e. automatic scrolling
5631 will not scroll a window to a column less than the value returned
5632 by this function. This happens in an interactive call. */)
5634 register Lisp_Object arg
, set_minimum
;
5638 struct window
*w
= XWINDOW (selected_window
);
5641 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5643 arg
= Fprefix_numeric_value (arg
);
5645 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5646 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5648 if (!NILP (set_minimum
))
5649 w
->min_hscroll
= w
->hscroll
;
5654 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5655 doc
: /* Return the window which was selected when entering the minibuffer.
5656 Returns nil, if current window is not a minibuffer window. */)
5659 if (minibuf_level
> 0
5660 && MINI_WINDOW_P (XWINDOW (selected_window
))
5661 && WINDOW_LIVE_P (minibuf_selected_window
))
5662 return minibuf_selected_window
;
5667 /* Value is the number of lines actually displayed in window W,
5668 as opposed to its height. */
5671 displayed_window_lines (w
)
5675 struct text_pos start
;
5676 int height
= window_box_height (w
);
5677 struct buffer
*old_buffer
;
5680 if (XBUFFER (w
->buffer
) != current_buffer
)
5682 old_buffer
= current_buffer
;
5683 set_buffer_internal (XBUFFER (w
->buffer
));
5688 /* In case W->start is out of the accessible range, do something
5689 reasonable. This happens in Info mode when Info-scroll-down
5690 calls (recenter -1) while W->start is 1. */
5691 if (XMARKER (w
->start
)->charpos
< BEGV
)
5692 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5693 else if (XMARKER (w
->start
)->charpos
> ZV
)
5694 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5696 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5698 start_display (&it
, w
, start
);
5699 move_it_vertically (&it
, height
);
5700 bottom_y
= line_bottom_y (&it
);
5702 /* rms: On a non-window display,
5703 the value of it.vpos at the bottom of the screen
5704 seems to be 1 larger than window_box_height (w).
5705 This kludge fixes a bug whereby (move-to-window-line -1)
5706 when ZV is on the last screen line
5707 moves to the previous screen line instead of the last one. */
5708 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5711 /* Add in empty lines at the bottom of the window. */
5712 if (bottom_y
< height
)
5714 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5715 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5719 set_buffer_internal (old_buffer
);
5725 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5726 doc
: /* Center point in window and redisplay frame.
5727 With prefix argument ARG, recenter putting point on screen line ARG
5728 relative to the current window. If ARG is negative, it counts up from the
5729 bottom of the window. (ARG should be less than the height of the window.)
5731 If ARG is omitted or nil, erase the entire frame and then redraw with point
5732 in the center of the current window. If `auto-resize-tool-bars' is set to
5733 `grow-only', this resets the tool-bar's height to the minimum height needed.
5735 Just C-u as prefix means put point in the center of the window
5736 and redisplay normally--don't erase and redraw the frame. */)
5738 register Lisp_Object arg
;
5740 struct window
*w
= XWINDOW (selected_window
);
5741 struct buffer
*buf
= XBUFFER (w
->buffer
);
5742 struct buffer
*obuf
= current_buffer
;
5744 int charpos
, bytepos
;
5746 int this_scroll_margin
;
5748 /* If redisplay is suppressed due to an error, try again. */
5749 obuf
->display_error_modiff
= 0;
5755 /* Invalidate pixel data calculated for all compositions. */
5756 for (i
= 0; i
< n_compositions
; i
++)
5757 composition_table
[i
]->font
= NULL
;
5759 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5761 Fredraw_frame (WINDOW_FRAME (w
));
5762 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5765 else if (CONSP (arg
)) /* Just C-u. */
5769 arg
= Fprefix_numeric_value (arg
);
5774 set_buffer_internal (buf
);
5776 /* Do this after making BUF current
5777 in case scroll_margin is buffer-local. */
5778 this_scroll_margin
= max (0, scroll_margin
);
5779 this_scroll_margin
= min (this_scroll_margin
,
5780 XFASTINT (w
->total_lines
) / 4);
5782 /* Handle centering on a graphical frame specially. Such frames can
5783 have variable-height lines and centering point on the basis of
5784 line counts would lead to strange effects. */
5785 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5792 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5793 start_display (&it
, w
, pt
);
5794 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5795 charpos
= IT_CHARPOS (it
);
5796 bytepos
= IT_BYTEPOS (it
);
5803 int extra_line_spacing
;
5804 int h
= window_box_height (w
);
5806 iarg
= - max (-iarg
, this_scroll_margin
);
5808 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5809 start_display (&it
, w
, pt
);
5811 /* Be sure we have the exact height of the full line containing PT. */
5812 move_it_by_lines (&it
, 0, 1);
5814 /* The amount of pixels we have to move back is the window
5815 height minus what's displayed in the line containing PT,
5816 and the lines below. */
5819 move_it_by_lines (&it
, nlines
, 1);
5821 if (it
.vpos
== nlines
)
5825 /* Last line has no newline */
5826 h
-= line_bottom_y (&it
);
5830 /* Don't reserve space for extra line spacing of last line. */
5831 extra_line_spacing
= it
.max_extra_line_spacing
;
5833 /* If we can't move down NLINES lines because we hit
5834 the end of the buffer, count in some empty lines. */
5835 if (it
.vpos
< nlines
)
5838 extra_line_spacing
= it
.extra_line_spacing
;
5839 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5844 /* Now find the new top line (starting position) of the window. */
5845 start_display (&it
, w
, pt
);
5847 move_it_vertically_backward (&it
, h
);
5849 /* If extra line spacing is present, we may move too far
5850 back. This causes the last line to be only partially
5851 visible (which triggers redisplay to recenter that line
5852 in the middle), so move forward.
5853 But ignore extra line spacing on last line, as it is not
5854 considered to be part of the visible height of the line.
5856 h
+= extra_line_spacing
;
5857 while (-it
.current_y
> h
)
5858 move_it_by_lines (&it
, 1, 1);
5860 charpos
= IT_CHARPOS (it
);
5861 bytepos
= IT_BYTEPOS (it
);
5865 struct position pos
;
5867 iarg
= max (iarg
, this_scroll_margin
);
5869 pos
= *vmotion (PT
, -iarg
, w
);
5870 charpos
= pos
.bufpos
;
5871 bytepos
= pos
.bytepos
;
5876 struct position pos
;
5877 int ht
= window_internal_height (w
);
5884 /* Don't let it get into the margin at either top or bottom. */
5885 iarg
= max (iarg
, this_scroll_margin
);
5886 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5888 pos
= *vmotion (PT
, - iarg
, w
);
5889 charpos
= pos
.bufpos
;
5890 bytepos
= pos
.bytepos
;
5893 /* Set the new window start. */
5894 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5895 w
->window_end_valid
= Qnil
;
5897 w
->optional_new_start
= Qt
;
5899 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5900 w
->start_at_line_beg
= Qt
;
5902 w
->start_at_line_beg
= Qnil
;
5904 set_buffer_internal (obuf
);
5909 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5911 doc
: /* Return the height in lines of the text display area of WINDOW.
5912 WINDOW defaults to the selected window.
5913 This doesn't include the mode-line (or header-line if any) or any
5914 partial-height lines in the text display area. */)
5918 struct window
*w
= decode_window (window
);
5919 int pixel_height
= window_box_height (w
);
5920 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5921 return make_number (line_height
);
5926 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5928 doc
: /* Position point relative to window.
5929 With no argument, position point at center of window.
5930 An argument specifies vertical position within the window;
5931 zero means top of window, negative means relative to bottom of window. */)
5935 struct window
*w
= XWINDOW (selected_window
);
5939 int this_scroll_margin
;
5942 window
= selected_window
;
5943 start
= marker_position (w
->start
);
5944 if (start
< BEGV
|| start
> ZV
)
5946 int height
= window_internal_height (w
);
5947 Fvertical_motion (make_number (- (height
/ 2)), window
);
5948 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5949 w
->start_at_line_beg
= Fbolp ();
5950 w
->force_start
= Qt
;
5953 Fgoto_char (w
->start
);
5955 lines
= displayed_window_lines (w
);
5958 this_scroll_margin
= max (0, scroll_margin
);
5959 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5963 XSETFASTINT (arg
, lines
/ 2);
5966 int iarg
= XINT (Fprefix_numeric_value (arg
));
5969 iarg
= iarg
+ lines
;
5971 #if 0 /* This code would prevent move-to-window-line from moving point
5972 to a place inside the scroll margins (which would cause the
5973 next redisplay to scroll). I wrote this code, but then concluded
5974 it is probably better not to install it. However, it is here
5975 inside #if 0 so as not to lose it. -- rms. */
5977 /* Don't let it get into the margin at either top or bottom. */
5978 iarg
= max (iarg
, this_scroll_margin
);
5979 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5982 arg
= make_number (iarg
);
5985 /* Skip past a partially visible first line. */
5987 XSETINT (arg
, XINT (arg
) + 1);
5989 return Fvertical_motion (arg
, window
);
5994 /***********************************************************************
5995 Window Configuration
5996 ***********************************************************************/
5998 struct save_window_data
6000 EMACS_INT size_from_Lisp_Vector_struct
;
6001 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6002 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
6003 Lisp_Object frame_tool_bar_lines
;
6004 Lisp_Object selected_frame
;
6005 Lisp_Object current_window
;
6006 Lisp_Object current_buffer
;
6007 Lisp_Object minibuf_scroll_window
;
6008 Lisp_Object minibuf_selected_window
;
6009 Lisp_Object root_window
;
6010 Lisp_Object focus_frame
;
6011 /* Record the values of window-min-width and window-min-height
6012 so that window sizes remain consistent with them. */
6013 Lisp_Object min_width
, min_height
;
6014 /* A vector, each of whose elements is a struct saved_window
6016 Lisp_Object saved_windows
;
6019 /* This is saved as a Lisp_Vector */
6022 /* these first two must agree with struct Lisp_Vector in lisp.h */
6023 EMACS_INT size_from_Lisp_Vector_struct
;
6024 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6027 Lisp_Object buffer
, start
, pointm
, mark
;
6028 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
6029 Lisp_Object hscroll
, min_hscroll
;
6030 Lisp_Object parent
, prev
;
6031 Lisp_Object start_at_line_beg
;
6032 Lisp_Object display_table
;
6033 Lisp_Object orig_top_line
, orig_total_lines
;
6034 Lisp_Object left_margin_cols
, right_margin_cols
;
6035 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
6036 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
6037 Lisp_Object dedicated
;
6040 #define SAVED_WINDOW_N(swv,n) \
6041 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
6043 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
6044 doc
: /* Return t if OBJECT is a window-configuration object. */)
6048 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
6051 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
6052 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
6056 register struct save_window_data
*data
;
6057 struct Lisp_Vector
*saved_windows
;
6059 CHECK_WINDOW_CONFIGURATION (config
);
6061 data
= (struct save_window_data
*) XVECTOR (config
);
6062 saved_windows
= XVECTOR (data
->saved_windows
);
6063 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6066 DEFUN ("set-window-configuration", Fset_window_configuration
,
6067 Sset_window_configuration
, 1, 1, 0,
6068 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
6069 CONFIGURATION must be a value previously returned
6070 by `current-window-configuration' (which see).
6071 If CONFIGURATION was made from a frame that is now deleted,
6072 only frame-independent values can be restored. In this case,
6073 the return value is nil. Otherwise the value is t. */)
6075 Lisp_Object configuration
;
6077 register struct save_window_data
*data
;
6078 struct Lisp_Vector
*saved_windows
;
6079 Lisp_Object new_current_buffer
;
6084 CHECK_WINDOW_CONFIGURATION (configuration
);
6086 data
= (struct save_window_data
*) XVECTOR (configuration
);
6087 saved_windows
= XVECTOR (data
->saved_windows
);
6089 new_current_buffer
= data
->current_buffer
;
6090 if (NILP (XBUFFER (new_current_buffer
)->name
))
6091 new_current_buffer
= Qnil
;
6094 if (XBUFFER (new_current_buffer
) == current_buffer
)
6095 /* The code further down "preserves point" by saving here PT in
6096 old_point and then setting it later back into PT. When the
6097 current-selected-window and the final-selected-window both show
6098 the current buffer, this suffers from the problem that the
6099 current PT is the window-point of the current-selected-window,
6100 while the final PT is the point of the final-selected-window, so
6101 this copy from one PT to the other would end up moving the
6102 window-point of the final-selected-window to the window-point of
6103 the current-selected-window. So we have to be careful which
6104 point of the current-buffer we copy into old_point. */
6105 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6106 && WINDOWP (selected_window
)
6107 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
6108 && !EQ (selected_window
, data
->current_window
))
6109 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6113 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6114 point in new_current_buffer as of the last time this buffer was
6115 used. This can be non-deterministic since it can be changed by
6116 things like jit-lock by mere temporary selection of some random
6117 window that happens to show this buffer.
6118 So if possible we want this arbitrary choice of "which point" to
6119 be the one from the to-be-selected-window so as to prevent this
6120 window's cursor from being copied from another window. */
6121 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6122 /* If current_window = selected_window, its point is in BUF_PT. */
6123 && !EQ (selected_window
, data
->current_window
))
6124 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6126 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
6129 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6132 /* If f is a dead frame, don't bother rebuilding its window tree.
6133 However, there is other stuff we should still try to do below. */
6134 if (FRAME_LIVE_P (f
))
6136 register struct window
*w
;
6137 register struct saved_window
*p
;
6138 struct window
*root_window
;
6139 struct window
**leaf_windows
;
6143 /* If the frame has been resized since this window configuration was
6144 made, we change the frame to the size specified in the
6145 configuration, restore the configuration, and then resize it
6146 back. We keep track of the prevailing height in these variables. */
6147 int previous_frame_lines
= FRAME_LINES (f
);
6148 int previous_frame_cols
= FRAME_COLS (f
);
6149 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6150 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6152 /* The mouse highlighting code could get screwed up
6153 if it runs during this. */
6156 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
6157 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
6158 change_frame_size (f
, XFASTINT (data
->frame_lines
),
6159 XFASTINT (data
->frame_cols
), 0, 0, 0);
6160 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6161 if (XFASTINT (data
->frame_menu_bar_lines
)
6162 != previous_frame_menu_bar_lines
)
6163 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
6164 #ifdef HAVE_WINDOW_SYSTEM
6165 if (XFASTINT (data
->frame_tool_bar_lines
)
6166 != previous_frame_tool_bar_lines
)
6167 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
6171 /* "Swap out" point from the selected window's buffer
6172 into the window itself. (Normally the pointm of the selected
6173 window holds garbage.) We do this now, before
6174 restoring the window contents, and prevent it from
6175 being done later on when we select a new window. */
6176 if (! NILP (XWINDOW (selected_window
)->buffer
))
6178 w
= XWINDOW (selected_window
);
6179 set_marker_both (w
->pointm
,
6181 BUF_PT (XBUFFER (w
->buffer
)),
6182 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6185 windows_or_buffers_changed
++;
6186 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6188 /* Problem: Freeing all matrices and later allocating them again
6189 is a serious redisplay flickering problem. What we would
6190 really like to do is to free only those matrices not reused
6192 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6194 = (struct window
**) alloca (count_windows (root_window
)
6195 * sizeof (struct window
*));
6196 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6198 /* Temporarily avoid any problems with windows that are smaller
6199 than they are supposed to be. */
6200 window_min_height
= 1;
6201 window_min_width
= 1;
6204 Mark all windows now on frame as "deleted".
6205 Restoring the new configuration "undeletes" any that are in it.
6207 Save their current buffers in their height fields, since we may
6208 need it later, if a buffer saved in the configuration is now
6210 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6212 for (k
= 0; k
< saved_windows
->size
; k
++)
6214 p
= SAVED_WINDOW_N (saved_windows
, k
);
6215 w
= XWINDOW (p
->window
);
6218 if (!NILP (p
->parent
))
6219 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6220 XFASTINT (p
->parent
))->window
;
6224 if (!NILP (p
->prev
))
6226 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6227 XFASTINT (p
->prev
))->window
;
6228 XWINDOW (w
->prev
)->next
= p
->window
;
6233 if (!NILP (w
->parent
))
6235 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6237 XWINDOW (w
->parent
)->vchild
= p
->window
;
6238 XWINDOW (w
->parent
)->hchild
= Qnil
;
6242 XWINDOW (w
->parent
)->hchild
= p
->window
;
6243 XWINDOW (w
->parent
)->vchild
= Qnil
;
6248 /* If we squirreled away the buffer in the window's height,
6250 if (BUFFERP (w
->total_lines
))
6251 w
->buffer
= w
->total_lines
;
6252 w
->left_col
= p
->left_col
;
6253 w
->top_line
= p
->top_line
;
6254 w
->total_cols
= p
->total_cols
;
6255 w
->total_lines
= p
->total_lines
;
6256 w
->hscroll
= p
->hscroll
;
6257 w
->min_hscroll
= p
->min_hscroll
;
6258 w
->display_table
= p
->display_table
;
6259 w
->orig_top_line
= p
->orig_top_line
;
6260 w
->orig_total_lines
= p
->orig_total_lines
;
6261 w
->left_margin_cols
= p
->left_margin_cols
;
6262 w
->right_margin_cols
= p
->right_margin_cols
;
6263 w
->left_fringe_width
= p
->left_fringe_width
;
6264 w
->right_fringe_width
= p
->right_fringe_width
;
6265 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6266 w
->scroll_bar_width
= p
->scroll_bar_width
;
6267 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6268 w
->dedicated
= p
->dedicated
;
6269 XSETFASTINT (w
->last_modified
, 0);
6270 XSETFASTINT (w
->last_overlay_modified
, 0);
6272 /* Reinstall the saved buffer and pointers into it. */
6273 if (NILP (p
->buffer
))
6274 w
->buffer
= p
->buffer
;
6277 if (!NILP (XBUFFER (p
->buffer
)->name
))
6278 /* If saved buffer is alive, install it. */
6280 w
->buffer
= p
->buffer
;
6281 w
->start_at_line_beg
= p
->start_at_line_beg
;
6282 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6283 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6284 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6285 p
->mark
, w
->buffer
);
6287 /* As documented in Fcurrent_window_configuration, don't
6288 restore the location of point in the buffer which was
6289 current when the window configuration was recorded. */
6290 if (!EQ (p
->buffer
, new_current_buffer
)
6291 && XBUFFER (p
->buffer
) == current_buffer
)
6292 Fgoto_char (w
->pointm
);
6294 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6295 /* Else unless window has a live buffer, get one. */
6297 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6298 /* This will set the markers to beginning of visible
6300 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6301 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6302 w
->start_at_line_beg
= Qt
;
6305 /* Keeping window's old buffer; make sure the markers
6308 /* Set window markers at start of visible range. */
6309 if (XMARKER (w
->start
)->buffer
== 0)
6310 set_marker_restricted (w
->start
, make_number (0),
6312 if (XMARKER (w
->pointm
)->buffer
== 0)
6313 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6314 BUF_PT (XBUFFER (w
->buffer
)),
6315 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6316 w
->start_at_line_beg
= Qt
;
6321 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6322 /* Prevent "swapping out point" in the old selected window
6323 using the buffer that has been restored into it.
6324 We already swapped out point that from that window's old buffer. */
6325 selected_window
= Qnil
;
6327 /* Arrange *not* to restore point in the buffer that was
6328 current when the window configuration was saved. */
6329 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6330 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6331 make_number (old_point
),
6332 XWINDOW (data
->current_window
)->buffer
);
6334 Fselect_window (data
->current_window
, Qnil
);
6335 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6338 if (NILP (data
->focus_frame
)
6339 || (FRAMEP (data
->focus_frame
)
6340 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6341 Fredirect_frame_focus (frame
, data
->focus_frame
);
6343 #if 0 /* I don't understand why this is needed, and it causes problems
6344 when the frame's old selected window has been deleted. */
6345 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6346 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6350 /* Set the screen height to the value it had before this function. */
6351 if (previous_frame_lines
!= FRAME_LINES (f
)
6352 || previous_frame_cols
!= FRAME_COLS (f
))
6353 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6355 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6356 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6357 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6359 #ifdef HAVE_WINDOW_SYSTEM
6360 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6361 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6366 /* Now, free glyph matrices in windows that were not reused. */
6367 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6369 if (NILP (leaf_windows
[i
]->buffer
))
6371 /* Assert it's not reused as a combination. */
6372 xassert (NILP (leaf_windows
[i
]->hchild
)
6373 && NILP (leaf_windows
[i
]->vchild
));
6374 free_window_matrices (leaf_windows
[i
]);
6376 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6384 /* Fselect_window will have made f the selected frame, so we
6385 reselect the proper frame here. Fhandle_switch_frame will change the
6386 selected window too, but that doesn't make the call to
6387 Fselect_window above totally superfluous; it still sets f's
6389 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6390 do_switch_frame (data
->selected_frame
, 0, 0);
6392 if (! NILP (Vwindow_configuration_change_hook
)
6393 && ! NILP (Vrun_hooks
))
6394 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6397 if (!NILP (new_current_buffer
))
6398 Fset_buffer (new_current_buffer
);
6400 /* Restore the minimum heights recorded in the configuration. */
6401 window_min_height
= XINT (data
->min_height
);
6402 window_min_width
= XINT (data
->min_width
);
6404 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6405 minibuf_selected_window
= data
->minibuf_selected_window
;
6407 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6410 /* Mark all windows now on frame as deleted
6411 by setting their buffers to nil. */
6414 delete_all_subwindows (w
)
6415 register struct window
*w
;
6417 if (!NILP (w
->next
))
6418 delete_all_subwindows (XWINDOW (w
->next
));
6419 if (!NILP (w
->vchild
))
6420 delete_all_subwindows (XWINDOW (w
->vchild
));
6421 if (!NILP (w
->hchild
))
6422 delete_all_subwindows (XWINDOW (w
->hchild
));
6424 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6426 if (!NILP (w
->buffer
))
6429 /* We set all three of these fields to nil, to make sure that we can
6430 distinguish this dead window from any live window. Live leaf
6431 windows will have buffer set, and combination windows will have
6432 vchild or hchild set. */
6437 Vwindow_list
= Qnil
;
6441 count_windows (window
)
6442 register struct window
*window
;
6444 register int count
= 1;
6445 if (!NILP (window
->next
))
6446 count
+= count_windows (XWINDOW (window
->next
));
6447 if (!NILP (window
->vchild
))
6448 count
+= count_windows (XWINDOW (window
->vchild
));
6449 if (!NILP (window
->hchild
))
6450 count
+= count_windows (XWINDOW (window
->hchild
));
6455 /* Fill vector FLAT with leaf windows under W, starting at index I.
6456 Value is last index + 1. */
6459 get_leaf_windows (w
, flat
, i
)
6461 struct window
**flat
;
6466 if (!NILP (w
->hchild
))
6467 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6468 else if (!NILP (w
->vchild
))
6469 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6473 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6480 /* Return a pointer to the glyph W's physical cursor is on. Value is
6481 null if W's current matrix is invalid, so that no meaningfull glyph
6485 get_phys_cursor_glyph (w
)
6488 struct glyph_row
*row
;
6489 struct glyph
*glyph
;
6491 if (w
->phys_cursor
.vpos
>= 0
6492 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6493 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6495 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6496 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6505 save_window_save (window
, vector
, i
)
6507 struct Lisp_Vector
*vector
;
6510 register struct saved_window
*p
;
6511 register struct window
*w
;
6512 register Lisp_Object tem
;
6514 for (;!NILP (window
); window
= w
->next
)
6516 p
= SAVED_WINDOW_N (vector
, i
);
6517 w
= XWINDOW (window
);
6519 XSETFASTINT (w
->temslot
, i
); i
++;
6521 p
->buffer
= w
->buffer
;
6522 p
->left_col
= w
->left_col
;
6523 p
->top_line
= w
->top_line
;
6524 p
->total_cols
= w
->total_cols
;
6525 p
->total_lines
= w
->total_lines
;
6526 p
->hscroll
= w
->hscroll
;
6527 p
->min_hscroll
= w
->min_hscroll
;
6528 p
->display_table
= w
->display_table
;
6529 p
->orig_top_line
= w
->orig_top_line
;
6530 p
->orig_total_lines
= w
->orig_total_lines
;
6531 p
->left_margin_cols
= w
->left_margin_cols
;
6532 p
->right_margin_cols
= w
->right_margin_cols
;
6533 p
->left_fringe_width
= w
->left_fringe_width
;
6534 p
->right_fringe_width
= w
->right_fringe_width
;
6535 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6536 p
->scroll_bar_width
= w
->scroll_bar_width
;
6537 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6538 p
->dedicated
= w
->dedicated
;
6539 if (!NILP (w
->buffer
))
6541 /* Save w's value of point in the window configuration.
6542 If w is the selected window, then get the value of point
6543 from the buffer; pointm is garbage in the selected window. */
6544 if (EQ (window
, selected_window
))
6546 p
->pointm
= Fmake_marker ();
6547 set_marker_both (p
->pointm
, w
->buffer
,
6548 BUF_PT (XBUFFER (w
->buffer
)),
6549 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6552 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6554 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6555 p
->start_at_line_beg
= w
->start_at_line_beg
;
6557 tem
= XBUFFER (w
->buffer
)->mark
;
6558 p
->mark
= Fcopy_marker (tem
, Qnil
);
6565 p
->start_at_line_beg
= Qnil
;
6568 if (NILP (w
->parent
))
6571 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6576 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6578 if (!NILP (w
->vchild
))
6579 i
= save_window_save (w
->vchild
, vector
, i
);
6580 if (!NILP (w
->hchild
))
6581 i
= save_window_save (w
->hchild
, vector
, i
);
6587 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6588 Scurrent_window_configuration
, 0, 1, 0,
6589 doc
: /* Return an object representing the current window configuration of FRAME.
6590 If FRAME is nil or omitted, use the selected frame.
6591 This describes the number of windows, their sizes and current buffers,
6592 and for each displayed buffer, where display starts, and the positions of
6593 point and mark. An exception is made for point in the current buffer:
6594 its value is -not- saved.
6595 This also records the currently selected frame, and FRAME's focus
6596 redirection (see `redirect-frame-focus'). */)
6600 register Lisp_Object tem
;
6601 register int n_windows
;
6602 register struct save_window_data
*data
;
6603 register struct Lisp_Vector
*vec
;
6608 frame
= selected_frame
;
6609 CHECK_LIVE_FRAME (frame
);
6612 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6613 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6614 data
= (struct save_window_data
*)vec
;
6616 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6617 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6618 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6619 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6620 data
->selected_frame
= selected_frame
;
6621 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6622 XSETBUFFER (data
->current_buffer
, current_buffer
);
6623 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6624 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6625 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6626 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6627 XSETINT (data
->min_height
, window_min_height
);
6628 XSETINT (data
->min_width
, window_min_width
);
6629 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6630 data
->saved_windows
= tem
;
6631 for (i
= 0; i
< n_windows
; i
++)
6632 XVECTOR (tem
)->contents
[i
]
6633 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6634 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6635 XSETWINDOW_CONFIGURATION (tem
, data
);
6639 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6641 doc
: /* Execute BODY, preserving window sizes and contents.
6642 Return the value of the last form in BODY.
6643 Restore which buffer appears in which window, where display starts,
6644 and the value of point and mark for each window.
6645 Also restore the choice of selected window.
6646 Also restore which buffer is current.
6647 Does not restore the value of point in current buffer.
6648 usage: (save-window-excursion BODY ...) */)
6652 register Lisp_Object val
;
6653 register int count
= SPECPDL_INDEX ();
6655 record_unwind_protect (Fset_window_configuration
,
6656 Fcurrent_window_configuration (Qnil
));
6657 val
= Fprogn (args
);
6658 return unbind_to (count
, val
);
6663 /***********************************************************************
6665 ***********************************************************************/
6671 Lisp_Object tail
= Qnil
;
6672 Lisp_Object result
= Qnil
;
6679 if (!NILP (w
->hchild
))
6680 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6681 window_tree (XWINDOW (w
->hchild
))));
6682 else if (!NILP (w
->vchild
))
6683 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6684 window_tree (XWINDOW (w
->vchild
))));
6688 result
= tail
= Fcons (wn
, Qnil
);
6692 XSETCDR (tail
, Fcons (wn
, Qnil
));
6696 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6704 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6706 doc
: /* Return the window tree for frame FRAME.
6708 The return value is a list of the form (ROOT MINI), where ROOT
6709 represents the window tree of the frame's root window, and MINI
6710 is the frame's minibuffer window.
6712 If the root window is not split, ROOT is the root window itself.
6713 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6714 horizontal split, and t for a vertical split, EDGES gives the combined
6715 size and position of the subwindows in the split, and the rest of the
6716 elements are the subwindows in the split. Each of the subwindows may
6717 again be a window or a list representing a window split, and so on.
6718 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6720 If FRAME is nil or omitted, return information on the currently
6728 frame
= selected_frame
;
6730 CHECK_FRAME (frame
);
6733 if (!FRAME_LIVE_P (f
))
6736 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6740 /***********************************************************************
6742 ***********************************************************************/
6744 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6746 doc
: /* Set width of marginal areas of window WINDOW.
6747 If WINDOW is nil, set margins of the currently selected window.
6748 Second arg LEFT-WIDTH specifies the number of character cells to
6749 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6750 does the same for the right marginal area. A nil width parameter
6751 means no margin. */)
6752 (window
, left_width
, right_width
)
6753 Lisp_Object window
, left_width
, right_width
;
6755 struct window
*w
= decode_window (window
);
6757 /* Translate negative or zero widths to nil.
6758 Margins that are too wide have to be checked elsewhere. */
6760 if (!NILP (left_width
))
6762 CHECK_NUMBER (left_width
);
6763 if (XINT (left_width
) <= 0)
6767 if (!NILP (right_width
))
6769 CHECK_NUMBER (right_width
);
6770 if (XINT (right_width
) <= 0)
6774 if (!EQ (w
->left_margin_cols
, left_width
)
6775 || !EQ (w
->right_margin_cols
, right_width
))
6777 w
->left_margin_cols
= left_width
;
6778 w
->right_margin_cols
= right_width
;
6780 adjust_window_margins (w
);
6782 ++windows_or_buffers_changed
;
6783 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6790 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6792 doc
: /* Get width of marginal areas of window WINDOW.
6793 If WINDOW is omitted or nil, use the currently selected window.
6794 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6795 If a marginal area does not exist, its width will be returned
6800 struct window
*w
= decode_window (window
);
6801 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6806 /***********************************************************************
6808 ***********************************************************************/
6810 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6812 doc
: /* Set the fringe widths of window WINDOW.
6813 If WINDOW is nil, set the fringe widths of the currently selected
6815 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6816 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6817 fringe width. If a fringe width arg is nil, that means to use the
6818 frame's default fringe width. Default fringe widths can be set with
6819 the command `set-fringe-style'.
6820 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6821 outside of the display margins. By default, fringes are drawn between
6822 display marginal areas and the text area. */)
6823 (window
, left_width
, right_width
, outside_margins
)
6824 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6826 struct window
*w
= decode_window (window
);
6828 if (!NILP (left_width
))
6829 CHECK_NATNUM (left_width
);
6830 if (!NILP (right_width
))
6831 CHECK_NATNUM (right_width
);
6833 /* Do nothing on a tty. */
6834 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6835 && (!EQ (w
->left_fringe_width
, left_width
)
6836 || !EQ (w
->right_fringe_width
, right_width
)
6837 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6839 w
->left_fringe_width
= left_width
;
6840 w
->right_fringe_width
= right_width
;
6841 w
->fringes_outside_margins
= outside_margins
;
6843 adjust_window_margins (w
);
6845 clear_glyph_matrix (w
->current_matrix
);
6846 w
->window_end_valid
= Qnil
;
6848 ++windows_or_buffers_changed
;
6849 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6856 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6858 doc
: /* Get width of fringes of window WINDOW.
6859 If WINDOW is omitted or nil, use the currently selected window.
6860 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6864 struct window
*w
= decode_window (window
);
6866 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6867 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6868 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6869 ? Qt
: Qnil
), Qnil
)));
6874 /***********************************************************************
6876 ***********************************************************************/
6878 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6880 doc
: /* Set width and type of scroll bars of window WINDOW.
6881 If window is nil, set scroll bars of the currently selected window.
6882 Second parameter WIDTH specifies the pixel width for the scroll bar;
6883 this is automatically adjusted to a multiple of the frame column width.
6884 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6885 bar: left, right, or nil.
6886 If WIDTH is nil, use the frame's scroll-bar width.
6887 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6888 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6889 (window
, width
, vertical_type
, horizontal_type
)
6890 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6892 struct window
*w
= decode_window (window
);
6896 CHECK_NATNUM (width
);
6898 if (XINT (width
) == 0)
6899 vertical_type
= Qnil
;
6902 if (!(EQ (vertical_type
, Qnil
)
6903 || EQ (vertical_type
, Qleft
)
6904 || EQ (vertical_type
, Qright
)
6905 || EQ (vertical_type
, Qt
)))
6906 error ("Invalid type of vertical scroll bar");
6908 if (!EQ (w
->scroll_bar_width
, width
)
6909 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6911 w
->scroll_bar_width
= width
;
6912 w
->vertical_scroll_bar_type
= vertical_type
;
6914 adjust_window_margins (w
);
6916 clear_glyph_matrix (w
->current_matrix
);
6917 w
->window_end_valid
= Qnil
;
6919 ++windows_or_buffers_changed
;
6920 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6927 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6929 doc
: /* Get width and type of scroll bars of window WINDOW.
6930 If WINDOW is omitted or nil, use the currently selected window.
6931 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6932 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6937 struct window
*w
= decode_window (window
);
6938 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6939 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6940 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6941 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6942 Fcons (w
->vertical_scroll_bar_type
,
6943 Fcons (Qnil
, Qnil
))));
6948 /***********************************************************************
6950 ***********************************************************************/
6952 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6953 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6954 Use the selected window if WINDOW is nil or omitted.
6955 Normally, value is a multiple of the canonical character height of WINDOW;
6956 optional second arg PIXELS-P means value is measured in pixels. */)
6958 Lisp_Object window
, pixels_p
;
6965 window
= selected_window
;
6967 CHECK_WINDOW (window
);
6968 w
= XWINDOW (window
);
6969 f
= XFRAME (w
->frame
);
6971 if (FRAME_WINDOW_P (f
))
6972 result
= (NILP (pixels_p
)
6973 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6974 : make_number (-w
->vscroll
));
6976 result
= make_number (0);
6981 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6983 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6984 WINDOW nil means use the selected window. Normally, VSCROLL is a
6985 non-negative multiple of the canonical character height of WINDOW;
6986 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6987 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6988 corresponds to an integral number of pixels. The return value is the
6989 result of this rounding.
6990 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6991 (window
, vscroll
, pixels_p
)
6992 Lisp_Object window
, vscroll
, pixels_p
;
6998 window
= selected_window
;
7000 CHECK_WINDOW (window
);
7001 CHECK_NUMBER_OR_FLOAT (vscroll
);
7003 w
= XWINDOW (window
);
7004 f
= XFRAME (w
->frame
);
7006 if (FRAME_WINDOW_P (f
))
7008 int old_dy
= w
->vscroll
;
7010 w
->vscroll
= - (NILP (pixels_p
)
7011 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
7012 : XFLOATINT (vscroll
));
7013 w
->vscroll
= min (w
->vscroll
, 0);
7015 if (w
->vscroll
!= old_dy
)
7017 /* Adjust glyph matrix of the frame if the virtual display
7018 area becomes larger than before. */
7019 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
7022 /* Prevent redisplay shortcuts. */
7023 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
7027 return Fwindow_vscroll (window
, pixels_p
);
7031 /* Call FN for all leaf windows on frame F. FN is called with the
7032 first argument being a pointer to the leaf window, and with
7033 additional argument USER_DATA. Stops when FN returns 0. */
7036 foreach_window (f
, fn
, user_data
)
7038 int (* fn
) P_ ((struct window
*, void *));
7041 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
7042 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
7043 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
7047 /* Helper function for foreach_window. Call FN for all leaf windows
7048 reachable from W. FN is called with the first argument being a
7049 pointer to the leaf window, and with additional argument USER_DATA.
7050 Stop when FN returns 0. Value is 0 if stopped by FN. */
7053 foreach_window_1 (w
, fn
, user_data
)
7055 int (* fn
) P_ ((struct window
*, void *));
7060 for (cont
= 1; w
&& cont
;)
7062 if (!NILP (w
->hchild
))
7063 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
7064 else if (!NILP (w
->vchild
))
7065 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
7067 cont
= fn (w
, user_data
);
7069 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
7076 /* Freeze or unfreeze the window start of W unless it is a
7077 mini-window or the selected window. FREEZE_P non-null means freeze
7078 the window start. */
7081 freeze_window_start (w
, freeze_p
)
7085 if (w
== XWINDOW (selected_window
)
7086 || MINI_WINDOW_P (w
)
7087 || (MINI_WINDOW_P (XWINDOW (selected_window
))
7088 && ! NILP (Vminibuf_scroll_window
)
7089 && w
== XWINDOW (Vminibuf_scroll_window
)))
7092 w
->frozen_window_start_p
= freeze_p
!= NULL
;
7097 /* Freeze or unfreeze the window starts of all leaf windows on frame
7098 F, except the selected window and a mini-window. FREEZE_P non-zero
7099 means freeze the window start. */
7102 freeze_window_starts (f
, freeze_p
)
7106 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
7110 /***********************************************************************
7112 ***********************************************************************/
7114 /* Return 1 if window configurations C1 and C2
7115 describe the same state of affairs. This is used by Fequal. */
7118 compare_window_configurations (c1
, c2
, ignore_positions
)
7120 int ignore_positions
;
7122 register struct save_window_data
*d1
, *d2
;
7123 struct Lisp_Vector
*sw1
, *sw2
;
7126 CHECK_WINDOW_CONFIGURATION (c1
);
7127 CHECK_WINDOW_CONFIGURATION (c2
);
7129 d1
= (struct save_window_data
*) XVECTOR (c1
);
7130 d2
= (struct save_window_data
*) XVECTOR (c2
);
7131 sw1
= XVECTOR (d1
->saved_windows
);
7132 sw2
= XVECTOR (d2
->saved_windows
);
7134 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
7136 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
7138 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
7140 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
7142 /* Don't compare the current_window field directly.
7143 Instead see w1_is_current and w2_is_current, below. */
7144 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
7146 if (! ignore_positions
)
7148 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
7150 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
7153 /* Don't compare the root_window field.
7154 We don't require the two configurations
7155 to use the same window object,
7156 and the two root windows must be equivalent
7157 if everything else compares equal. */
7158 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
7160 if (! EQ (d1
->min_width
, d2
->min_width
))
7162 if (! EQ (d1
->min_height
, d2
->min_height
))
7165 /* Verify that the two confis have the same number of windows. */
7166 if (sw1
->size
!= sw2
->size
)
7169 for (i
= 0; i
< sw1
->size
; i
++)
7171 struct saved_window
*p1
, *p2
;
7172 int w1_is_current
, w2_is_current
;
7174 p1
= SAVED_WINDOW_N (sw1
, i
);
7175 p2
= SAVED_WINDOW_N (sw2
, i
);
7177 /* Verify that the current windows in the two
7178 configurations correspond to each other. */
7179 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7180 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7182 if (w1_is_current
!= w2_is_current
)
7185 /* Verify that the corresponding windows do match. */
7186 if (! EQ (p1
->buffer
, p2
->buffer
))
7188 if (! EQ (p1
->left_col
, p2
->left_col
))
7190 if (! EQ (p1
->top_line
, p2
->top_line
))
7192 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7194 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7196 if (! EQ (p1
->display_table
, p2
->display_table
))
7198 if (! EQ (p1
->parent
, p2
->parent
))
7200 if (! EQ (p1
->prev
, p2
->prev
))
7202 if (! ignore_positions
)
7204 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7206 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7208 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7210 if (NILP (Fequal (p1
->start
, p2
->start
)))
7212 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7214 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7217 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7219 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7221 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7223 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7225 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7227 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7229 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7236 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7237 Scompare_window_configurations
, 2, 2, 0,
7238 doc
: /* Compare two window configurations as regards the structure of windows.
7239 This function ignores details such as the values of point and mark
7240 and scrolling positions. */)
7244 if (compare_window_configurations (x
, y
, 1))
7252 struct frame
*f
= make_initial_frame ();
7253 XSETFRAME (selected_frame
, f
);
7254 Vterminal_frame
= selected_frame
;
7255 minibuf_window
= f
->minibuffer_window
;
7256 selected_window
= f
->selected_window
;
7257 last_nonminibuf_frame
= f
;
7259 window_initialized
= 1;
7265 Vwindow_list
= Qnil
;
7271 Qscroll_up
= intern ("scroll-up");
7272 staticpro (&Qscroll_up
);
7274 Qscroll_down
= intern ("scroll-down");
7275 staticpro (&Qscroll_down
);
7277 Qwindow_size_fixed
= intern ("window-size-fixed");
7278 staticpro (&Qwindow_size_fixed
);
7279 Fset (Qwindow_size_fixed
, Qnil
);
7281 staticpro (&Qwindow_configuration_change_hook
);
7282 Qwindow_configuration_change_hook
7283 = intern ("window-configuration-change-hook");
7285 Qwindowp
= intern ("windowp");
7286 staticpro (&Qwindowp
);
7288 Qwindow_configuration_p
= intern ("window-configuration-p");
7289 staticpro (&Qwindow_configuration_p
);
7291 Qwindow_live_p
= intern ("window-live-p");
7292 staticpro (&Qwindow_live_p
);
7294 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7295 staticpro (&Qtemp_buffer_show_hook
);
7297 staticpro (&Vwindow_list
);
7299 minibuf_selected_window
= Qnil
;
7300 staticpro (&minibuf_selected_window
);
7302 window_scroll_pixel_based_preserve_y
= -1;
7304 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7305 doc
: /* Non-nil means call as function to display a help buffer.
7306 The function is called with one argument, the buffer to be displayed.
7307 Used by `with-output-to-temp-buffer'.
7308 If this function is used, then it must do the entire job of showing
7309 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7310 Vtemp_buffer_show_function
= Qnil
;
7312 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7313 doc
: /* If non-nil, function to call to handle `display-buffer'.
7314 It will receive two args, the buffer and a flag which if non-nil means
7315 that the currently selected window is not acceptable.
7316 It should choose or create a window, display the specified buffer in it,
7317 and return the window.
7318 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7319 work using this function. */);
7320 Vdisplay_buffer_function
= Qnil
;
7322 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7323 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7324 If nil, `display-buffer' will leave the window configuration alone. */);
7325 Veven_window_heights
= Qt
;
7327 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7328 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7329 Vminibuf_scroll_window
= Qnil
;
7331 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7332 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7333 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7334 is displayed in the `mode-line' face. */);
7335 mode_line_in_non_selected_windows
= 1;
7337 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7338 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7339 Vother_window_scroll_buffer
= Qnil
;
7341 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7342 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7345 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7346 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7347 auto_window_vscroll_p
= 1;
7349 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7350 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7351 If the buffer in question is already displayed in a frame, raise that frame. */);
7352 display_buffer_reuse_frames
= 0;
7354 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7355 doc
: /* Function to call to handle automatic new frame creation.
7356 It is called with no arguments and should return a newly created frame.
7358 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7359 where `pop-up-frame-alist' would hold the default frame parameters. */);
7360 Vpop_up_frame_function
= Qnil
;
7362 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7363 doc
: /* *List of buffer names that should have their own special frames.
7364 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7365 if its name is in this list, makes a special frame for it
7366 using `special-display-function'. See also `special-display-regexps'.
7368 An element of the list can be a list instead of just a string.
7369 There are two ways to use a list as an element:
7370 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7371 In the first case, the FRAME-PARAMETERS are pairs of the form
7372 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7373 In the second case, FUNCTION is called with BUFFER as the first argument,
7374 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7375 All this is done by the function found in `special-display-function'.
7377 If the specified frame parameters include (same-buffer . t), the
7378 buffer is displayed in the currently selected window. Otherwise, if
7379 they include (same-frame . t), the buffer is displayed in a new window
7380 in the currently selected frame.
7382 If this variable appears \"not to work\", because you add a name to it
7383 but that buffer still appears in the selected window, look at the
7384 values of `same-window-buffer-names' and `same-window-regexps'.
7385 Those variables take precedence over this one. */);
7386 Vspecial_display_buffer_names
= Qnil
;
7388 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7389 doc
: /* *List of regexps saying which buffers should have their own special frames.
7390 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7391 if any regexp in this list matches the buffer name, it makes a
7392 special frame for the buffer by calling `special-display-function'.
7394 An element of the list can be a list instead of just a string.
7395 There are two ways to use a list as an element:
7396 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7397 In the first case, the FRAME-PARAMETERS are pairs of the form
7398 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7399 In the second case, FUNCTION is called with BUFFER as the first argument,
7400 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7401 All this is done by the function found in `special-display-function'.
7403 If the specified frame parameters include (same-buffer . t), the
7404 buffer is displayed in the currently selected window. Otherwise, if
7405 they include (same-frame . t), the buffer is displayed in a new window
7406 in the currently selected frame.
7408 If this variable appears \"not to work\", because you add a regexp to it
7409 but the matching buffers still appear in the selected window, look at the
7410 values of `same-window-buffer-names' and `same-window-regexps'.
7411 Those variables take precedence over this one. */);
7412 Vspecial_display_regexps
= Qnil
;
7414 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7415 doc
: /* Function to call to make a new frame for a special buffer.
7416 It is called with two arguments, the buffer and optional buffer specific
7417 data, and should return a window displaying that buffer.
7418 The default value normally makes a separate frame for the buffer,
7419 using `special-display-frame-alist' to specify the frame parameters.
7420 But if the buffer specific data includes (same-buffer . t) then the
7421 buffer is displayed in the current selected window.
7422 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7423 a new window in the currently selected frame.
7425 A buffer is special if it is listed in `special-display-buffer-names'
7426 or matches a regexp in `special-display-regexps'. */);
7427 Vspecial_display_function
= Qnil
;
7429 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7430 doc
: /* *List of buffer names that should appear in the selected window.
7431 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7432 switches to it in the selected window, rather than making it appear
7433 in some other window.
7435 An element of the list can be a cons cell instead of just a string.
7436 Then the car must be a string, which specifies the buffer name.
7437 This is for compatibility with `special-display-buffer-names';
7438 the cdr of the cons cell is ignored.
7440 See also `same-window-regexps'. */);
7441 Vsame_window_buffer_names
= Qnil
;
7443 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7444 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7445 If a buffer name matches one of these regexps, then displaying it
7446 using `display-buffer' or `pop-to-buffer' switches to it
7447 in the selected window, rather than making it appear in some other window.
7449 An element of the list can be a cons cell instead of just a string.
7450 Then the car must be a string, which specifies the buffer name.
7451 This is for compatibility with `special-display-buffer-names';
7452 the cdr of the cons cell is ignored.
7454 See also `same-window-buffer-names'. */);
7455 Vsame_window_regexps
= Qnil
;
7457 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7458 doc
: /* *Non-nil means display-buffer should make new windows. */);
7461 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7462 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7463 next_screen_context_lines
= 2;
7465 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7466 doc
: /* *A window must be at least this tall to be eligible for splitting
7467 by `display-buffer'. The value is in line units.
7468 If there is only one window, it is split regardless of this value. */);
7469 split_height_threshold
= 500;
7471 DEFVAR_INT ("window-min-height", &window_min_height
,
7472 doc
: /* *Delete any window less than this tall (including its mode line).
7473 The value is in line units. */);
7474 window_min_height
= 4;
7476 DEFVAR_INT ("window-min-width", &window_min_width
,
7477 doc
: /* *Delete any window less than this wide (measured in characters). */);
7478 window_min_width
= 10;
7480 DEFVAR_LISP ("scroll-preserve-screen-position",
7481 &Vscroll_preserve_screen_position
,
7482 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7483 A value of nil means point does not keep its screen position except
7484 at the scroll margin or window boundary respectively.
7485 A value of t means point keeps its screen position if the scroll
7486 command moved it vertically out of the window, e.g. when scrolling
7488 Any other value means point always keeps its screen position. */);
7489 Vscroll_preserve_screen_position
= Qnil
;
7491 DEFVAR_LISP ("window-configuration-change-hook",
7492 &Vwindow_configuration_change_hook
,
7493 doc
: /* Functions to call when window configuration changes.
7494 The selected frame is the one whose configuration has changed. */);
7495 Vwindow_configuration_change_hook
= Qnil
;
7497 defsubr (&Sselected_window
);
7498 defsubr (&Sminibuffer_window
);
7499 defsubr (&Swindow_minibuffer_p
);
7500 defsubr (&Swindowp
);
7501 defsubr (&Swindow_live_p
);
7502 defsubr (&Spos_visible_in_window_p
);
7503 defsubr (&Swindow_line_height
);
7504 defsubr (&Swindow_buffer
);
7505 defsubr (&Swindow_height
);
7506 defsubr (&Swindow_width
);
7507 defsubr (&Swindow_hscroll
);
7508 defsubr (&Sset_window_hscroll
);
7509 defsubr (&Swindow_redisplay_end_trigger
);
7510 defsubr (&Sset_window_redisplay_end_trigger
);
7511 defsubr (&Swindow_edges
);
7512 defsubr (&Swindow_pixel_edges
);
7513 defsubr (&Swindow_inside_edges
);
7514 defsubr (&Swindow_inside_pixel_edges
);
7515 defsubr (&Scoordinates_in_window_p
);
7516 defsubr (&Swindow_at
);
7517 defsubr (&Swindow_point
);
7518 defsubr (&Swindow_start
);
7519 defsubr (&Swindow_end
);
7520 defsubr (&Sset_window_point
);
7521 defsubr (&Sset_window_start
);
7522 defsubr (&Swindow_dedicated_p
);
7523 defsubr (&Sset_window_dedicated_p
);
7524 defsubr (&Swindow_display_table
);
7525 defsubr (&Sset_window_display_table
);
7526 defsubr (&Snext_window
);
7527 defsubr (&Sprevious_window
);
7528 defsubr (&Sother_window
);
7529 defsubr (&Sget_lru_window
);
7530 defsubr (&Sget_largest_window
);
7531 defsubr (&Sget_buffer_window
);
7532 defsubr (&Sdelete_other_windows
);
7533 defsubr (&Sdelete_windows_on
);
7534 defsubr (&Sreplace_buffer_in_windows
);
7535 defsubr (&Sdelete_window
);
7536 defsubr (&Sset_window_buffer
);
7537 defsubr (&Sselect_window
);
7538 defsubr (&Sspecial_display_p
);
7539 defsubr (&Ssame_window_p
);
7540 defsubr (&Sdisplay_buffer
);
7541 defsubr (&Sforce_window_update
);
7542 defsubr (&Ssplit_window
);
7543 defsubr (&Senlarge_window
);
7544 defsubr (&Sshrink_window
);
7545 defsubr (&Sadjust_window_trailing_edge
);
7546 defsubr (&Sscroll_up
);
7547 defsubr (&Sscroll_down
);
7548 defsubr (&Sscroll_left
);
7549 defsubr (&Sscroll_right
);
7550 defsubr (&Sother_window_for_scrolling
);
7551 defsubr (&Sscroll_other_window
);
7552 defsubr (&Sminibuffer_selected_window
);
7553 defsubr (&Srecenter
);
7554 defsubr (&Swindow_text_height
);
7555 defsubr (&Smove_to_window_line
);
7556 defsubr (&Swindow_configuration_p
);
7557 defsubr (&Swindow_configuration_frame
);
7558 defsubr (&Sset_window_configuration
);
7559 defsubr (&Scurrent_window_configuration
);
7560 defsubr (&Ssave_window_excursion
);
7561 defsubr (&Swindow_tree
);
7562 defsubr (&Sset_window_margins
);
7563 defsubr (&Swindow_margins
);
7564 defsubr (&Sset_window_fringes
);
7565 defsubr (&Swindow_fringes
);
7566 defsubr (&Sset_window_scroll_bars
);
7567 defsubr (&Swindow_scroll_bars
);
7568 defsubr (&Swindow_vscroll
);
7569 defsubr (&Sset_window_vscroll
);
7570 defsubr (&Scompare_window_configurations
);
7571 defsubr (&Swindow_list
);
7577 initial_define_key (control_x_map
, '1', "delete-other-windows");
7578 initial_define_key (control_x_map
, '2', "split-window");
7579 initial_define_key (control_x_map
, '0', "delete-window");
7580 initial_define_key (control_x_map
, 'o', "other-window");
7581 initial_define_key (control_x_map
, '^', "enlarge-window");
7582 initial_define_key (control_x_map
, '<', "scroll-left");
7583 initial_define_key (control_x_map
, '>', "scroll-right");
7585 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7586 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7587 initial_define_key (meta_map
, 'v', "scroll-down");
7589 initial_define_key (global_map
, Ctl('L'), "recenter");
7590 initial_define_key (meta_map
, 'r', "move-to-window-line");
7593 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7594 (do not change this comment) */