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, 2008
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
37 #include "dispextern.h"
38 #include "blockinput.h"
39 #include "intervals.h"
40 #include "termhooks.h" /* For FRAME_TERMINAL. */
44 #endif /* HAVE_X_WINDOWS */
56 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
57 Lisp_Object Qscroll_up
, Qscroll_down
;
58 Lisp_Object Qwindow_size_fixed
;
59 extern Lisp_Object Qleft_margin
, Qright_margin
;
61 static int displayed_window_lines
P_ ((struct window
*));
62 static struct window
*decode_window
P_ ((Lisp_Object
));
63 static int count_windows
P_ ((struct window
*));
64 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
65 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
66 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
67 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
68 static int window_min_size_1
P_ ((struct window
*, int));
69 static int window_min_size_2
P_ ((struct window
*, int));
70 static int window_min_size
P_ ((struct window
*, int, int, int *));
71 static void size_window
P_ ((Lisp_Object
, int, int, int, int, int));
72 static int freeze_window_start
P_ ((struct window
*, void *));
73 static int window_fixed_size_p
P_ ((struct window
*, int, int));
74 static void enlarge_window
P_ ((Lisp_Object
, int, int));
75 static Lisp_Object window_list
P_ ((void));
76 static int add_window_to_list
P_ ((struct window
*, void *));
77 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
79 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
81 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
83 static int foreach_window_1
P_ ((struct window
*,
84 int (* fn
) (struct window
*, void *),
86 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
88 /* This is the window in which the terminal's cursor should
89 be left when nothing is being done with it. This must
90 always be a leaf window, and its buffer is selected by
91 the top level editing loop at the end of each command.
93 This value is always the same as
94 FRAME_SELECTED_WINDOW (selected_frame). */
96 Lisp_Object selected_window
;
98 /* A list of all windows for use by next_window and Fwindow_list.
99 Functions creating or deleting windows should invalidate this cache
100 by setting it to nil. */
102 Lisp_Object Vwindow_list
;
104 /* The mini-buffer window of the selected frame.
105 Note that you cannot test for mini-bufferness of an arbitrary window
106 by comparing against this; but you can test for mini-bufferness of
107 the selected window. */
109 Lisp_Object minibuf_window
;
111 /* Non-nil means it is the window whose mode line should be
112 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Non-nil means it is the window for C-M-v to scroll
117 when the mini-buffer is selected. */
119 Lisp_Object Vminibuf_scroll_window
;
121 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
123 Lisp_Object Vother_window_scroll_buffer
;
125 /* Non-nil means it's function to call to display temp buffers. */
127 Lisp_Object Vtemp_buffer_show_function
;
129 /* Non-zero means line and page scrolling on tall lines (with images)
130 does partial scrolling by modifying window-vscroll. */
132 int auto_window_vscroll_p
;
134 /* Non-zero means to use mode-line-inactive face in all windows but the
135 selected-window and the minibuffer-scroll-window when the
136 minibuffer is active. */
137 int mode_line_in_non_selected_windows
;
139 /* If a window gets smaller than either of these, it is removed. */
141 EMACS_INT window_min_height
;
142 EMACS_INT window_min_width
;
144 /* Nonzero implies Fdisplay_buffer should create windows. */
148 /* Nonzero implies make new frames for Fdisplay_buffer. */
152 /* Nonzero means reuse existing frames for displaying buffers. */
154 int display_buffer_reuse_frames
;
156 /* Non-nil means use this function instead of default */
158 Lisp_Object Vpop_up_frame_function
;
160 /* Function to call to handle Fdisplay_buffer. */
162 Lisp_Object Vdisplay_buffer_function
;
164 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
166 Lisp_Object Veven_window_heights
;
168 /* List of buffer *names* for buffers that should have their own frames. */
170 Lisp_Object Vspecial_display_buffer_names
;
172 /* List of regexps for buffer names that should have their own frames. */
174 Lisp_Object Vspecial_display_regexps
;
176 /* Function to pop up a special frame. */
178 Lisp_Object Vspecial_display_function
;
180 /* List of buffer *names* for buffers to appear in selected window. */
182 Lisp_Object Vsame_window_buffer_names
;
184 /* List of regexps for buffer names to appear in selected window. */
186 Lisp_Object Vsame_window_regexps
;
188 /* Hook run at end of temp_output_buffer_show. */
190 Lisp_Object Qtemp_buffer_show_hook
;
192 /* Fdisplay_buffer always splits the largest window
193 if that window is more than this high. */
195 EMACS_INT split_height_threshold
;
197 /* How to split windows (horizontally/vertically/hybrid). */
199 Lisp_Object Vsplit_window_preferred_function
;
201 /* Number of lines of continuity in scrolling by screenfuls. */
203 EMACS_INT next_screen_context_lines
;
205 /* Incremented for each window created. */
207 static int sequence_number
;
209 /* Nonzero after init_window_once has finished. */
211 static int window_initialized
;
213 /* Hook to run when window config changes. */
215 static Lisp_Object Qwindow_configuration_change_hook
;
216 static Lisp_Object Vwindow_configuration_change_hook
;
218 /* Non-nil means scroll commands try to put point
219 at the same screen height as previously. */
221 Lisp_Object Vscroll_preserve_screen_position
;
223 /* Incremented by 1 whenever a window is deleted. */
225 int window_deletion_count
;
227 /* Used by the function window_scroll_pixel_based */
229 static int window_scroll_pixel_based_preserve_y
;
231 #if 0 /* This isn't used anywhere. */
232 /* Nonzero means we can split a frame even if it is "unsplittable". */
233 static int inhibit_frame_unsplittable
;
236 extern EMACS_INT scroll_margin
;
238 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
240 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
241 doc
: /* Returns t if OBJECT is a window. */)
245 return WINDOWP (object
) ? Qt
: Qnil
;
248 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
249 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
253 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
260 register struct window
*p
;
262 p
= allocate_window ();
264 XSETFASTINT (p
->sequence_number
, sequence_number
);
265 XSETFASTINT (p
->left_col
, 0);
266 XSETFASTINT (p
->top_line
, 0);
267 XSETFASTINT (p
->total_lines
, 0);
268 XSETFASTINT (p
->total_cols
, 0);
269 XSETFASTINT (p
->hscroll
, 0);
270 XSETFASTINT (p
->min_hscroll
, 0);
271 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
272 p
->start
= Fmake_marker ();
273 p
->pointm
= Fmake_marker ();
274 XSETFASTINT (p
->use_time
, 0);
276 p
->display_table
= Qnil
;
278 p
->pseudo_window_p
= 0;
279 bzero (&p
->cursor
, sizeof (p
->cursor
));
280 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
281 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
282 p
->desired_matrix
= p
->current_matrix
= 0;
283 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
284 p
->phys_cursor_type
= -1;
285 p
->phys_cursor_width
= -1;
286 p
->must_be_updated_p
= 0;
287 XSETFASTINT (p
->window_end_vpos
, 0);
288 XSETFASTINT (p
->window_end_pos
, 0);
289 p
->window_end_valid
= Qnil
;
292 XSETFASTINT (p
->last_point
, 0);
293 p
->frozen_window_start_p
= 0;
294 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
295 p
->left_margin_cols
= Qnil
;
296 p
->right_margin_cols
= Qnil
;
297 p
->left_fringe_width
= Qnil
;
298 p
->right_fringe_width
= Qnil
;
299 p
->fringes_outside_margins
= Qnil
;
300 p
->scroll_bar_width
= Qnil
;
301 p
->vertical_scroll_bar_type
= Qt
;
307 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
308 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
311 return selected_window
;
314 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
315 doc
: /* Return the window used now for minibuffers.
316 If the optional argument FRAME is specified, return the minibuffer window
317 used by that frame. */)
322 frame
= selected_frame
;
323 CHECK_LIVE_FRAME (frame
);
324 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
327 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
328 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
329 WINDOW defaults to the selected window. */)
333 struct window
*w
= decode_window (window
);
334 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
338 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
339 Spos_visible_in_window_p
, 0, 3, 0,
340 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
341 Return nil if that position is scrolled vertically out of view.
342 If a character is only partially visible, nil is returned, unless the
343 optional argument PARTIALLY is non-nil.
344 If POS is only out of view because of horizontal scrolling, return non-nil.
345 If POS is t, it specifies the position of the last visible glyph in WINDOW.
346 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
348 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
349 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
350 where X and Y are the pixel coordinates relative to the top left corner
351 of the window. The remaining elements are omitted if the character after
352 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
353 off-window at the top and bottom of the row, ROWH is the height of the
354 display row, and VPOS is the row number (0-based) containing POS. */)
355 (pos
, window
, partially
)
356 Lisp_Object pos
, window
, partially
;
358 register struct window
*w
;
360 register struct buffer
*buf
;
362 Lisp_Object in_window
= Qnil
;
363 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
366 w
= decode_window (window
);
367 buf
= XBUFFER (w
->buffer
);
368 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
372 else if (!NILP (pos
))
374 CHECK_NUMBER_COERCE_MARKER (pos
);
377 else if (w
== XWINDOW (selected_window
))
380 posint
= XMARKER (w
->pointm
)->charpos
;
382 /* If position is above window start or outside buffer boundaries,
383 or if window start is out of range, position is not visible. */
385 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
386 && CHARPOS (top
) >= BUF_BEGV (buf
)
387 && CHARPOS (top
) <= BUF_ZV (buf
)
388 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
389 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
392 if (!NILP (in_window
) && !NILP (partially
))
394 Lisp_Object part
= Qnil
;
396 part
= list4 (make_number (rtop
), make_number (rbot
),
397 make_number (rowh
), make_number (vpos
));
398 in_window
= Fcons (make_number (x
),
399 Fcons (make_number (y
), part
));
405 DEFUN ("window-line-height", Fwindow_line_height
,
406 Swindow_line_height
, 0, 2, 0,
407 doc
: /* Return height in pixels of text line LINE in window WINDOW.
408 If WINDOW is nil or omitted, use selected window.
410 Return height of current line if LINE is omitted or nil. Return height of
411 header or mode line if LINE is `header-line' and `mode-line'.
412 Otherwise, LINE is a text line number starting from 0. A negative number
413 counts from the end of the window.
415 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
416 in pixels of the visible part of the line, VPOS and YPOS are the
417 vertical position in lines and pixels of the line, relative to the top
418 of the first text line, and OFFBOT is the number of off-window pixels at
419 the bottom of the text line. If there are off-window pixels at the top
420 of the (first) text line, YPOS is negative.
422 Return nil if window display is not up-to-date. In that case, use
423 `pos-visible-in-window-p' to obtain the information. */)
425 Lisp_Object line
, window
;
427 register struct window
*w
;
428 register struct buffer
*b
;
429 struct glyph_row
*row
, *end_row
;
430 int max_y
, crop
, i
, n
;
432 w
= decode_window (window
);
435 || w
->pseudo_window_p
)
438 CHECK_BUFFER (w
->buffer
);
439 b
= XBUFFER (w
->buffer
);
441 /* Fail if current matrix is not up-to-date. */
442 if (NILP (w
->window_end_valid
)
443 || current_buffer
->clip_changed
444 || current_buffer
->prevent_redisplay_optimizations_p
445 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
446 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
452 if (i
< 0 || i
>= w
->current_matrix
->nrows
453 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
455 max_y
= window_text_bottom_y (w
);
459 if (EQ (line
, Qheader_line
))
461 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
463 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
466 return list4 (make_number (row
->height
),
467 make_number (0), make_number (0),
471 if (EQ (line
, Qmode_line
))
473 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
476 return list4 (make_number (row
->height
),
477 make_number (0), /* not accurate */
478 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
479 + window_text_bottom_y (w
)),
486 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
487 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
488 max_y
= window_text_bottom_y (w
);
491 while ((n
< 0 || i
< n
)
492 && row
<= end_row
&& row
->enabled_p
493 && row
->y
+ row
->height
< max_y
)
496 if (row
> end_row
|| !row
->enabled_p
)
508 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
509 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
511 make_number (row
->y
),
517 static struct window
*
518 decode_window (window
)
519 register Lisp_Object window
;
522 return XWINDOW (selected_window
);
524 CHECK_LIVE_WINDOW (window
);
525 return XWINDOW (window
);
528 static struct window
*
529 decode_any_window (window
)
530 register Lisp_Object window
;
533 return XWINDOW (selected_window
);
535 CHECK_WINDOW (window
);
536 return XWINDOW (window
);
539 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
540 doc
: /* Return the buffer that WINDOW is displaying.
541 WINDOW defaults to the selected window. */)
545 return decode_window (window
)->buffer
;
548 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
549 doc
: /* Return the number of lines in WINDOW (including its mode line).
550 WINDOW defaults to the selected window. */)
554 return decode_any_window (window
)->total_lines
;
557 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
558 doc
: /* Return the number of display columns in WINDOW.
559 This is the width that is usable columns available for text in WINDOW.
560 If you want to find out how many columns WINDOW takes up,
561 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
565 return make_number (window_box_text_cols (decode_any_window (window
)));
568 DEFUN ("window-full-width-p", Fwindow_full_width_p
, Swindow_full_width_p
, 0, 1, 0,
569 doc
: /* Return t if WINDOW is as wide as its frame.
570 WINDOW defaults to the selected window. */)
574 return WINDOW_FULL_WIDTH_P (decode_any_window (window
)) ? Qt
: Qnil
;
577 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
578 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
579 WINDOW defaults to the selected window. */)
583 return decode_window (window
)->hscroll
;
586 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
587 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
588 Return NCOL. NCOL should be zero or positive.
590 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
591 window so that the location of point moves off-window. */)
593 Lisp_Object window
, ncol
;
595 struct window
*w
= decode_window (window
);
599 hscroll
= max (0, XINT (ncol
));
601 /* Prevent redisplay shortcuts when changing the hscroll. */
602 if (XINT (w
->hscroll
) != hscroll
)
603 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
605 w
->hscroll
= make_number (hscroll
);
609 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
610 Swindow_redisplay_end_trigger
, 0, 1, 0,
611 doc
: /* Return WINDOW's redisplay end trigger value.
612 WINDOW defaults to the selected window.
613 See `set-window-redisplay-end-trigger' for more information. */)
617 return decode_window (window
)->redisplay_end_trigger
;
620 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
621 Sset_window_redisplay_end_trigger
, 2, 2, 0,
622 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
623 VALUE should be a buffer position (typically a marker) or nil.
624 If it is a buffer position, then if redisplay in WINDOW reaches a position
625 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
626 with two arguments: WINDOW, and the end trigger value.
627 Afterwards the end-trigger value is reset to nil. */)
629 register Lisp_Object window
, value
;
631 register struct window
*w
;
633 w
= decode_window (window
);
634 w
->redisplay_end_trigger
= value
;
638 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
639 doc
: /* Return a list of the edge coordinates of WINDOW.
640 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
641 RIGHT is one more than the rightmost column occupied by WINDOW,
642 and BOTTOM is one more than the bottommost row occupied by WINDOW.
643 The edges include the space used by the window's scroll bar,
644 display margins, fringes, header line, and mode line, if it has them.
645 To get the edges of the actual text area, use `window-inside-edges'. */)
649 register struct window
*w
= decode_any_window (window
);
651 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
652 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
653 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
654 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
658 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
659 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
660 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
661 RIGHT is one more than the rightmost x position occupied by WINDOW,
662 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
663 The pixel edges include the space used by the window's scroll bar,
664 display margins, fringes, header line, and mode line, if it has them.
665 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
669 register struct window
*w
= decode_any_window (window
);
671 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
672 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
673 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
674 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
678 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
679 doc
: /* Return a list of the edge coordinates of WINDOW.
680 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
681 RIGHT is one more than the rightmost column used by text in WINDOW,
682 and BOTTOM is one more than the bottommost row used by text in WINDOW.
683 The inside edges do not include the space used by the window's scroll bar,
684 display margins, fringes, header line, and/or mode line. */)
688 register struct window
*w
= decode_any_window (window
);
690 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
691 + WINDOW_LEFT_MARGIN_COLS (w
)
692 + WINDOW_LEFT_FRINGE_COLS (w
)),
693 make_number (WINDOW_TOP_EDGE_LINE (w
)
694 + WINDOW_HEADER_LINE_LINES (w
)),
695 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
696 - WINDOW_RIGHT_MARGIN_COLS (w
)
697 - WINDOW_RIGHT_FRINGE_COLS (w
)),
698 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
699 - WINDOW_MODE_LINE_LINES (w
)));
702 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
703 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
704 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
705 RIGHT is one more than the rightmost x position used by text in WINDOW,
706 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
707 The inside edges do not include the space used by the window's scroll bar,
708 display margins, fringes, header line, and/or mode line. */)
712 register struct window
*w
= decode_any_window (window
);
714 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
715 + WINDOW_LEFT_MARGIN_WIDTH (w
)
716 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
717 make_number (WINDOW_TOP_EDGE_Y (w
)
718 + WINDOW_HEADER_LINE_HEIGHT (w
)),
719 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
720 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
721 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
722 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
723 - WINDOW_MODE_LINE_HEIGHT (w
)));
726 /* Test if the character at column *X, row *Y is within window W.
727 If it is not, return ON_NOTHING;
728 if it is in the window's text area,
729 set *x and *y to its location relative to the upper left corner
732 if it is on the window's modeline, return ON_MODE_LINE;
733 if it is on the border between the window and its right sibling,
734 return ON_VERTICAL_BORDER.
735 if it is on a scroll bar,
736 return ON_SCROLL_BAR.
737 if it is on the window's top line, return ON_HEADER_LINE;
738 if it is in left or right fringe of the window,
739 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
740 to window-relative coordinates;
741 if it is in the marginal area to the left/right of the window,
742 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
743 to window-relative coordinates.
745 X and Y are frame relative pixel coordinates. */
747 static enum window_part
748 coordinates_in_window (w
, x
, y
)
749 register struct window
*w
;
752 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
753 int left_x
, right_x
, top_y
, bottom_y
;
754 enum window_part part
;
755 int ux
= FRAME_COLUMN_WIDTH (f
);
756 int x0
= WINDOW_LEFT_EDGE_X (w
);
757 int x1
= WINDOW_RIGHT_EDGE_X (w
);
758 /* The width of the area where the vertical line can be dragged.
759 (Between mode lines for instance. */
760 int grabbable_width
= ux
;
761 int lmargin_width
, rmargin_width
, text_left
, text_right
;
763 /* In what's below, we subtract 1 when computing right_x because we
764 want the rightmost pixel, which is given by left_pixel+width-1. */
765 if (w
->pseudo_window_p
)
768 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
769 top_y
= WINDOW_TOP_EDGE_Y (w
);
770 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
774 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
775 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
776 top_y
= WINDOW_TOP_EDGE_Y (w
);
777 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
780 /* Outside any interesting row? */
781 if (*y
< top_y
|| *y
>= bottom_y
)
784 /* On the mode line or header line? If it's near the start of
785 the mode or header line of window that's has a horizontal
786 sibling, say it's on the vertical line. That's to be able
787 to resize windows horizontally in case we're using toolkit
790 if (WINDOW_WANTS_MODELINE_P (w
)
791 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
795 header_vertical_border_check
:
796 /* We're somewhere on the mode line. We consider the place
797 between mode lines of horizontally adjacent mode lines
798 as the vertical border. If scroll bars on the left,
799 return the right window. */
800 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
801 || WINDOW_RIGHTMOST_P (w
))
803 if (!WINDOW_LEFTMOST_P (w
) && eabs (*x
- x0
) < grabbable_width
)
805 /* Convert X and Y to window relative coordinates.
806 Vertical border is at the left edge of window. */
807 *x
= max (0, *x
- x0
);
809 return ON_VERTICAL_BORDER
;
814 if (eabs (*x
- x1
) < grabbable_width
)
816 /* Convert X and Y to window relative coordinates.
817 Vertical border is at the right edge of window. */
818 *x
= min (x1
, *x
) - x0
;
820 return ON_VERTICAL_BORDER
;
824 if (*x
< x0
|| *x
>= x1
)
827 /* Convert X and Y to window relative coordinates.
828 Mode line starts at left edge of window. */
834 if (WINDOW_WANTS_HEADER_LINE_P (w
)
835 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
837 part
= ON_HEADER_LINE
;
838 goto header_vertical_border_check
;
841 if (*x
< x0
|| *x
>= x1
)
844 /* Outside any interesting column? */
845 if (*x
< left_x
|| *x
> right_x
)
848 return ON_SCROLL_BAR
;
851 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
852 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
854 text_left
= window_box_left (w
, TEXT_AREA
);
855 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
857 if (FRAME_WINDOW_P (f
))
859 if (!w
->pseudo_window_p
860 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
861 && !WINDOW_RIGHTMOST_P (w
)
862 && (eabs (*x
- right_x
) < grabbable_width
))
864 /* Convert X and Y to window relative coordinates.
865 Vertical border is at the right edge of window. */
866 *x
= min (right_x
, *x
) - left_x
;
868 return ON_VERTICAL_BORDER
;
873 /* Need to say "*x > right_x" rather than >=, since on character
874 terminals, the vertical line's x coordinate is right_x. */
875 if (!w
->pseudo_window_p
876 && !WINDOW_RIGHTMOST_P (w
)
877 && *x
> right_x
- ux
)
879 /* On the border on the right side of the window? Assume that
880 this area begins at RIGHT_X minus a canonical char width. */
881 *x
= min (right_x
, *x
) - left_x
;
883 return ON_VERTICAL_BORDER
;
889 if (lmargin_width
> 0
890 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
891 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
892 : (*x
< left_x
+ lmargin_width
)))
895 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
896 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
898 return ON_LEFT_MARGIN
;
901 /* Convert X and Y to window-relative pixel coordinates. */
904 return ON_LEFT_FRINGE
;
907 if (*x
>= text_right
)
909 if (rmargin_width
> 0
910 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
911 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
912 : (*x
>= right_x
- rmargin_width
)))
914 *x
-= right_x
- rmargin_width
;
915 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
916 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
918 return ON_RIGHT_MARGIN
;
921 /* Convert X and Y to window-relative pixel coordinates. */
922 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
924 return ON_RIGHT_FRINGE
;
927 /* Everything special ruled out - must be on text area */
934 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
935 Scoordinates_in_window_p
, 2, 2, 0,
936 doc
: /* Return non-nil if COORDINATES are in WINDOW.
937 COORDINATES is a cons of the form (X . Y), X and Y being distances
938 measured in characters from the upper-left corner of the frame.
939 \(0 . 0) denotes the character in the upper left corner of the
941 If COORDINATES are in the text portion of WINDOW,
942 the coordinates relative to the window are returned.
943 If they are in the mode line of WINDOW, `mode-line' is returned.
944 If they are in the top mode line of WINDOW, `header-line' is returned.
945 If they are in the left fringe of WINDOW, `left-fringe' is returned.
946 If they are in the right fringe of WINDOW, `right-fringe' is returned.
947 If they are on the border between WINDOW and its right sibling,
948 `vertical-line' is returned.
949 If they are in the windows's left or right marginal areas, `left-margin'\n\
950 or `right-margin' is returned. */)
951 (coordinates
, window
)
952 register Lisp_Object coordinates
, window
;
959 CHECK_WINDOW (window
);
960 w
= XWINDOW (window
);
961 f
= XFRAME (w
->frame
);
962 CHECK_CONS (coordinates
);
963 lx
= Fcar (coordinates
);
964 ly
= Fcdr (coordinates
);
965 CHECK_NUMBER_OR_FLOAT (lx
);
966 CHECK_NUMBER_OR_FLOAT (ly
);
967 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
968 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
970 switch (coordinates_in_window (w
, &x
, &y
))
976 /* X and Y are now window relative pixel coordinates. Convert
977 them to canonical char units before returning them. */
978 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
979 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
984 case ON_VERTICAL_BORDER
:
985 return Qvertical_line
;
993 case ON_RIGHT_FRINGE
:
994 return Qright_fringe
;
999 case ON_RIGHT_MARGIN
:
1000 return Qright_margin
;
1003 /* Historically we are supposed to return nil in this case. */
1012 /* Callback for foreach_window, used in window_from_coordinates.
1013 Check if window W contains coordinates specified by USER_DATA which
1014 is actually a pointer to a struct check_window_data CW.
1016 Check if window W contains coordinates *CW->x and *CW->y. If it
1017 does, return W in *CW->window, as Lisp_Object, and return in
1018 *CW->part the part of the window under coordinates *X,*Y. Return
1019 zero from this function to stop iterating over windows. */
1021 struct check_window_data
1023 Lisp_Object
*window
;
1025 enum window_part
*part
;
1029 check_window_containing (w
, user_data
)
1033 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1034 enum window_part found
;
1037 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1038 if (found
!= ON_NOTHING
)
1041 XSETWINDOW (*cw
->window
, w
);
1049 /* Find the window containing frame-relative pixel position X/Y and
1050 return it as a Lisp_Object.
1052 If X, Y is on one of the window's special `window_part' elements,
1053 set *PART to the id of that element, and return X and Y converted
1054 to window relative coordinates in WX and WY.
1056 If there is no window under X, Y return nil and leave *PART
1057 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1059 This function was previously implemented with a loop cycling over
1060 windows with Fnext_window, and starting with the frame's selected
1061 window. It turned out that this doesn't work with an
1062 implementation of next_window using Vwindow_list, because
1063 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1064 tree of F when this function is called asynchronously from
1065 note_mouse_highlight. The original loop didn't terminate in this
1069 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
1072 enum window_part
*part
;
1077 struct check_window_data cw
;
1078 enum window_part dummy
;
1084 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1085 foreach_window (f
, check_window_containing
, &cw
);
1087 /* If not found above, see if it's in the tool bar window, if a tool
1091 && WINDOWP (f
->tool_bar_window
)
1092 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1093 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1097 window
= f
->tool_bar_window
;
1106 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1107 doc
: /* Return window containing coordinates X and Y on FRAME.
1108 If omitted, FRAME defaults to the currently selected frame.
1109 The top left corner of the frame is considered to be row 0,
1112 Lisp_Object x
, y
, frame
;
1117 frame
= selected_frame
;
1118 CHECK_LIVE_FRAME (frame
);
1121 /* Check that arguments are integers or floats. */
1122 CHECK_NUMBER_OR_FLOAT (x
);
1123 CHECK_NUMBER_OR_FLOAT (y
);
1125 return window_from_coordinates (f
,
1126 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1127 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1128 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1129 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1133 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1134 doc
: /* Return current value of point in WINDOW.
1135 WINDOW defaults to the selected window.
1137 For a nonselected window, this is the value point would have
1138 if that window were selected.
1140 Note that, when WINDOW is the selected window and its buffer
1141 is also currently selected, the value returned is the same as (point).
1142 It would be more strictly correct to return the `top-level' value
1143 of point, outside of any save-excursion forms.
1144 But that is hard to define. */)
1148 register struct window
*w
= decode_window (window
);
1150 if (w
== XWINDOW (selected_window
)
1151 && current_buffer
== XBUFFER (w
->buffer
))
1153 return Fmarker_position (w
->pointm
);
1156 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1157 doc
: /* Return position at which display currently starts in WINDOW.
1158 WINDOW defaults to the selected window.
1159 This is updated by redisplay or by calling `set-window-start'. */)
1163 return Fmarker_position (decode_window (window
)->start
);
1166 /* This is text temporarily removed from the doc string below.
1168 This function returns nil if the position is not currently known.
1169 That happens when redisplay is preempted and doesn't finish.
1170 If in that case you want to compute where the end of the window would
1171 have been if redisplay had finished, do this:
1173 (goto-char (window-start window))
1174 (vertical-motion (1- (window-height window)) window)
1177 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1178 doc
: /* Return position at which display currently ends in WINDOW.
1179 WINDOW defaults to the selected window.
1180 This is updated by redisplay, when it runs to completion.
1181 Simply changing the buffer text or setting `window-start'
1182 does not update this value.
1183 Return nil if there is no recorded value. \(This can happen if the
1184 last redisplay of WINDOW was preempted, and did not finish.)
1185 If UPDATE is non-nil, compute the up-to-date position
1186 if it isn't already recorded. */)
1188 Lisp_Object window
, update
;
1191 struct window
*w
= decode_window (window
);
1199 #if 0 /* This change broke some things. We should make it later. */
1200 /* If we don't know the end position, return nil.
1201 The user can compute it with vertical-motion if he wants to.
1202 It would be nicer to do it automatically,
1203 but that's so slow that it would probably bother people. */
1204 if (NILP (w
->window_end_valid
))
1209 && ! (! NILP (w
->window_end_valid
)
1210 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1211 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1214 struct text_pos startp
;
1216 struct buffer
*old_buffer
= NULL
;
1218 /* Cannot use Fvertical_motion because that function doesn't
1219 cope with variable-height lines. */
1220 if (b
!= current_buffer
)
1222 old_buffer
= current_buffer
;
1223 set_buffer_internal (b
);
1226 /* In case W->start is out of the range, use something
1227 reasonable. This situation occurred when loading a file with
1228 `-l' containing a call to `rmail' with subsequent other
1229 commands. At the end, W->start happened to be BEG, while
1230 rmail had already narrowed the buffer. */
1231 if (XMARKER (w
->start
)->charpos
< BEGV
)
1232 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1233 else if (XMARKER (w
->start
)->charpos
> ZV
)
1234 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1236 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1238 start_display (&it
, w
, startp
);
1239 move_it_vertically (&it
, window_box_height (w
));
1240 if (it
.current_y
< it
.last_visible_y
)
1241 move_it_past_eol (&it
);
1242 value
= make_number (IT_CHARPOS (it
));
1245 set_buffer_internal (old_buffer
);
1248 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1253 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1254 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1257 Lisp_Object window
, pos
;
1259 register struct window
*w
= decode_window (window
);
1261 CHECK_NUMBER_COERCE_MARKER (pos
);
1262 if (w
== XWINDOW (selected_window
)
1263 && XBUFFER (w
->buffer
) == current_buffer
)
1266 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1268 /* We have to make sure that redisplay updates the window to show
1269 the new value of point. */
1270 if (!EQ (window
, selected_window
))
1271 ++windows_or_buffers_changed
;
1276 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1277 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1279 Optional third arg NOFORCE non-nil inhibits next redisplay
1280 from overriding motion of point in order to display at this exact start. */)
1281 (window
, pos
, noforce
)
1282 Lisp_Object window
, pos
, noforce
;
1284 register struct window
*w
= decode_window (window
);
1286 CHECK_NUMBER_COERCE_MARKER (pos
);
1287 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1288 /* this is not right, but much easier than doing what is right. */
1289 w
->start_at_line_beg
= Qnil
;
1291 w
->force_start
= Qt
;
1292 w
->update_mode_line
= Qt
;
1293 XSETFASTINT (w
->last_modified
, 0);
1294 XSETFASTINT (w
->last_overlay_modified
, 0);
1295 if (!EQ (window
, selected_window
))
1296 windows_or_buffers_changed
++;
1301 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1303 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1304 See also `set-window-dedicated-p'. */)
1308 return decode_window (window
)->dedicated
;
1311 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1312 Sset_window_dedicated_p
, 2, 2, 0,
1313 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1314 If it is dedicated, Emacs will not automatically change
1315 which buffer appears in it.
1316 The second argument is the new value for the dedication flag;
1317 non-nil means yes. */)
1319 Lisp_Object window
, arg
;
1321 register struct window
*w
= decode_window (window
);
1325 return w
->dedicated
;
1328 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1330 doc
: /* Return the display-table that WINDOW is using.
1331 WINDOW defaults to the selected window. */)
1335 return decode_window (window
)->display_table
;
1338 /* Get the display table for use on window W. This is either W's
1339 display table or W's buffer's display table. Ignore the specified
1340 tables if they are not valid; if no valid table is specified,
1343 struct Lisp_Char_Table
*
1344 window_display_table (w
)
1347 struct Lisp_Char_Table
*dp
= NULL
;
1349 if (DISP_TABLE_P (w
->display_table
))
1350 dp
= XCHAR_TABLE (w
->display_table
);
1351 else if (BUFFERP (w
->buffer
))
1353 struct buffer
*b
= XBUFFER (w
->buffer
);
1355 if (DISP_TABLE_P (b
->display_table
))
1356 dp
= XCHAR_TABLE (b
->display_table
);
1357 else if (DISP_TABLE_P (Vstandard_display_table
))
1358 dp
= XCHAR_TABLE (Vstandard_display_table
);
1364 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1365 doc
: /* Set WINDOW's display-table to TABLE. */)
1367 register Lisp_Object window
, table
;
1369 register struct window
*w
;
1371 w
= decode_window (window
);
1372 w
->display_table
= table
;
1376 /* Record info on buffer window w is displaying
1377 when it is about to cease to display that buffer. */
1380 register struct window
*w
;
1387 if (b
!= XMARKER (w
->pointm
)->buffer
)
1391 if (w
== XWINDOW (selected_window
)
1392 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1393 /* Do this except when the selected window's buffer
1394 is being removed from some other window. */
1396 /* last_window_start records the start position that this buffer
1397 had in the last window to be disconnected from it.
1398 Now that this statement is unconditional,
1399 it is possible for the buffer to be displayed in the
1400 selected window, while last_window_start reflects another
1401 window which was recently showing the same buffer.
1402 Some people might say that might be a good thing. Let's see. */
1403 b
->last_window_start
= marker_position (w
->start
);
1405 /* Point in the selected window's buffer
1406 is actually stored in that buffer, and the window's pointm isn't used.
1407 So don't clobber point in that buffer. */
1408 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1409 /* This line helps to fix Horsley's testbug.el bug. */
1410 && !(WINDOWP (b
->last_selected_window
)
1411 && w
!= XWINDOW (b
->last_selected_window
)
1412 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1413 temp_set_point_both (b
,
1414 clip_to_bounds (BUF_BEGV (b
),
1415 XMARKER (w
->pointm
)->charpos
,
1417 clip_to_bounds (BUF_BEGV_BYTE (b
),
1418 marker_byte_position (w
->pointm
),
1421 if (WINDOWP (b
->last_selected_window
)
1422 && w
== XWINDOW (b
->last_selected_window
))
1423 b
->last_selected_window
= Qnil
;
1426 /* Put replacement into the window structure in place of old. */
1428 replace_window (old
, replacement
)
1429 Lisp_Object old
, replacement
;
1431 register Lisp_Object tem
;
1432 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1434 /* If OLD is its frame's root_window, then replacement is the new
1435 root_window for that frame. */
1437 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1438 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1440 p
->left_col
= o
->left_col
;
1441 p
->top_line
= o
->top_line
;
1442 p
->total_cols
= o
->total_cols
;
1443 p
->total_lines
= o
->total_lines
;
1444 p
->desired_matrix
= p
->current_matrix
= 0;
1446 bzero (&p
->cursor
, sizeof (p
->cursor
));
1447 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1448 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1449 p
->phys_cursor_type
= -1;
1450 p
->phys_cursor_width
= -1;
1451 p
->must_be_updated_p
= 0;
1452 p
->pseudo_window_p
= 0;
1453 XSETFASTINT (p
->window_end_vpos
, 0);
1454 XSETFASTINT (p
->window_end_pos
, 0);
1455 p
->window_end_valid
= Qnil
;
1456 p
->frozen_window_start_p
= 0;
1457 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1459 p
->next
= tem
= o
->next
;
1461 XWINDOW (tem
)->prev
= replacement
;
1463 p
->prev
= tem
= o
->prev
;
1465 XWINDOW (tem
)->next
= replacement
;
1467 p
->parent
= tem
= o
->parent
;
1470 if (EQ (XWINDOW (tem
)->vchild
, old
))
1471 XWINDOW (tem
)->vchild
= replacement
;
1472 if (EQ (XWINDOW (tem
)->hchild
, old
))
1473 XWINDOW (tem
)->hchild
= replacement
;
1476 /*** Here, if replacement is a vertical combination
1477 and so is its new parent, we should make replacement's
1478 children be children of that parent instead. ***/
1481 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1482 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1484 register Lisp_Object window
;
1488 window
= selected_window
;
1489 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1490 delete_window (window
);
1492 run_window_configuration_change_hook (f
);
1498 delete_window (window
)
1499 register Lisp_Object window
;
1501 register Lisp_Object tem
, parent
, sib
;
1502 register struct window
*p
;
1503 register struct window
*par
;
1506 /* Because this function is called by other C code on non-leaf
1507 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1508 so we can't decode_window here. */
1509 CHECK_WINDOW (window
);
1510 p
= XWINDOW (window
);
1512 /* It's a no-op to delete an already-deleted window. */
1513 if (NILP (p
->buffer
)
1515 && NILP (p
->vchild
))
1520 error ("Attempt to delete minibuffer or sole ordinary window");
1521 par
= XWINDOW (parent
);
1523 windows_or_buffers_changed
++;
1524 Vwindow_list
= Qnil
;
1525 f
= XFRAME (WINDOW_FRAME (p
));
1526 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1528 /* Are we trying to delete any frame's selected window? */
1530 Lisp_Object swindow
, pwindow
;
1532 /* See if the frame's selected window is either WINDOW
1533 or any subwindow of it, by finding all that window's parents
1534 and comparing each one with WINDOW. */
1535 swindow
= FRAME_SELECTED_WINDOW (f
);
1540 while (!NILP (pwindow
))
1542 if (EQ (window
, pwindow
))
1544 pwindow
= XWINDOW (pwindow
)->parent
;
1547 /* If the window being deleted is not a parent of SWINDOW,
1548 then SWINDOW is ok as the new selected window. */
1549 if (!EQ (window
, pwindow
))
1551 /* Otherwise, try another window for SWINDOW. */
1552 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);
1554 /* If we get back to the frame's selected window,
1555 it means there was no acceptable alternative,
1556 so we cannot delete. */
1557 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1558 error ("Cannot delete window");
1561 /* If we need to change SWINDOW, do it. */
1562 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1564 /* If we're about to delete the selected window on the
1565 selected frame, then we should use Fselect_window to select
1566 the new window. On the other hand, if we're about to
1567 delete the selected window on any other frame, we shouldn't do
1568 anything but set the frame's selected_window slot. */
1569 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1570 Fselect_window (swindow
, Qnil
);
1572 FRAME_SELECTED_WINDOW (f
) = swindow
;
1576 /* Now we know we can delete this one. */
1577 window_deletion_count
++;
1580 /* tem is null for dummy parent windows
1581 (which have inferiors but not any contents themselves) */
1585 unchain_marker (XMARKER (p
->pointm
));
1586 unchain_marker (XMARKER (p
->start
));
1589 /* Free window glyph matrices. It is sure that they are allocated
1590 again when ADJUST_GLYPHS is called. Block input so that expose
1591 events and other events that access glyph matrices are not
1592 processed while we are changing them. */
1594 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1598 XWINDOW (tem
)->prev
= p
->prev
;
1602 XWINDOW (tem
)->next
= p
->next
;
1604 if (EQ (window
, par
->hchild
))
1605 par
->hchild
= p
->next
;
1606 if (EQ (window
, par
->vchild
))
1607 par
->vchild
= p
->next
;
1609 /* Find one of our siblings to give our space to. */
1613 /* If p gives its space to its next sibling, that sibling needs
1614 to have its top/left side pulled back to where p's is.
1615 set_window_{height,width} will re-position the sibling's
1618 XWINDOW (sib
)->top_line
= p
->top_line
;
1619 XWINDOW (sib
)->left_col
= p
->left_col
;
1622 /* Stretch that sibling. */
1623 if (!NILP (par
->vchild
))
1624 set_window_height (sib
,
1625 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1627 if (!NILP (par
->hchild
))
1628 set_window_width (sib
,
1629 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1632 /* If parent now has only one child,
1633 put the child into the parent's place. */
1637 if (NILP (XWINDOW (tem
)->next
)) {
1638 replace_window (parent
, tem
);
1639 par
= XWINDOW (tem
);
1642 /* Since we may be deleting combination windows, we must make sure that
1643 not only p but all its children have been marked as deleted. */
1644 if (! NILP (p
->hchild
))
1645 delete_all_subwindows (XWINDOW (p
->hchild
));
1646 else if (! NILP (p
->vchild
))
1647 delete_all_subwindows (XWINDOW (p
->vchild
));
1649 /* Mark this window as deleted. */
1650 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1652 if (! NILP (par
->parent
))
1653 par
= XWINDOW (par
->parent
);
1655 /* Check if we have a v/hchild with a v/hchild. In that case remove
1658 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1660 p
= XWINDOW (par
->vchild
);
1661 par
->vchild
= p
->vchild
;
1664 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1666 p
= XWINDOW (par
->hchild
);
1667 par
->hchild
= p
->hchild
;
1675 while (! NILP (tem
)) {
1676 XWINDOW (tem
)->parent
= p
->parent
;
1677 if (NILP (XWINDOW (tem
)->next
))
1679 tem
= XWINDOW (tem
)->next
;
1682 /* The next of the v/hchild we are removing is now the next of the
1683 last child for the v/hchild:
1684 Before v/hchild -> v/hchild -> next1 -> next2
1687 After: v/hchild -> next1 -> next2 -> next3
1689 XWINDOW (tem
)->next
= p
->next
;
1690 if (! NILP (p
->next
))
1691 XWINDOW (p
->next
)->prev
= tem
;
1693 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1697 /* Adjust glyph matrices. */
1704 /***********************************************************************
1706 ***********************************************************************/
1708 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1709 pointer. This is a callback function for foreach_window, used in
1710 function window_list. */
1713 add_window_to_list (w
, user_data
)
1717 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1719 XSETWINDOW (window
, w
);
1720 *list
= Fcons (window
, *list
);
1725 /* Return a list of all windows, for use by next_window. If
1726 Vwindow_list is a list, return that list. Otherwise, build a new
1727 list, cache it in Vwindow_list, and return that. */
1732 if (!CONSP (Vwindow_list
))
1736 Vwindow_list
= Qnil
;
1737 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1739 Lisp_Object args
[2];
1741 /* We are visiting windows in canonical order, and add
1742 new windows at the front of args[1], which means we
1743 have to reverse this list at the end. */
1745 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1746 args
[0] = Vwindow_list
;
1747 args
[1] = Fnreverse (args
[1]);
1748 Vwindow_list
= Fnconc (2, args
);
1752 return Vwindow_list
;
1756 /* Value is non-zero if WINDOW satisfies the constraints given by
1757 OWINDOW, MINIBUF and ALL_FRAMES.
1759 MINIBUF t means WINDOW may be minibuffer windows.
1760 `lambda' means WINDOW may not be a minibuffer window.
1761 a window means a specific minibuffer window
1763 ALL_FRAMES t means search all frames,
1764 nil means search just current frame,
1765 `visible' means search just visible frames,
1766 0 means search visible and iconified frames,
1767 a window means search the frame that window belongs to,
1768 a frame means consider windows on that frame, only. */
1771 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1772 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1774 struct window
*w
= XWINDOW (window
);
1775 struct frame
*f
= XFRAME (w
->frame
);
1776 int candidate_p
= 1;
1778 if (!BUFFERP (w
->buffer
))
1780 else if (MINI_WINDOW_P (w
)
1781 && (EQ (minibuf
, Qlambda
)
1782 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1784 /* If MINIBUF is `lambda' don't consider any mini-windows.
1785 If it is a window, consider only that one. */
1788 else if (EQ (all_frames
, Qt
))
1790 else if (NILP (all_frames
))
1792 xassert (WINDOWP (owindow
));
1793 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1795 else if (EQ (all_frames
, Qvisible
))
1797 FRAME_SAMPLE_VISIBILITY (f
);
1798 candidate_p
= FRAME_VISIBLE_P (f
)
1799 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1800 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1803 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1805 FRAME_SAMPLE_VISIBILITY (f
);
1806 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
1807 #ifdef HAVE_X_WINDOWS
1808 /* Yuck!! If we've just created the frame and the
1809 window-manager requested the user to place it
1810 manually, the window may still not be considered
1811 `visible'. I'd argue it should be at least
1812 something like `iconified', but don't know how to do
1814 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
1815 && !f
->output_data
.x
->has_been_visible
)
1818 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1819 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1821 else if (WINDOWP (all_frames
))
1822 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1823 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1824 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1825 else if (FRAMEP (all_frames
))
1826 candidate_p
= EQ (all_frames
, w
->frame
);
1832 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1833 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1837 decode_next_window_args (window
, minibuf
, all_frames
)
1838 Lisp_Object
*window
, *minibuf
, *all_frames
;
1841 *window
= selected_window
;
1843 CHECK_LIVE_WINDOW (*window
);
1845 /* MINIBUF nil may or may not include minibuffers. Decide if it
1847 if (NILP (*minibuf
))
1848 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1849 else if (!EQ (*minibuf
, Qt
))
1852 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1853 => count none of them, or a specific minibuffer window (the
1854 active one) to count. */
1856 /* ALL_FRAMES nil doesn't specify which frames to include. */
1857 if (NILP (*all_frames
))
1858 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1859 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1861 else if (EQ (*all_frames
, Qvisible
))
1863 else if (EQ (*all_frames
, make_number (0)))
1865 else if (FRAMEP (*all_frames
))
1867 else if (!EQ (*all_frames
, Qt
))
1870 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1871 search just current frame, `visible' meaning search just visible
1872 frames, 0 meaning search visible and iconified frames, or a
1873 window, meaning search the frame that window belongs to, or a
1874 frame, meaning consider windows on that frame, only. */
1878 /* Return the next or previous window of WINDOW in canonical ordering
1879 of windows. NEXT_P non-zero means return the next window. See the
1880 documentation string of next-window for the meaning of MINIBUF and
1884 next_window (window
, minibuf
, all_frames
, next_p
)
1885 Lisp_Object window
, minibuf
, all_frames
;
1888 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1890 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1891 return the first window on the frame. */
1892 if (FRAMEP (all_frames
)
1893 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1894 return Fframe_first_window (all_frames
);
1900 /* Find WINDOW in the list of all windows. */
1901 list
= Fmemq (window
, window_list ());
1903 /* Scan forward from WINDOW to the end of the window list. */
1905 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1906 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1909 /* Scan from the start of the window list up to WINDOW. */
1911 for (list
= Vwindow_list
;
1912 CONSP (list
) && !EQ (XCAR (list
), window
);
1914 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1918 window
= XCAR (list
);
1922 Lisp_Object candidate
, list
;
1924 /* Scan through the list of windows for candidates. If there are
1925 candidate windows in front of WINDOW, the last one of these
1926 is the one we want. If there are candidates following WINDOW
1927 in the list, again the last one of these is the one we want. */
1929 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1931 if (EQ (XCAR (list
), window
))
1933 if (WINDOWP (candidate
))
1936 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1938 candidate
= XCAR (list
);
1941 if (WINDOWP (candidate
))
1949 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1950 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1951 If omitted, WINDOW defaults to the selected window.
1953 Optional second arg MINIBUF t means count the minibuffer window even
1954 if not active. MINIBUF nil or omitted means count the minibuffer iff
1955 it is active. MINIBUF neither t nor nil means not to count the
1956 minibuffer even if it is active.
1958 Several frames may share a single minibuffer; if the minibuffer
1959 counts, all windows on all frames that share that minibuffer count
1960 too. Therefore, `next-window' can be used to iterate through the
1961 set of windows even when the minibuffer is on another frame. If the
1962 minibuffer does not count, only windows from WINDOW's frame count.
1964 Optional third arg ALL-FRAMES t means include windows on all frames.
1965 ALL-FRAMES nil or omitted means cycle within the frames as specified
1966 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1967 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1968 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1969 Anything else means restrict to WINDOW's frame.
1971 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1972 `next-window' to iterate through the entire cycle of acceptable
1973 windows, eventually ending up back at the window you started with.
1974 `previous-window' traverses the same cycle, in the reverse order. */)
1975 (window
, minibuf
, all_frames
)
1976 Lisp_Object window
, minibuf
, all_frames
;
1978 return next_window (window
, minibuf
, all_frames
, 1);
1982 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1983 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1984 If omitted, WINDOW defaults to the selected window.
1986 Optional second arg MINIBUF t means count the minibuffer window even
1987 if not active. MINIBUF nil or omitted means count the minibuffer iff
1988 it is active. MINIBUF neither t nor nil means not to count the
1989 minibuffer even if it is active.
1991 Several frames may share a single minibuffer; if the minibuffer
1992 counts, all windows on all frames that share that minibuffer count
1993 too. Therefore, `previous-window' can be used to iterate through
1994 the set of windows even when the minibuffer is on another frame. If
1995 the minibuffer does not count, only windows from WINDOW's frame count
1997 Optional third arg ALL-FRAMES t means include windows on all frames.
1998 ALL-FRAMES nil or omitted means cycle within the frames as specified
1999 above. ALL-FRAMES = `visible' means include windows on all visible frames.
2000 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
2001 If ALL-FRAMES is a frame, restrict search to windows on that frame.
2002 Anything else means restrict to WINDOW's frame.
2004 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2005 `previous-window' to iterate through the entire cycle of acceptable
2006 windows, eventually ending up back at the window you started with.
2007 `next-window' traverses the same cycle, in the reverse order. */)
2008 (window
, minibuf
, all_frames
)
2009 Lisp_Object window
, minibuf
, all_frames
;
2011 return next_window (window
, minibuf
, all_frames
, 0);
2015 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
2016 doc
: /* Select the ARG'th different window on this frame.
2017 All windows on current frame are arranged in a cyclic order.
2018 This command selects the window ARG steps away in that order.
2019 A negative ARG moves in the opposite order. The optional second
2020 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
2022 Lisp_Object arg
, all_frames
;
2028 window
= selected_window
;
2030 for (i
= XINT (arg
); i
> 0; --i
)
2031 window
= Fnext_window (window
, Qnil
, all_frames
);
2033 window
= Fprevious_window (window
, Qnil
, all_frames
);
2035 Fselect_window (window
, Qnil
);
2040 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2041 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2042 FRAME nil or omitted means use the selected frame.
2043 WINDOW nil or omitted means use the selected window.
2044 MINIBUF t means include the minibuffer window, even if it isn't active.
2045 MINIBUF nil or omitted means include the minibuffer window only
2047 MINIBUF neither nil nor t means never include the minibuffer window. */)
2048 (frame
, minibuf
, window
)
2049 Lisp_Object frame
, minibuf
, window
;
2052 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2053 CHECK_WINDOW (window
);
2055 frame
= selected_frame
;
2057 if (!EQ (frame
, XWINDOW (window
)->frame
))
2058 error ("Window is on a different frame");
2060 return window_list_1 (window
, minibuf
, frame
);
2064 /* Return a list of windows in canonical ordering. Arguments are like
2065 for `next-window'. */
2068 window_list_1 (window
, minibuf
, all_frames
)
2069 Lisp_Object window
, minibuf
, all_frames
;
2071 Lisp_Object tail
, list
, rest
;
2073 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2076 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2077 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2078 list
= Fcons (XCAR (tail
), list
);
2080 /* Rotate the list to start with WINDOW. */
2081 list
= Fnreverse (list
);
2082 rest
= Fmemq (window
, list
);
2083 if (!NILP (rest
) && !EQ (rest
, list
))
2085 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2087 XSETCDR (tail
, Qnil
);
2088 list
= nconc2 (rest
, list
);
2095 /* Look at all windows, performing an operation specified by TYPE
2097 If FRAMES is Qt, look at all frames;
2098 Qnil, look at just the selected frame;
2099 Qvisible, look at visible frames;
2100 a frame, just look at windows on that frame.
2101 If MINI is non-zero, perform the operation on minibuffer windows too. */
2106 GET_BUFFER_WINDOW
, /* Arg is buffer */
2107 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2108 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2109 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2111 UNSHOW_BUFFER
, /* Arg is buffer */
2112 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2117 window_loop (type
, obj
, mini
, frames
)
2118 enum window_loop type
;
2119 Lisp_Object obj
, frames
;
2122 Lisp_Object window
, windows
, best_window
, frame_arg
;
2124 struct gcpro gcpro1
;
2126 /* If we're only looping through windows on a particular frame,
2127 frame points to that frame. If we're looping through windows
2128 on all frames, frame is 0. */
2129 if (FRAMEP (frames
))
2130 f
= XFRAME (frames
);
2131 else if (NILP (frames
))
2132 f
= SELECTED_FRAME ();
2137 frame_arg
= Qlambda
;
2138 else if (EQ (frames
, make_number (0)))
2140 else if (EQ (frames
, Qvisible
))
2145 /* frame_arg is Qlambda to stick to one frame,
2146 Qvisible to consider all visible frames,
2149 /* Pick a window to start with. */
2153 window
= FRAME_SELECTED_WINDOW (f
);
2155 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2157 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2161 for (; CONSP (windows
); windows
= XCDR (windows
))
2165 window
= XCAR (windows
);
2166 w
= XWINDOW (window
);
2168 /* Note that we do not pay attention here to whether the frame
2169 is visible, since Fwindow_list skips non-visible frames if
2170 that is desired, under the control of frame_arg. */
2171 if (!MINI_WINDOW_P (w
)
2172 /* For UNSHOW_BUFFER, we must always consider all windows. */
2173 || type
== UNSHOW_BUFFER
2174 || (mini
&& minibuf_level
> 0))
2177 case GET_BUFFER_WINDOW
:
2178 if (EQ (w
->buffer
, obj
)
2179 /* Don't find any minibuffer window
2180 except the one that is currently in use. */
2181 && (MINI_WINDOW_P (w
)
2182 ? EQ (window
, minibuf_window
)
2185 if (NILP (best_window
))
2186 best_window
= window
;
2187 else if (EQ (window
, selected_window
))
2188 /* Prefer to return selected-window. */
2189 RETURN_UNGCPRO (window
);
2190 else if (EQ (Fwindow_frame (window
), selected_frame
))
2191 /* Prefer windows on the current frame. */
2192 best_window
= window
;
2196 case GET_LRU_WINDOW
:
2197 /* `obj' is an integer encoding a bitvector.
2198 `obj & 1' means consider only full-width windows.
2199 `obj & 2' means consider also dedicated windows. */
2200 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2201 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2202 /* Minibuffer windows are always ignored. */
2203 || MINI_WINDOW_P (w
))
2205 if (NILP (best_window
)
2206 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2207 > XFASTINT (w
->use_time
)))
2208 best_window
= window
;
2211 case DELETE_OTHER_WINDOWS
:
2212 if (!EQ (window
, obj
))
2213 Fdelete_window (window
);
2216 case DELETE_BUFFER_WINDOWS
:
2217 if (EQ (w
->buffer
, obj
))
2219 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2221 /* If this window is dedicated, and in a frame of its own,
2223 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2224 && !NILP (w
->dedicated
)
2225 && other_visible_frames (f
))
2227 /* Skip the other windows on this frame.
2228 There might be one, the minibuffer! */
2229 while (CONSP (XCDR (windows
))
2230 && EQ (XWINDOW (XCAR (windows
))->frame
,
2231 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2232 windows
= XCDR (windows
);
2234 /* Now we can safely delete the frame. */
2235 Fdelete_frame (w
->frame
, Qnil
);
2237 else if (NILP (w
->parent
))
2239 /* If we're deleting the buffer displayed in the
2240 only window on the frame, find a new buffer to
2243 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2244 Fset_window_buffer (window
, buffer
, Qnil
);
2245 if (EQ (window
, selected_window
))
2246 Fset_buffer (w
->buffer
);
2249 Fdelete_window (window
);
2253 case GET_LARGEST_WINDOW
:
2254 { /* nil `obj' means to ignore dedicated windows. */
2255 /* Ignore dedicated windows and minibuffers. */
2256 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2259 if (NILP (best_window
))
2260 best_window
= window
;
2263 struct window
*b
= XWINDOW (best_window
);
2264 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2265 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2266 best_window
= window
;
2272 if (EQ (w
->buffer
, obj
))
2275 struct frame
*f
= XFRAME (w
->frame
);
2277 /* Find another buffer to show in this window. */
2278 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2280 /* If this window is dedicated, and in a frame of its own,
2282 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2283 && !NILP (w
->dedicated
)
2284 && other_visible_frames (f
))
2286 /* Skip the other windows on this frame.
2287 There might be one, the minibuffer! */
2288 while (CONSP (XCDR (windows
))
2289 && EQ (XWINDOW (XCAR (windows
))->frame
,
2290 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2291 windows
= XCDR (windows
);
2293 /* Now we can safely delete the frame. */
2294 Fdelete_frame (w
->frame
, Qnil
);
2296 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2299 XSETWINDOW (window
, w
);
2300 /* If this window is dedicated and not the only window
2301 in its frame, then kill it. */
2302 Fdelete_window (window
);
2306 /* Otherwise show a different buffer in the window. */
2307 w
->dedicated
= Qnil
;
2308 Fset_window_buffer (window
, buffer
, Qnil
);
2309 if (EQ (window
, selected_window
))
2310 Fset_buffer (w
->buffer
);
2315 case REDISPLAY_BUFFER_WINDOWS
:
2316 if (EQ (w
->buffer
, obj
))
2318 mark_window_display_accurate (window
, 0);
2319 w
->update_mode_line
= Qt
;
2320 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2321 ++update_mode_lines
;
2322 best_window
= window
;
2326 /* Check for a window that has a killed buffer. */
2327 case CHECK_ALL_WINDOWS
:
2328 if (! NILP (w
->buffer
)
2329 && NILP (XBUFFER (w
->buffer
)->name
))
2333 case WINDOW_LOOP_UNUSED
:
2342 /* Used for debugging. Abort if any window has a dead buffer. */
2345 check_all_windows ()
2347 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2350 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2351 doc
: /* Return the window least recently selected or used for display.
2352 \(LRU means Least Recently Used.)
2354 Return a full-width window if possible.
2355 A minibuffer window is never a candidate.
2356 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2357 so if all windows are dedicated, the value is nil.
2358 If optional argument FRAME is `visible', search all visible frames.
2359 If FRAME is 0, search all visible and iconified frames.
2360 If FRAME is t, search all frames.
2361 If FRAME is nil, search only the selected frame.
2362 If FRAME is a frame, search only that frame. */)
2364 Lisp_Object frame
, dedicated
;
2366 register Lisp_Object w
;
2367 /* First try for a window that is full-width */
2368 w
= window_loop (GET_LRU_WINDOW
,
2369 NILP (dedicated
) ? make_number (1) : make_number (3),
2371 if (!NILP (w
) && !EQ (w
, selected_window
))
2373 /* If none of them, try the rest */
2374 return window_loop (GET_LRU_WINDOW
,
2375 NILP (dedicated
) ? make_number (0) : make_number (2),
2379 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2380 doc
: /* Return the largest window in area.
2381 A minibuffer window is never a candidate.
2382 A dedicated window is never a candidate unless DEDICATED is non-nil,
2383 so if all windows are dedicated, the value is nil.
2384 If optional argument FRAME is `visible', search all visible frames.
2385 If FRAME is 0, search all visible and iconified frames.
2386 If FRAME is t, search all frames.
2387 If FRAME is nil, search only the selected frame.
2388 If FRAME is a frame, search only that frame. */)
2390 Lisp_Object frame
, dedicated
;
2392 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2396 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2397 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2398 BUFFER can be a buffer or a buffer name.
2399 If optional argument FRAME is `visible', search all visible frames.
2400 If optional argument FRAME is 0, search all visible and iconified frames.
2401 If FRAME is t, search all frames.
2402 If FRAME is nil, search only the selected frame.
2403 If FRAME is a frame, search only that frame. */)
2405 Lisp_Object buffer
, frame
;
2407 buffer
= Fget_buffer (buffer
);
2408 if (BUFFERP (buffer
))
2409 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2414 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2416 doc
: /* Make WINDOW (or the selected window) fill its frame.
2417 Only the frame WINDOW is on is affected.
2418 This function tries to reduce display jumps
2419 by keeping the text previously visible in WINDOW
2420 in the same place on the frame. Doing this depends on
2421 the value of (window-start WINDOW), so if calling this function
2422 in a program gives strange scrolling, make sure the window-start
2423 value is reasonable when this function is called. */)
2432 window
= selected_window
;
2434 CHECK_LIVE_WINDOW (window
);
2435 w
= XWINDOW (window
);
2437 startpos
= marker_position (w
->start
);
2438 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2440 if (MINI_WINDOW_P (w
) && top
> 0)
2441 error ("Can't expand minibuffer to full frame");
2443 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2445 /* Try to minimize scrolling, by setting the window start to the point
2446 will cause the text at the old window start to be at the same place
2447 on the frame. But don't try to do this if the window start is
2448 outside the visible portion (as might happen when the display is
2449 not current, due to typeahead). */
2450 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2452 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2453 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2455 struct position pos
;
2456 struct buffer
*obuf
= current_buffer
;
2458 Fset_buffer (w
->buffer
);
2459 /* This computation used to temporarily move point, but that can
2460 have unwanted side effects due to text properties. */
2461 pos
= *vmotion (startpos
, -top
, w
);
2463 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2464 w
->window_end_valid
= Qnil
;
2465 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2466 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2468 /* We need to do this, so that the window-scroll-functions
2470 w
->optional_new_start
= Qt
;
2472 set_buffer_internal (obuf
);
2478 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2479 1, 2, "bDelete windows on (buffer): ",
2480 doc
: /* Delete all windows showing BUFFER.
2481 BUFFER must be a buffer or the name of an existing buffer.
2482 Optional second argument FRAME controls which frames are affected.
2483 If optional argument FRAME is `visible', search all visible frames.
2484 If FRAME is 0, search all visible and iconified frames.
2485 If FRAME is nil, search all frames.
2486 If FRAME is t, search only the selected frame.
2487 If FRAME is a frame, search only that frame. */)
2489 Lisp_Object buffer
, frame
;
2491 /* FRAME uses t and nil to mean the opposite of what window_loop
2495 else if (EQ (frame
, Qt
))
2500 buffer
= Fget_buffer (buffer
);
2501 CHECK_BUFFER (buffer
);
2502 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2508 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2509 Sreplace_buffer_in_windows
,
2510 1, 1, "bReplace buffer in windows: ",
2511 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2512 BUFFER may be a buffer or the name of an existing buffer. */)
2518 buffer
= Fget_buffer (buffer
);
2519 CHECK_BUFFER (buffer
);
2520 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2525 /* Replace BUFFER with some other buffer in all windows
2526 of all frames, even those on other keyboards. */
2529 replace_buffer_in_all_windows (buffer
)
2533 Lisp_Object tail
, frame
;
2535 /* A single call to window_loop won't do the job
2536 because it only considers frames on the current keyboard.
2537 So loop manually over frames, and handle each one. */
2538 FOR_EACH_FRAME (tail
, frame
)
2539 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2541 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2545 /* Set the height of WINDOW and all its inferiors. */
2547 /* The smallest acceptable dimensions for a window. Anything smaller
2548 might crash Emacs. */
2550 #define MIN_SAFE_WINDOW_WIDTH (2)
2551 #define MIN_SAFE_WINDOW_HEIGHT (1)
2553 /* Make sure that window_min_height and window_min_width are
2554 not too small; if they are, set them to safe minima. */
2557 check_min_window_sizes ()
2559 /* Smaller values might permit a crash. */
2560 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2561 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2562 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2563 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2566 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2567 minimum allowable size. */
2570 check_frame_size (frame
, rows
, cols
)
2574 /* For height, we have to see:
2575 how many windows the frame has at minimum (one or two),
2576 and whether it has a menu bar or other special stuff at the top. */
2578 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2579 ? MIN_SAFE_WINDOW_HEIGHT
2580 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2582 if (FRAME_TOP_MARGIN (frame
) > 0)
2583 min_height
+= FRAME_TOP_MARGIN (frame
);
2585 if (*rows
< min_height
)
2587 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2588 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2591 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2592 check if W's width can be changed, otherwise check W's height.
2593 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2594 siblings, too. If none of the siblings is resizable, WINDOW isn't
2598 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2600 int width_p
, check_siblings_p
;
2605 if (!NILP (w
->hchild
))
2607 c
= XWINDOW (w
->hchild
);
2611 /* A horiz. combination is fixed-width if all of if its
2613 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2614 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2615 fixed_p
= c
== NULL
;
2619 /* A horiz. combination is fixed-height if one of if its
2621 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2622 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2623 fixed_p
= c
!= NULL
;
2626 else if (!NILP (w
->vchild
))
2628 c
= XWINDOW (w
->vchild
);
2632 /* A vert. combination is fixed-width if one of if its
2634 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2635 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2636 fixed_p
= c
!= NULL
;
2640 /* A vert. combination is fixed-height if all of if its
2642 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2643 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2644 fixed_p
= c
== NULL
;
2647 else if (BUFFERP (w
->buffer
))
2649 struct buffer
*old
= current_buffer
;
2652 current_buffer
= XBUFFER (w
->buffer
);
2653 val
= find_symbol_value (Qwindow_size_fixed
);
2654 current_buffer
= old
;
2657 if (!EQ (val
, Qunbound
))
2659 fixed_p
= !NILP (val
);
2662 && ((EQ (val
, Qheight
) && width_p
)
2663 || (EQ (val
, Qwidth
) && !width_p
)))
2667 /* Can't tell if this one is resizable without looking at
2668 siblings. If all siblings are fixed-size this one is too. */
2669 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2673 for (child
= w
->prev
; WINDOWP (child
); child
= XWINDOW (child
)->prev
)
2674 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2678 for (child
= w
->next
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
2679 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2692 /* Return the minimum size for leaf window W. WIDTH_P non-zero means
2693 take into account fringes and the scrollbar of W. WIDTH_P zero means
2694 take into account mode-line of W. Return 1 for the minibuffer. */
2697 window_min_size_2 (w
, width_p
)
2704 size
= max (window_min_width
,
2705 (MIN_SAFE_WINDOW_WIDTH
2706 + WINDOW_FRINGE_COLS (w
)
2707 + WINDOW_SCROLL_BAR_COLS (w
)));
2708 else if (MINI_WINDOW_P (w
))
2711 size
= max (window_min_height
,
2712 (MIN_SAFE_WINDOW_HEIGHT
2713 /* Don't count the header-line here. It would break
2714 splitting a window with a header-line when the new
2715 window shall have a height of two (calculator does
2717 + (WINDOW_WANTS_MODELINE_P (w
) ? 1 : 0)));
2722 /* Return the minimum size of window W, not taking fixed-width windows
2723 into account. WIDTH_P non-zero means return the minimum width,
2724 otherwise return the minimum height. If W is a combination window,
2725 compute the minimum size from the minimum sizes of W's children. */
2728 window_min_size_1 (w
, width_p
)
2735 if (!NILP (w
->hchild
))
2737 c
= XWINDOW (w
->hchild
);
2742 /* The min width of a horizontal combination is
2743 the sum of the min widths of its children. */
2746 size
+= window_min_size_1 (c
, width_p
);
2747 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2752 /* The min height a horizontal combination equals
2753 the maximum of all min height of its children. */
2756 int min_size
= window_min_size_1 (c
, width_p
);
2757 size
= max (min_size
, size
);
2758 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2762 else if (!NILP (w
->vchild
))
2764 c
= XWINDOW (w
->vchild
);
2769 /* The min width of a vertical combination is
2770 the maximum of the min widths of its children. */
2773 int min_size
= window_min_size_1 (c
, width_p
);
2774 size
= max (min_size
, size
);
2775 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2780 /* The min height of a vertical combination equals
2781 the sum of the min height of its children. */
2784 size
+= window_min_size_1 (c
, width_p
);
2785 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2790 size
= window_min_size_2 (w
, width_p
);
2796 /* Return the minimum size of window W, taking fixed-size windows into
2797 account. WIDTH_P non-zero means return the minimum width,
2798 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2799 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2800 unless FIXED is null. */
2803 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2805 int width_p
, ignore_fixed_p
, *fixed
;
2812 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2818 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2820 size
= window_min_size_1 (w
, width_p
);
2826 /* Adjust the margins of window W if text area is too small.
2827 Return 1 if window width is ok after adjustment; 0 if window
2828 is still too narrow. */
2831 adjust_window_margins (w
)
2834 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2835 - WINDOW_FRINGE_COLS (w
)
2836 - WINDOW_SCROLL_BAR_COLS (w
));
2837 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2838 + WINDOW_RIGHT_MARGIN_COLS (w
));
2840 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2843 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2846 /* Window's text area is too narrow, but reducing the window
2847 margins will fix that. */
2848 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2849 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2851 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2852 w
->left_margin_cols
= w
->right_margin_cols
2853 = make_number (margin_cols
/2);
2855 w
->right_margin_cols
= make_number (margin_cols
);
2858 w
->left_margin_cols
= make_number (margin_cols
);
2862 /* Calculate new sizes for windows in the list FORWARD when the window size
2863 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2864 The number of windows in FORWARD is NCHILDREN, and the number that
2865 can shrink is SHRINKABLE.
2866 The minimum size a window can have is MIN_SIZE.
2867 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2868 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2871 This function returns an allocated array of new sizes that the caller
2872 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2873 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2874 the second, and so on.
2876 This function tries to keep windows at least at the minimum size
2877 and resize other windows before it resizes any window to zero (i.e.
2878 delete that window).
2880 Windows are resized proportional to their size, so bigger windows
2881 shrink more than smaller windows. */
2883 shrink_windows (total
, size
, nchildren
, shrinkable
,
2884 min_size
, resize_fixed_p
, forward
, width_p
)
2885 int total
, size
, nchildren
, shrinkable
, min_size
;
2886 int resize_fixed_p
, width_p
;
2887 Lisp_Object forward
;
2889 int available_resize
= 0;
2893 int smallest
= total
;
2894 int total_removed
= 0;
2895 int total_shrink
= total
- size
;
2898 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2900 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2904 c
= XWINDOW (child
);
2905 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2907 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2911 new_sizes
[i
] = child_size
;
2912 if (child_size
> min_size
)
2913 available_resize
+= child_size
- min_size
;
2916 /* We might need to shrink some windows to zero. Find the smallest
2917 windows and set them to 0 until we can fulfil the new size. */
2919 while (shrinkable
> 1 && size
+ available_resize
< total
)
2921 for (i
= 0; i
< nchildren
; ++i
)
2922 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2923 smallest
= new_sizes
[i
];
2925 for (i
= 0; i
< nchildren
; ++i
)
2926 if (new_sizes
[i
] == smallest
)
2928 /* Resize this window down to zero. */
2930 if (smallest
> min_size
)
2931 available_resize
-= smallest
- min_size
;
2932 available_resize
+= smallest
;
2934 total_removed
+= smallest
;
2936 /* We don't know what the smallest is now. */
2939 /* Out of for, just remove one window at the time and
2940 check again if we have enough space. */
2945 /* Now, calculate the new sizes. Try to shrink each window
2946 proportional to its size. */
2947 for (i
= 0; i
< nchildren
; ++i
)
2949 if (new_sizes
[i
] > min_size
)
2951 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2952 if (new_sizes
[i
] - to_shrink
< min_size
)
2953 to_shrink
= new_sizes
[i
] - min_size
;
2954 new_sizes
[i
] -= to_shrink
;
2955 total_removed
+= to_shrink
;
2959 /* Any reminder due to rounding, we just subtract from windows
2960 that are left and still can be shrunk. */
2961 while (total_shrink
> total_removed
)
2963 int nonzero_sizes
= 0;
2964 int nonzero_idx
= -1;
2966 for (i
= 0; i
< nchildren
; ++i
)
2967 if (new_sizes
[i
] > 0)
2973 for (i
= 0; i
< nchildren
; ++i
)
2974 if (new_sizes
[i
] > min_size
)
2979 /* Out of for, just shrink one window at the time and
2980 check again if we have enough space. */
2985 /* Special case, only one window left. */
2986 if (nonzero_sizes
== 1)
2990 /* Any surplus due to rounding, we add to windows that are left. */
2991 while (total_shrink
< total_removed
)
2993 for (i
= 0; i
< nchildren
; ++i
)
2995 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
3007 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
3008 WINDOW's width. Resize WINDOW's children, if any, so that they
3009 keep their proportionate size relative to WINDOW.
3011 If FIRST_ONLY is 1, change only the first of WINDOW's children when
3012 they are in series. If LAST_ONLY is 1, change only the last of
3013 WINDOW's children when they are in series.
3015 Propagate WINDOW's top or left edge position to children. Delete
3016 windows that become too small unless NODELETE_P is non-zero.
3018 If NODELETE_P is 2, that means we do delete windows that are
3019 too small, even if they were too small before! */
3022 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
3024 int size
, width_p
, nodelete_p
;
3025 int first_only
, last_only
;
3027 struct window
*w
= XWINDOW (window
);
3029 Lisp_Object child
, *forward
, *sideward
;
3030 int old_size
, min_size
, safe_min_size
;
3032 check_min_window_sizes ();
3033 size
= max (0, size
);
3035 /* If the window has been "too small" at one point,
3036 don't delete it for being "too small" in the future.
3037 Preserve it as long as that is at all possible. */
3040 old_size
= WINDOW_TOTAL_COLS (w
);
3041 min_size
= window_min_width
;
3042 safe_min_size
= window_min_size_2 (w
, 1);
3046 old_size
= XINT (w
->total_lines
);
3047 min_size
= window_min_height
;
3048 safe_min_size
= window_min_size_2 (w
, 0);
3051 if (old_size
< min_size
&& nodelete_p
!= 2)
3052 w
->too_small_ok
= Qt
;
3054 /* Move the following test here since otherwise the
3055 preceding test doesn't make sense. martin. */
3056 if (nodelete_p
== 2)
3059 /* Maybe delete WINDOW if it's too small. */
3060 if (nodelete_p
!= 1 && !NILP (w
->parent
))
3062 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
3063 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
3064 if (min_size
< safe_min_size
)
3065 min_size
= safe_min_size
;
3066 if (size
< min_size
)
3068 delete_window (window
);
3073 /* Set redisplay hints. */
3074 w
->last_modified
= make_number (0);
3075 w
->last_overlay_modified
= make_number (0);
3076 windows_or_buffers_changed
++;
3077 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3081 sideward
= &w
->vchild
;
3082 forward
= &w
->hchild
;
3083 w
->total_cols
= make_number (size
);
3084 adjust_window_margins (w
);
3088 sideward
= &w
->hchild
;
3089 forward
= &w
->vchild
;
3090 w
->total_lines
= make_number (size
);
3091 w
->orig_total_lines
= Qnil
;
3094 if (!NILP (*sideward
))
3096 /* We have a chain of parallel siblings whose size should all change. */
3097 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3099 c
= XWINDOW (child
);
3101 c
->left_col
= w
->left_col
;
3103 c
->top_line
= w
->top_line
;
3104 size_window (child
, size
, width_p
, nodelete_p
,
3105 first_only
, last_only
);
3108 else if (!NILP (*forward
) && last_only
)
3110 /* Change the last in a series of siblings. */
3111 Lisp_Object last_child
;
3114 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3116 c
= XWINDOW (child
);
3120 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3121 size_window (last_child
,
3122 size
- old_size
+ child_size
,
3123 width_p
, nodelete_p
, first_only
, last_only
);
3125 else if (!NILP (*forward
) && first_only
)
3127 /* Change the first in a series of siblings. */
3131 c
= XWINDOW (child
);
3134 c
->left_col
= w
->left_col
;
3136 c
->top_line
= w
->top_line
;
3138 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3140 size
- old_size
+ child_size
,
3141 width_p
, nodelete_p
, first_only
, last_only
);
3143 else if (!NILP (*forward
))
3145 int fixed_size
, each
, extra
, n
;
3146 int resize_fixed_p
, nfixed
;
3147 int last_pos
, first_pos
, nchildren
, total
;
3148 int *new_sizes
= NULL
;
3150 /* Determine the fixed-size portion of this window, and the
3151 number of child windows. */
3152 fixed_size
= nchildren
= nfixed
= total
= 0;
3153 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3157 c
= XWINDOW (child
);
3158 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3159 total
+= child_size
;
3161 if (window_fixed_size_p (c
, width_p
, 0))
3163 fixed_size
+= child_size
;
3168 /* If the new size is smaller than fixed_size, or if there
3169 aren't any resizable windows, allow resizing fixed-size
3171 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3173 /* Compute how many lines/columns to add/remove to each child. The
3174 value of extra takes care of rounding errors. */
3175 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3176 if (size
< total
&& n
> 1)
3177 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
3178 resize_fixed_p
, *forward
, width_p
);
3181 each
= (size
- total
) / n
;
3182 extra
= (size
- total
) - n
* each
;
3185 /* Compute new children heights and edge positions. */
3186 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3187 last_pos
= first_pos
;
3188 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3190 int new_size
, old_size
;
3192 c
= XWINDOW (child
);
3193 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
3194 new_size
= old_size
;
3196 /* The top or left edge position of this child equals the
3197 bottom or right edge of its predecessor. */
3199 c
->left_col
= make_number (last_pos
);
3201 c
->top_line
= make_number (last_pos
);
3203 /* If this child can be resized, do it. */
3204 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3206 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3210 /* Set new height. Note that size_window also propagates
3211 edge positions to children, so it's not a no-op if we
3212 didn't change the child's size. */
3213 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3215 /* Remember the bottom/right edge position of this child; it
3216 will be used to set the top/left edge of the next child. */
3217 last_pos
+= new_size
;
3220 if (new_sizes
) xfree (new_sizes
);
3222 /* We should have covered the parent exactly with child windows. */
3223 xassert (size
== last_pos
- first_pos
);
3225 /* Now delete any children that became too small. */
3227 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3230 c
= XWINDOW (child
);
3231 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3232 size_window (child
, child_size
, width_p
, 2, first_only
, last_only
);
3237 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3238 WINDOW's children. NODELETE non-zero means don't delete windows
3239 that become too small in the process. (The caller should check
3240 later and do so if appropriate.) */
3243 set_window_height (window
, height
, nodelete
)
3248 size_window (window
, height
, 0, nodelete
, 0, 0);
3252 /* Set WINDOW's width to WIDTH, and recursively change the width of
3253 WINDOW's children. NODELETE non-zero means don't delete windows
3254 that become too small in the process. (The caller should check
3255 later and do so if appropriate.) */
3258 set_window_width (window
, width
, nodelete
)
3263 size_window (window
, width
, 1, nodelete
, 0, 0);
3266 /* Change window heights in windows rooted in WINDOW by N lines. */
3269 change_window_heights (window
, n
)
3273 struct window
*w
= XWINDOW (window
);
3275 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3276 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3278 if (INTEGERP (w
->orig_top_line
))
3279 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3280 if (INTEGERP (w
->orig_total_lines
))
3281 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3283 /* Handle just the top child in a vertical split. */
3284 if (!NILP (w
->vchild
))
3285 change_window_heights (w
->vchild
, n
);
3287 /* Adjust all children in a horizontal split. */
3288 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3290 w
= XWINDOW (window
);
3291 change_window_heights (window
, n
);
3296 int window_select_count
;
3299 Fset_window_buffer_unwind (obuf
)
3306 EXFUN (Fset_window_fringes
, 4);
3307 EXFUN (Fset_window_scroll_bars
, 4);
3310 run_funs (Lisp_Object funs
)
3312 for (; CONSP (funs
); funs
= XCDR (funs
))
3313 if (!EQ (XCAR (funs
), Qt
))
3314 call0 (XCAR (funs
));
3317 static Lisp_Object
select_window_norecord (Lisp_Object window
);
3320 run_window_configuration_change_hook (struct frame
*f
)
3322 int count
= SPECPDL_INDEX ();
3323 Lisp_Object frame
, global_wcch
3324 = Fdefault_value (Qwindow_configuration_change_hook
);
3325 XSETFRAME (frame
, f
);
3327 if (NILP (Vrun_hooks
))
3330 if (SELECTED_FRAME () != f
)
3332 record_unwind_protect (Fselect_frame
, Fselected_frame ());
3333 Fselect_frame (frame
);
3336 /* Use the right buffer. Matters when running the local hooks. */
3337 if (current_buffer
!= XBUFFER (Fwindow_buffer (Qnil
)))
3339 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3340 Fset_buffer (Fwindow_buffer (Qnil
));
3343 /* Look for buffer-local values. */
3345 Lisp_Object windows
= Fwindow_list (frame
, Qlambda
, Qnil
);
3346 for (; CONSP (windows
); windows
= XCDR (windows
))
3348 Lisp_Object window
= XCAR (windows
);
3349 Lisp_Object buffer
= Fwindow_buffer (window
);
3350 if (!NILP (Flocal_variable_p (Qwindow_configuration_change_hook
,
3353 int count
= SPECPDL_INDEX ();
3354 record_unwind_protect (select_window_norecord
, Fselected_window ());
3355 select_window_norecord (window
);
3356 run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook
,
3358 unbind_to (count
, Qnil
);
3363 run_funs (global_wcch
);
3364 unbind_to (count
, Qnil
);
3367 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3368 means it's allowed to run hooks. See make_frame for a case where
3369 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3370 margins, fringes, and scroll-bar settings of the window are not
3371 reset from the buffer's local settings. */
3374 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3375 Lisp_Object window
, buffer
;
3376 int run_hooks_p
, keep_margins_p
;
3378 struct window
*w
= XWINDOW (window
);
3379 struct buffer
*b
= XBUFFER (buffer
);
3380 int count
= SPECPDL_INDEX ();
3381 int samebuf
= EQ (buffer
, w
->buffer
);
3385 if (EQ (window
, selected_window
))
3386 b
->last_selected_window
= window
;
3388 /* Let redisplay errors through. */
3389 b
->display_error_modiff
= 0;
3391 /* Update time stamps of buffer display. */
3392 if (INTEGERP (b
->display_count
))
3393 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3394 b
->display_time
= Fcurrent_time ();
3396 XSETFASTINT (w
->window_end_pos
, 0);
3397 XSETFASTINT (w
->window_end_vpos
, 0);
3398 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3399 w
->window_end_valid
= Qnil
;
3400 if (!(keep_margins_p
&& samebuf
))
3401 { /* If we're not actually changing the buffer, Don't reset hscroll and
3402 vscroll. This case happens for example when called from
3403 change_frame_size_1, where we use a dummy call to
3404 Fset_window_buffer on the frame's selected window (and no other)
3405 just in order to run window-configuration-change-hook.
3406 Resetting hscroll and vscroll here is problematic for things like
3407 image-mode and doc-view-mode since it resets the image's position
3408 whenever we resize the frame. */
3409 w
->hscroll
= w
->min_hscroll
= make_number (0);
3411 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3412 set_marker_restricted (w
->start
,
3413 make_number (b
->last_window_start
),
3415 w
->start_at_line_beg
= Qnil
;
3416 w
->force_start
= Qnil
;
3417 XSETFASTINT (w
->last_modified
, 0);
3418 XSETFASTINT (w
->last_overlay_modified
, 0);
3420 /* Maybe we could move this into the `if' but it's not obviously safe and
3421 I doubt it's worth the trouble. */
3422 windows_or_buffers_changed
++;
3424 /* We must select BUFFER for running the window-scroll-functions.
3425 If WINDOW is selected, switch permanently.
3426 Otherwise, switch but go back to the ambient buffer afterward. */
3427 if (EQ (window
, selected_window
))
3428 Fset_buffer (buffer
);
3429 /* We can't check ! NILP (Vwindow_scroll_functions) here
3430 because that might itself be a local variable. */
3431 else if (window_initialized
)
3433 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3434 Fset_buffer (buffer
);
3437 if (!keep_margins_p
)
3439 /* Set left and right marginal area width etc. from buffer. */
3441 /* This may call adjust_window_margins three times, so
3442 temporarily disable window margins. */
3443 Lisp_Object save_left
= w
->left_margin_cols
;
3444 Lisp_Object save_right
= w
->right_margin_cols
;
3446 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3448 Fset_window_fringes (window
,
3449 b
->left_fringe_width
, b
->right_fringe_width
,
3450 b
->fringes_outside_margins
);
3452 Fset_window_scroll_bars (window
,
3453 b
->scroll_bar_width
,
3454 b
->vertical_scroll_bar_type
, Qnil
);
3456 w
->left_margin_cols
= save_left
;
3457 w
->right_margin_cols
= save_right
;
3459 Fset_window_margins (window
,
3460 b
->left_margin_cols
, b
->right_margin_cols
);
3465 if (! NILP (Vwindow_scroll_functions
))
3466 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3467 Fmarker_position (w
->start
));
3468 run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w
)));
3471 unbind_to (count
, Qnil
);
3475 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3476 doc
: /* Make WINDOW display BUFFER as its contents.
3477 BUFFER can be a buffer or the name of an existing buffer.
3478 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3479 display margins, fringe widths, and scroll bar settings are maintained;
3480 the default is to reset these from BUFFER's local settings or the frame
3483 This function runs the hook `window-scroll-functions'. */)
3484 (window
, buffer
, keep_margins
)
3485 register Lisp_Object window
, buffer
, keep_margins
;
3487 register Lisp_Object tem
;
3488 register struct window
*w
= decode_window (window
);
3490 XSETWINDOW (window
, w
);
3491 buffer
= Fget_buffer (buffer
);
3492 CHECK_BUFFER (buffer
);
3494 if (NILP (XBUFFER (buffer
)->name
))
3495 error ("Attempt to display deleted buffer");
3499 error ("Window is deleted");
3500 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3501 is first being set up. */
3503 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3504 error ("Window is dedicated to `%s'",
3505 SDATA (XBUFFER (tem
)->name
));
3510 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3514 /* Note that selected_window can be nil
3515 when this is called from Fset_window_configuration. */
3517 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3518 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3519 If WINDOW is not already selected, make WINDOW's buffer current
3520 and make WINDOW the frame's selected window. Return WINDOW.
3521 Optional second arg NORECORD non-nil means
3522 do not put this buffer at the front of the list of recently selected ones.
3524 Note that the main editor command loop
3525 selects the buffer of the selected window before each command. */)
3527 register Lisp_Object window
, norecord
;
3529 register struct window
*w
;
3530 register struct window
*ow
;
3533 CHECK_LIVE_WINDOW (window
);
3535 w
= XWINDOW (window
);
3536 w
->frozen_window_start_p
= 0;
3538 ++window_select_count
;
3539 XSETFASTINT (w
->use_time
, window_select_count
);
3540 if (EQ (window
, selected_window
))
3543 sf
= SELECTED_FRAME ();
3544 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3546 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3547 /* Use this rather than Fhandle_switch_frame
3548 so that FRAME_FOCUS_FRAME is moved appropriately as we
3549 move around in the state where a minibuffer in a separate
3551 Fselect_frame (WINDOW_FRAME (w
));
3552 /* Fselect_frame called us back so we've done all the work already. */
3553 eassert (EQ (window
, selected_window
));
3557 sf
->selected_window
= window
;
3559 /* Store the current buffer's actual point into the
3560 old selected window. It belongs to that window,
3561 and when the window is not selected, must be in the window. */
3562 if (!NILP (selected_window
))
3564 ow
= XWINDOW (selected_window
);
3565 if (! NILP (ow
->buffer
))
3566 set_marker_both (ow
->pointm
, ow
->buffer
,
3567 BUF_PT (XBUFFER (ow
->buffer
)),
3568 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3571 selected_window
= window
;
3573 if (NILP (norecord
))
3574 record_buffer (w
->buffer
);
3575 Fset_buffer (w
->buffer
);
3577 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3579 /* Go to the point recorded in the window.
3580 This is important when the buffer is in more
3581 than one window. It also matters when
3582 redisplay_window has altered point after scrolling,
3583 because it makes the change only in the window. */
3585 register int new_point
= marker_position (w
->pointm
);
3586 if (new_point
< BEGV
)
3588 else if (new_point
> ZV
)
3594 windows_or_buffers_changed
++;
3599 select_window_norecord (window
)
3602 return Fselect_window (window
, Qt
);
3605 /* Deiconify the frame containing the window WINDOW,
3606 unless it is the selected frame;
3609 The reason for the exception for the selected frame
3610 is that it seems better not to change the selected frames visibility
3611 merely because of displaying a different buffer in it.
3612 The deiconification is useful when a buffer gets shown in
3613 another frame that you were not using lately. */
3616 display_buffer_1 (window
)
3619 Lisp_Object frame
= XWINDOW (window
)->frame
;
3620 FRAME_PTR f
= XFRAME (frame
);
3622 FRAME_SAMPLE_VISIBILITY (f
);
3624 if (EQ (frame
, selected_frame
))
3625 ; /* Assume the selected frame is already visible enough. */
3626 else if (minibuf_level
> 0
3627 && MINI_WINDOW_P (XWINDOW (selected_window
))
3628 && WINDOW_LIVE_P (minibuf_selected_window
)
3629 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3630 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3633 if (FRAME_ICONIFIED_P (f
))
3634 Fmake_frame_visible (frame
);
3635 else if (FRAME_VISIBLE_P (f
))
3636 Fraise_frame (frame
);
3642 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3643 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3644 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3645 special frame for that buffer using the default frame parameters.
3647 If the value is a list, it is a list of frame parameters that would be used
3648 to make a frame for that buffer.
3649 The variables `special-display-buffer-names'
3650 and `special-display-regexps' control this. */)
3652 Lisp_Object buffer_name
;
3656 CHECK_STRING (buffer_name
);
3658 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3662 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3666 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3668 Lisp_Object car
= XCAR (tem
);
3670 && fast_string_match (car
, buffer_name
) >= 0)
3672 else if (CONSP (car
)
3673 && STRINGP (XCAR (car
))
3674 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3680 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3681 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3682 More precisely, if `display-buffer' or `pop-to-buffer' would display
3683 that buffer in the selected window rather than (as usual) in some other window.
3684 See `same-window-buffer-names' and `same-window-regexps'. */)
3686 Lisp_Object buffer_name
;
3690 CHECK_STRING (buffer_name
);
3692 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3696 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3700 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3702 Lisp_Object car
= XCAR (tem
);
3704 && fast_string_match (car
, buffer_name
) >= 0)
3706 else if (CONSP (car
)
3707 && STRINGP (XCAR (car
))
3708 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3714 /* Use B so the default is (other-buffer). */
3715 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3716 "BDisplay buffer: \nP",
3717 doc
: /* Make BUFFER appear in some window but don't select it.
3718 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3720 If BUFFER is shown already in some window, just use that one,
3721 unless the window is the selected window and the optional second
3722 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3723 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3724 Returns the window displaying BUFFER.
3725 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3726 displaying BUFFER, then simply raise that frame.
3728 The variables `special-display-buffer-names',
3729 `special-display-regexps', `same-window-buffer-names', and
3730 `same-window-regexps' customize how certain buffer names are handled.
3731 The latter two take effect only if NOT-THIS-WINDOW is nil.
3733 If optional argument FRAME is `visible', check all visible frames
3734 for a window to use.
3735 If FRAME is 0, check all visible and iconified frames.
3736 If FRAME is t, check all frames.
3737 If FRAME is a frame, check only that frame.
3738 If FRAME is nil, check only the selected frame
3739 (actually the last nonminibuffer frame),
3740 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3741 which means search visible and iconified frames.
3743 If a full-width window on a splittable frame is available to display
3744 the buffer, it may be split, subject to the value of the variable
3745 `split-height-threshold'.
3747 If `even-window-heights' is non-nil, window heights will be evened out
3748 if displaying the buffer causes two vertically adjacent windows to be
3750 (buffer
, not_this_window
, frame
)
3751 Lisp_Object buffer
, not_this_window
, frame
;
3753 register Lisp_Object window
, tem
, swp
;
3757 buffer
= Fget_buffer (buffer
);
3758 CHECK_BUFFER (buffer
);
3760 if (!NILP (Vdisplay_buffer_function
))
3761 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3763 if (NILP (not_this_window
)
3764 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3765 return display_buffer_1 (selected_window
);
3767 /* See if the user has specified this buffer should appear
3768 in the selected window. */
3769 if (NILP (not_this_window
))
3771 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3772 if (!NILP (swp
) && !no_switch_window (selected_window
))
3774 Fswitch_to_buffer (buffer
, Qnil
);
3775 return display_buffer_1 (selected_window
);
3779 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3780 look for a window showing BUFFER on any visible or iconified frame.
3781 Otherwise search only the current frame. */
3784 else if (pop_up_frames
3785 || display_buffer_reuse_frames
3786 || last_nonminibuf_frame
== 0)
3787 XSETFASTINT (tem
, 0);
3789 XSETFRAME (tem
, last_nonminibuf_frame
);
3791 window
= Fget_buffer_window (buffer
, tem
);
3793 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3794 return display_buffer_1 (window
);
3796 /* Certain buffer names get special handling. */
3797 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3799 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3801 return call1 (Vspecial_display_function
, buffer
);
3803 return call2 (Vspecial_display_function
, buffer
, tem
);
3806 /* If there are no frames open that have more than a minibuffer,
3807 we need to create a new frame. */
3808 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3810 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3811 Fset_window_buffer (window
, buffer
, Qnil
);
3812 return display_buffer_1 (window
);
3815 f
= SELECTED_FRAME ();
3817 || FRAME_MINIBUF_ONLY_P (f
)
3818 /* If the current frame is a special display frame,
3819 don't try to reuse its windows. */
3820 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3823 struct gcpro gcpro1
;
3827 if (FRAME_MINIBUF_ONLY_P (f
))
3828 XSETFRAME (frames
, last_nonminibuf_frame
);
3830 /* Note that both Fget_largest_window and Fget_lru_window
3831 ignore minibuffers and dedicated windows.
3832 This means they can return nil. */
3834 /* If the frame we would try to split cannot be split,
3835 try other frames. */
3836 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3838 /* Try visible frames first. */
3839 window
= Fget_largest_window (Qvisible
, Qt
);
3840 /* If that didn't work, try iconified frames. */
3842 window
= Fget_largest_window (make_number (0), Qt
);
3843 #if 0 /* Don't try windows on other displays. */
3845 window
= Fget_largest_window (Qt
, Qt
);
3849 window
= Fget_largest_window (frames
, Qt
);
3851 if (!NILP (Vsplit_window_preferred_function
))
3852 tem
= call1 (Vsplit_window_preferred_function
, window
);
3857 /* If the largest window is tall enough, full-width, and either eligible
3858 for splitting or the only window, split it. */
3860 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3861 && WINDOW_FULL_WIDTH_P (XWINDOW (window
))
3862 && (window_height (window
) >= split_height_threshold
3863 || (NILP (XWINDOW (window
)->parent
)))
3864 && (window_height (window
)
3865 >= (2 * window_min_size_2 (XWINDOW (window
), 0))))
3866 window
= Fsplit_window (window
, Qnil
, Qnil
);
3869 Lisp_Object upper
, other
;
3871 window
= Fget_lru_window (frames
, Qt
);
3872 /* If the LRU window is tall enough, and either eligible for
3873 splitting and selected or the only window, split it. */
3875 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3876 && ((EQ (window
, selected_window
)
3877 && window_height (window
) >= split_height_threshold
)
3878 || (NILP (XWINDOW (window
)->parent
)))
3879 && (window_height (window
)
3880 >= (2 * window_min_size_2 (XWINDOW (window
), 0))))
3881 window
= Fsplit_window (window
, Qnil
, Qnil
);
3883 window
= Fget_lru_window (frames
, Qnil
);
3884 /* If Fget_lru_window returned nil, try other approaches. */
3886 /* Try visible frames first. */
3888 window
= Fget_buffer_window (buffer
, Qvisible
);
3890 window
= Fget_largest_window (Qvisible
, Qnil
);
3891 /* If that didn't work, try iconified frames. */
3893 window
= Fget_buffer_window (buffer
, make_number (0));
3895 window
= Fget_largest_window (make_number (0), Qnil
);
3897 #if 0 /* Don't try frames on other displays. */
3899 window
= Fget_buffer_window (buffer
, Qt
);
3901 window
= Fget_largest_window (Qt
, Qnil
);
3903 /* As a last resort, make a new frame. */
3905 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3906 /* If window appears above or below another,
3907 even out their heights. */
3908 other
= upper
= Qnil
;
3909 if (!NILP (XWINDOW (window
)->prev
))
3910 other
= upper
= XWINDOW (window
)->prev
;
3911 if (!NILP (XWINDOW (window
)->next
))
3912 other
= XWINDOW (window
)->next
, upper
= window
;
3914 && !NILP (Veven_window_heights
)
3915 /* Check that OTHER and WINDOW are vertically arrayed. */
3916 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3917 && (XFASTINT (XWINDOW (other
)->total_lines
)
3918 > XFASTINT (XWINDOW (window
)->total_lines
)))
3920 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3921 + XFASTINT (XWINDOW (window
)->total_lines
));
3922 enlarge_window (upper
,
3923 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3930 window
= Fget_lru_window (Qnil
, Qnil
);
3932 Fset_window_buffer (window
, buffer
, Qnil
);
3933 return display_buffer_1 (window
);
3937 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3939 doc
: /* Force all windows to be updated on next redisplay.
3940 If optional arg OBJECT is a window, force redisplay of that window only.
3941 If OBJECT is a buffer or buffer name, force redisplay of all windows
3942 displaying that buffer. */)
3948 windows_or_buffers_changed
++;
3949 update_mode_lines
++;
3953 if (WINDOWP (object
))
3955 struct window
*w
= XWINDOW (object
);
3956 mark_window_display_accurate (object
, 0);
3957 w
->update_mode_line
= Qt
;
3958 if (BUFFERP (w
->buffer
))
3959 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3960 ++update_mode_lines
;
3964 if (STRINGP (object
))
3965 object
= Fget_buffer (object
);
3966 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3968 /* Walk all windows looking for buffer, and force update
3969 of each of those windows. */
3971 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3972 return NILP (object
) ? Qnil
: Qt
;
3975 /* If nothing suitable was found, just return.
3976 We could signal an error, but this feature will typically be used
3977 asynchronously in timers or process sentinels, so we don't. */
3983 temp_output_buffer_show (buf
)
3984 register Lisp_Object buf
;
3986 register struct buffer
*old
= current_buffer
;
3987 register Lisp_Object window
;
3988 register struct window
*w
;
3990 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3993 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3997 #if 0 /* rms: there should be no reason for this. */
3998 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
4000 set_buffer_internal (old
);
4002 if (!NILP (Vtemp_buffer_show_function
))
4003 call1 (Vtemp_buffer_show_function
, buf
);
4006 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
4008 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
4009 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
4010 Vminibuf_scroll_window
= window
;
4011 w
= XWINDOW (window
);
4012 XSETFASTINT (w
->hscroll
, 0);
4013 XSETFASTINT (w
->min_hscroll
, 0);
4014 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
4015 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
4017 /* Run temp-buffer-show-hook, with the chosen window selected
4018 and its buffer current. */
4020 if (!NILP (Vrun_hooks
)
4021 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
4022 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
4024 int count
= SPECPDL_INDEX ();
4025 Lisp_Object prev_window
, prev_buffer
;
4026 prev_window
= selected_window
;
4027 XSETBUFFER (prev_buffer
, old
);
4029 /* Select the window that was chosen, for running the hook.
4030 Note: Both Fselect_window and select_window_norecord may
4031 set-buffer to the buffer displayed in the window,
4032 so we need to save the current buffer. --stef */
4033 record_unwind_protect (Fset_buffer
, prev_buffer
);
4034 record_unwind_protect (select_window_norecord
, prev_window
);
4035 Fselect_window (window
, Qt
);
4036 Fset_buffer (w
->buffer
);
4037 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
4038 unbind_to (count
, Qnil
);
4044 make_dummy_parent (window
)
4048 register struct window
*o
, *p
;
4051 o
= XWINDOW (window
);
4052 p
= allocate_window ();
4053 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
4054 ((struct Lisp_Vector
*) p
)->contents
[i
]
4055 = ((struct Lisp_Vector
*)o
)->contents
[i
];
4056 XSETWINDOW (new, p
);
4059 XSETFASTINT (p
->sequence_number
, sequence_number
);
4061 /* Put new into window structure in place of window */
4062 replace_window (window
, new);
4075 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
4076 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
4077 WINDOW defaults to selected one and SIZE to half its size.
4078 If optional third arg HORFLAG is non-nil, split side by side
4079 and put SIZE columns in the first of the pair. In that case,
4080 SIZE includes that window's scroll bar, or the divider column to its right.
4081 Interactively, all arguments are nil.
4083 Returns the newly created window (which is the lower or rightmost one).
4084 The upper or leftmost window is the original one, and remains selected
4085 if it was selected before.
4087 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
4088 (window
, size
, horflag
)
4089 Lisp_Object window
, size
, horflag
;
4091 register Lisp_Object
new;
4092 register struct window
*o
, *p
;
4094 register int size_int
;
4097 window
= selected_window
;
4099 CHECK_LIVE_WINDOW (window
);
4101 o
= XWINDOW (window
);
4102 fo
= XFRAME (WINDOW_FRAME (o
));
4106 if (!NILP (horflag
))
4107 /* Calculate the size of the left-hand window, by dividing
4108 the usable space in columns by two.
4109 We round up, since the left-hand window may include
4110 a dividing line, while the right-hand may not. */
4111 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
4113 size_int
= XFASTINT (o
->total_lines
) >> 1;
4117 CHECK_NUMBER (size
);
4118 size_int
= XINT (size
);
4121 if (MINI_WINDOW_P (o
))
4122 error ("Attempt to split minibuffer window");
4123 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
4124 error ("Attempt to split fixed-size window");
4126 check_min_window_sizes ();
4130 int window_safe_height
= window_min_size_2 (o
, 0);
4132 if (size_int
< window_safe_height
)
4133 error ("Window height %d too small (after splitting)", size_int
);
4134 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
4135 error ("Window height %d too small (after splitting)",
4136 XFASTINT (o
->total_lines
) - size_int
);
4137 if (NILP (o
->parent
)
4138 || NILP (XWINDOW (o
->parent
)->vchild
))
4140 make_dummy_parent (window
);
4142 XWINDOW (new)->vchild
= window
;
4147 int window_safe_width
= window_min_size_2 (o
, 1);
4149 if (size_int
< window_safe_width
)
4150 error ("Window width %d too small (after splitting)", size_int
);
4151 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
4152 error ("Window width %d too small (after splitting)",
4153 XFASTINT (o
->total_cols
) - size_int
);
4154 if (NILP (o
->parent
)
4155 || NILP (XWINDOW (o
->parent
)->hchild
))
4157 make_dummy_parent (window
);
4159 XWINDOW (new)->hchild
= window
;
4163 /* Now we know that window's parent is a vertical combination
4164 if we are dividing vertically, or a horizontal combination
4165 if we are making side-by-side windows */
4167 windows_or_buffers_changed
++;
4168 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
4169 new = make_window ();
4172 p
->frame
= o
->frame
;
4174 if (!NILP (p
->next
))
4175 XWINDOW (p
->next
)->prev
= new;
4178 p
->parent
= o
->parent
;
4180 p
->window_end_valid
= Qnil
;
4181 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
4183 /* Duplicate special geometry settings. */
4185 p
->left_margin_cols
= o
->left_margin_cols
;
4186 p
->right_margin_cols
= o
->right_margin_cols
;
4187 p
->left_fringe_width
= o
->left_fringe_width
;
4188 p
->right_fringe_width
= o
->right_fringe_width
;
4189 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
4190 p
->scroll_bar_width
= o
->scroll_bar_width
;
4191 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
4193 /* Apportion the available frame space among the two new windows */
4195 if (!NILP (horflag
))
4197 p
->total_lines
= o
->total_lines
;
4198 p
->top_line
= o
->top_line
;
4199 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
4200 XSETFASTINT (o
->total_cols
, size_int
);
4201 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
4202 adjust_window_margins (p
);
4203 adjust_window_margins (o
);
4207 p
->left_col
= o
->left_col
;
4208 p
->total_cols
= o
->total_cols
;
4209 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
4210 XSETFASTINT (o
->total_lines
, size_int
);
4211 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
4214 /* Adjust glyph matrices. */
4217 Fset_window_buffer (new, o
->buffer
, Qt
);
4221 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
4222 doc
: /* Make current window ARG lines bigger.
4223 From program, optional second arg non-nil means grow sideways ARG columns.
4224 Interactively, if an argument is not given, make the window one line bigger.
4225 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
4226 This function can delete windows, even the second window, if they get
4229 Lisp_Object arg
, horizontal
;
4232 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
4234 run_window_configuration_change_hook (SELECTED_FRAME ());
4239 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
4240 doc
: /* Make current window ARG lines smaller.
4241 From program, optional second arg non-nil means shrink sideways arg columns.
4242 Interactively, if an argument is not given, make the window one line smaller.
4243 Only siblings to the right or below are changed. */)
4245 Lisp_Object arg
, side
;
4248 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
4250 run_window_configuration_change_hook (SELECTED_FRAME ());
4256 window_height (window
)
4259 register struct window
*p
= XWINDOW (window
);
4260 return WINDOW_TOTAL_LINES (p
);
4264 window_width (window
)
4267 register struct window
*p
= XWINDOW (window
);
4268 return WINDOW_TOTAL_COLS (p
);
4273 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4275 #define CURSIZE(w) \
4276 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4279 /* Enlarge WINDOW by DELTA.
4280 HORIZ_FLAG nonzero means enlarge it horizontally;
4281 zero means do it vertically.
4283 Siblings of the selected window are resized to fulfill the size
4284 request. If they become too small in the process, they will be
4288 enlarge_window (window
, delta
, horiz_flag
)
4290 int delta
, horiz_flag
;
4292 Lisp_Object parent
, next
, prev
;
4296 int (*sizefun
) P_ ((Lisp_Object
))
4297 = horiz_flag
? window_width
: window_height
;
4298 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
4299 = (horiz_flag
? set_window_width
: set_window_height
);
4301 /* Check values of window_min_width and window_min_height for
4303 check_min_window_sizes ();
4305 /* Give up if this window cannot be resized. */
4306 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4307 error ("Window is not resizable");
4309 /* Find the parent of the selected window. */
4312 p
= XWINDOW (window
);
4318 error ("No other window to side of this one");
4323 ? !NILP (XWINDOW (parent
)->hchild
)
4324 : !NILP (XWINDOW (parent
)->vchild
))
4330 sizep
= &CURSIZE (window
);
4333 register int maxdelta
;
4335 /* Compute the maximum size increment this window can have. */
4337 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4338 /* This is a main window followed by a minibuffer. */
4339 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4340 - window_min_size (XWINDOW (p
->next
),
4342 /* This is a minibuffer following a main window. */
4343 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4344 - window_min_size (XWINDOW (p
->prev
),
4346 /* This is a frame with only one window, a minibuffer-only
4347 or a minibufferless frame. */
4350 if (delta
> maxdelta
)
4351 /* This case traps trying to make the minibuffer
4352 the full frame, or make the only window aside from the
4353 minibuffer the full frame. */
4357 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4359 delete_window (window
);
4366 /* Find the total we can get from other siblings without deleting them. */
4368 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4369 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4371 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4372 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4375 /* If we can get it all from them without deleting them, do so. */
4376 if (delta
<= maximum
)
4378 Lisp_Object first_unaffected
;
4379 Lisp_Object first_affected
;
4384 first_affected
= window
;
4385 /* Look at one sibling at a time,
4386 moving away from this window in both directions alternately,
4387 and take as much as we can get without deleting that sibling. */
4389 && (!NILP (next
) || !NILP (prev
)))
4393 int this_one
= ((*sizefun
) (next
)
4394 - window_min_size (XWINDOW (next
),
4395 horiz_flag
, 0, &fixed_p
));
4398 if (this_one
> delta
)
4401 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4402 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4407 next
= XWINDOW (next
)->next
;
4415 int this_one
= ((*sizefun
) (prev
)
4416 - window_min_size (XWINDOW (prev
),
4417 horiz_flag
, 0, &fixed_p
));
4420 if (this_one
> delta
)
4423 first_affected
= prev
;
4425 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4426 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4431 prev
= XWINDOW (prev
)->prev
;
4435 xassert (delta
== 0);
4437 /* Now recalculate the edge positions of all the windows affected,
4438 based on the new sizes. */
4439 first_unaffected
= next
;
4440 prev
= first_affected
;
4441 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4442 prev
= next
, next
= XWINDOW (next
)->next
)
4444 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4445 /* This does not change size of NEXT,
4446 but it propagates the new top edge to its children */
4447 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4452 register int delta1
;
4453 register int opht
= (*sizefun
) (parent
);
4455 if (opht
<= XINT (*sizep
) + delta
)
4457 /* If trying to grow this window to or beyond size of the parent,
4458 just delete all the sibling windows. */
4459 Lisp_Object start
, tem
, next
;
4461 start
= XWINDOW (parent
)->vchild
;
4463 start
= XWINDOW (parent
)->hchild
;
4465 /* Delete any siblings that come after WINDOW. */
4466 tem
= XWINDOW (window
)->next
;
4467 while (! NILP (tem
))
4469 next
= XWINDOW (tem
)->next
;
4470 delete_window (tem
);
4474 /* Delete any siblings that come after WINDOW.
4475 Note that if START is not WINDOW, then WINDOW still
4476 Fhas siblings, so WINDOW has not yet replaced its parent. */
4478 while (! EQ (tem
, window
))
4480 next
= XWINDOW (tem
)->next
;
4481 delete_window (tem
);
4487 /* Otherwise, make delta1 just right so that if we add
4488 delta1 lines to this window and to the parent, and then
4489 shrink the parent back to its original size, the new
4490 proportional size of this window will increase by delta.
4492 The function size_window will compute the new height h'
4493 of the window from delta1 as:
4496 x = delta1 - delta1/n * n for the 1st resizable child
4499 where n is the number of children that can be resized.
4500 We can ignore x by choosing a delta1 that is a multiple of
4501 n. We want the height of this window to come out as
4511 The number of children n equals the number of resizable
4512 children of this window + 1 because we know window itself
4513 is resizable (otherwise we would have signalled an error). */
4515 struct window
*w
= XWINDOW (window
);
4519 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4520 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4522 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4523 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4528 /* Add delta1 lines or columns to this window, and to the parent,
4529 keeping things consistent while not affecting siblings. */
4530 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4531 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4533 /* Squeeze out delta1 lines or columns from our parent,
4534 shriking this window and siblings proportionately.
4535 This brings parent back to correct size.
4536 Delta1 was calculated so this makes this window the desired size,
4537 taking it all out of the siblings. */
4538 (*setsizefun
) (parent
, opht
, 0);
4543 XSETFASTINT (p
->last_modified
, 0);
4544 XSETFASTINT (p
->last_overlay_modified
, 0);
4546 /* Adjust glyph matrices. */
4547 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4551 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4552 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4553 zero means adjust the height, moving the bottom edge.
4555 Following siblings of the selected window are resized to fulfill
4556 the size request. If they become too small in the process, they
4557 are not deleted; instead, we signal an error. */
4560 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4562 int delta
, horiz_flag
;
4564 Lisp_Object parent
, child
;
4566 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4567 int delcount
= window_deletion_count
;
4569 /* Check values of window_min_width and window_min_height for
4571 check_min_window_sizes ();
4573 CHECK_WINDOW (window
);
4575 /* Give up if this window cannot be resized. */
4576 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4577 error ("Window is not resizable");
4581 Lisp_Object first_parallel
= Qnil
;
4585 /* This happens if WINDOW on the previous iteration was
4586 at top level of the window tree. */
4587 Fset_window_configuration (old_config
);
4588 error ("Specified window edge is fixed");
4591 p
= XWINDOW (window
);
4594 /* See if this level has windows in parallel in the specified
4595 direction. If so, set FIRST_PARALLEL to the first one. */
4598 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4599 first_parallel
= XWINDOW (parent
)->vchild
;
4600 else if (NILP (parent
) && !NILP (p
->next
))
4602 /* Handle the vertical chain of main window and minibuffer
4603 which has no parent. */
4604 first_parallel
= window
;
4605 while (! NILP (XWINDOW (first_parallel
)->prev
))
4606 first_parallel
= XWINDOW (first_parallel
)->prev
;
4611 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4612 first_parallel
= XWINDOW (parent
)->hchild
;
4615 /* If this level's succession is in the desired dimension,
4616 and this window is the last one, and there is no higher level,
4617 its trailing edge is fixed. */
4618 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4621 Fset_window_configuration (old_config
);
4622 error ("Specified window edge is fixed");
4625 /* Don't make this window too small. */
4626 if (XINT (CURSIZE (window
)) + delta
4627 < window_min_size_2 (XWINDOW (window
), horiz_flag
))
4629 Fset_window_configuration (old_config
);
4630 error ("Cannot adjust window size as specified");
4633 /* Clear out some redisplay caches. */
4634 XSETFASTINT (p
->last_modified
, 0);
4635 XSETFASTINT (p
->last_overlay_modified
, 0);
4637 /* Adjust this window's edge. */
4638 XSETINT (CURSIZE (window
),
4639 XINT (CURSIZE (window
)) + delta
);
4641 /* If this window has following siblings in the desired dimension,
4642 make them smaller, and exit the loop.
4644 (If we reach the top of the tree and can never do this,
4645 we will fail and report an error, above.) */
4646 if (NILP (first_parallel
))
4648 if (!NILP (p
->next
))
4650 /* This may happen for the minibuffer. In that case
4651 the window_deletion_count check below does not work. */
4652 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4654 Fset_window_configuration (old_config
);
4655 error ("Cannot adjust window size as specified");
4658 XSETINT (CURBEG (p
->next
),
4659 XINT (CURBEG (p
->next
)) + delta
);
4660 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4661 horiz_flag
, 0, 1, 0);
4666 /* Here we have a chain of parallel siblings, in the other dimension.
4667 Change the size of the other siblings. */
4668 for (child
= first_parallel
;
4670 child
= XWINDOW (child
)->next
)
4671 if (! EQ (child
, window
))
4672 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4673 horiz_flag
, 0, 0, 1);
4678 /* If we made a window so small it got deleted,
4679 we failed. Report failure. */
4680 if (delcount
!= window_deletion_count
)
4682 Fset_window_configuration (old_config
);
4683 error ("Cannot adjust window size as specified");
4686 /* Adjust glyph matrices. */
4687 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4693 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4694 Sadjust_window_trailing_edge
, 3, 3, 0,
4695 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4696 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4697 Otherwise, adjust the height, moving the bottom edge.
4699 Following siblings of the selected window are resized to fulfill
4700 the size request. If they become too small in the process, they
4701 are not deleted; instead, we signal an error. */)
4702 (window
, delta
, horizontal
)
4703 Lisp_Object window
, delta
, horizontal
;
4705 CHECK_NUMBER (delta
);
4707 window
= selected_window
;
4708 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4710 run_window_configuration_change_hook
4711 (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4718 /***********************************************************************
4719 Resizing Mini-Windows
4720 ***********************************************************************/
4722 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4724 enum save_restore_action
4731 static int save_restore_orig_size
P_ ((struct window
*,
4732 enum save_restore_action
));
4734 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4735 from lowest windows first. */
4738 shrink_window_lowest_first (w
, height
)
4746 xassert (!MINI_WINDOW_P (w
));
4748 /* Set redisplay hints. */
4749 XSETFASTINT (w
->last_modified
, 0);
4750 XSETFASTINT (w
->last_overlay_modified
, 0);
4751 windows_or_buffers_changed
++;
4752 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4754 old_height
= XFASTINT (w
->total_lines
);
4755 XSETFASTINT (w
->total_lines
, height
);
4757 if (!NILP (w
->hchild
))
4759 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4761 c
= XWINDOW (child
);
4762 c
->top_line
= w
->top_line
;
4763 shrink_window_lowest_first (c
, height
);
4766 else if (!NILP (w
->vchild
))
4768 Lisp_Object last_child
;
4769 int delta
= old_height
- height
;
4774 /* Find the last child. We are taking space from lowest windows
4775 first, so we iterate over children from the last child
4777 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4780 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4781 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4785 c
= XWINDOW (child
);
4786 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4788 if (this_one
> delta
)
4791 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4795 /* Compute new positions. */
4796 last_top
= XINT (w
->top_line
);
4797 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4799 c
= XWINDOW (child
);
4800 c
->top_line
= make_number (last_top
);
4801 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4802 last_top
+= XFASTINT (c
->total_lines
);
4808 /* Save, restore, or check positions and sizes in the window tree
4809 rooted at W. ACTION says what to do.
4811 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4812 orig_total_lines members are valid for all windows in the window
4813 tree. Value is non-zero if they are valid.
4815 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4816 orig_top_line and orig_total_lines for all windows in the tree.
4818 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4819 stored in orig_top_line and orig_total_lines for all windows. */
4822 save_restore_orig_size (w
, action
)
4824 enum save_restore_action action
;
4830 if (!NILP (w
->hchild
))
4832 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4835 else if (!NILP (w
->vchild
))
4837 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4843 case CHECK_ORIG_SIZES
:
4844 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4848 case SAVE_ORIG_SIZES
:
4849 w
->orig_top_line
= w
->top_line
;
4850 w
->orig_total_lines
= w
->total_lines
;
4851 XSETFASTINT (w
->last_modified
, 0);
4852 XSETFASTINT (w
->last_overlay_modified
, 0);
4855 case RESTORE_ORIG_SIZES
:
4856 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4857 w
->top_line
= w
->orig_top_line
;
4858 w
->total_lines
= w
->orig_total_lines
;
4859 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4860 XSETFASTINT (w
->last_modified
, 0);
4861 XSETFASTINT (w
->last_overlay_modified
, 0);
4868 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4875 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4876 without deleting other windows. */
4879 grow_mini_window (w
, delta
)
4883 struct frame
*f
= XFRAME (w
->frame
);
4884 struct window
*root
;
4886 xassert (MINI_WINDOW_P (w
));
4887 xassert (delta
>= 0);
4889 /* Check values of window_min_width and window_min_height for
4891 check_min_window_sizes ();
4893 /* Compute how much we can enlarge the mini-window without deleting
4895 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4898 int min_height
= window_min_size (root
, 0, 0, 0);
4899 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4900 /* Note that the root window may already be smaller than
4902 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4907 /* Save original window sizes and positions, if not already done. */
4908 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4909 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4911 /* Shrink other windows. */
4912 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4914 /* Grow the mini-window. */
4915 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4916 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4917 XSETFASTINT (w
->last_modified
, 0);
4918 XSETFASTINT (w
->last_overlay_modified
, 0);
4925 /* Shrink mini-window W. If there is recorded info about window sizes
4926 before a call to grow_mini_window, restore recorded window sizes.
4927 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4931 shrink_mini_window (w
)
4934 struct frame
*f
= XFRAME (w
->frame
);
4935 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4937 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4939 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4941 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4942 windows_or_buffers_changed
= 1;
4944 else if (XFASTINT (w
->total_lines
) > 1)
4946 /* Distribute the additional lines of the mini-window
4947 among the other windows. */
4949 XSETWINDOW (window
, w
);
4950 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4956 /* Mark window cursors off for all windows in the window tree rooted
4957 at W by setting their phys_cursor_on_p flag to zero. Called from
4958 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4959 the frame are cleared. */
4962 mark_window_cursors_off (w
)
4967 if (!NILP (w
->hchild
))
4968 mark_window_cursors_off (XWINDOW (w
->hchild
));
4969 else if (!NILP (w
->vchild
))
4970 mark_window_cursors_off (XWINDOW (w
->vchild
));
4972 w
->phys_cursor_on_p
= 0;
4974 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4979 /* Return number of lines of text (not counting mode lines) in W. */
4982 window_internal_height (w
)
4985 int ht
= XFASTINT (w
->total_lines
);
4987 if (!MINI_WINDOW_P (w
))
4989 if (!NILP (w
->parent
)
4990 || !NILP (w
->vchild
)
4991 || !NILP (w
->hchild
)
4994 || WINDOW_WANTS_MODELINE_P (w
))
4997 if (WINDOW_WANTS_HEADER_LINE_P (w
))
5005 /* Return the number of columns in W.
5006 Don't count columns occupied by scroll bars or the vertical bar
5007 separating W from the sibling to its right. */
5010 window_box_text_cols (w
)
5013 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5014 int width
= XINT (w
->total_cols
);
5016 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
5017 /* Scroll bars occupy a few columns. */
5018 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
5019 else if (!FRAME_WINDOW_P (f
)
5020 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
5021 /* The column of `|' characters separating side-by-side windows
5022 occupies one column only. */
5025 if (FRAME_WINDOW_P (f
))
5026 /* On window-systems, fringes and display margins cannot be
5027 used for normal text. */
5028 width
-= (WINDOW_FRINGE_COLS (w
)
5029 + WINDOW_LEFT_MARGIN_COLS (w
)
5030 + WINDOW_RIGHT_MARGIN_COLS (w
));
5036 /************************************************************************
5038 ***********************************************************************/
5040 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
5041 N screen-fulls, which is defined as the height of the window minus
5042 next_screen_context_lines. If WHOLE is zero, scroll up N lines
5043 instead. Negative values of N mean scroll down. NOERROR non-zero
5044 means don't signal an error if we try to move over BEGV or ZV,
5048 window_scroll (window
, n
, whole
, noerror
)
5056 /* If we must, use the pixel-based version which is much slower than
5057 the line-based one but can handle varying line heights. */
5058 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
5059 window_scroll_pixel_based (window
, n
, whole
, noerror
);
5061 window_scroll_line_based (window
, n
, whole
, noerror
);
5067 /* Implementation of window_scroll that works based on pixel line
5068 heights. See the comment of window_scroll for parameter
5072 window_scroll_pixel_based (window
, n
, whole
, noerror
)
5079 struct window
*w
= XWINDOW (window
);
5080 struct text_pos start
;
5081 int this_scroll_margin
;
5082 /* True if we fiddled the window vscroll field without really scrolling. */
5084 int x
, y
, rtop
, rbot
, rowh
, vpos
;
5086 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5088 /* If PT is not visible in WINDOW, move back one half of
5089 the screen. Allow PT to be partially visible, otherwise
5090 something like (scroll-down 1) with PT in the line before
5091 the partially visible one would recenter. */
5093 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
5095 /* Move backward half the height of the window. Performance note:
5096 vmotion used here is about 10% faster, but would give wrong
5097 results for variable height lines. */
5098 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
5099 it
.current_y
= it
.last_visible_y
;
5100 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5102 /* The function move_iterator_vertically may move over more than
5103 the specified y-distance. If it->w is small, e.g. a
5104 mini-buffer window, we may end up in front of the window's
5105 display area. This is the case when Start displaying at the
5106 start of the line containing PT in this case. */
5107 if (it
.current_y
<= 0)
5109 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
5110 move_it_vertically_backward (&it
, 0);
5114 start
= it
.current
.pos
;
5116 else if (auto_window_vscroll_p
)
5118 if (rtop
|| rbot
) /* partially visible */
5121 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5123 dy
= max ((window_box_height (w
)
5124 - next_screen_context_lines
* dy
),
5130 /* Only vscroll backwards if already vscrolled forwards. */
5131 if (w
->vscroll
< 0 && rtop
> 0)
5133 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
5134 Fset_window_vscroll (window
, make_number (px
), Qt
);
5140 /* Do vscroll if already vscrolled or only display line. */
5141 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
5143 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
5144 Fset_window_vscroll (window
, make_number (px
), Qt
);
5148 /* Maybe modify window start instead of scrolling. */
5149 if (rbot
> 0 || w
->vscroll
< 0)
5153 Fset_window_vscroll (window
, make_number (0), Qt
);
5154 /* If there are other text lines above the current row,
5155 move window start to current row. Else to next row. */
5157 spos
= XINT (Fline_beginning_position (Qnil
));
5159 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
5160 set_marker_restricted (w
->start
, make_number (spos
),
5162 w
->start_at_line_beg
= Qt
;
5163 w
->update_mode_line
= Qt
;
5164 XSETFASTINT (w
->last_modified
, 0);
5165 XSETFASTINT (w
->last_overlay_modified
, 0);
5166 /* Set force_start so that redisplay_window will run the
5167 window-scroll-functions. */
5168 w
->force_start
= Qt
;
5173 /* Cancel previous vscroll. */
5174 Fset_window_vscroll (window
, make_number (0), Qt
);
5177 /* If scroll_preserve_screen_position is non-nil, we try to set
5178 point in the same window line as it is now, so get that line. */
5179 if (!NILP (Vscroll_preserve_screen_position
))
5181 /* We preserve the goal pixel coordinate across consecutive
5182 calls to scroll-up or scroll-down. This avoids the
5183 possibility of point becoming "stuck" on a tall line when
5184 scrolling by one line. */
5185 if (window_scroll_pixel_based_preserve_y
< 0
5186 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5187 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5189 start_display (&it
, w
, start
);
5190 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5191 window_scroll_pixel_based_preserve_y
= it
.current_y
;
5195 window_scroll_pixel_based_preserve_y
= -1;
5197 /* Move iterator it from start the specified distance forward or
5198 backward. The result is the new window start. */
5199 start_display (&it
, w
, start
);
5202 int start_pos
= IT_CHARPOS (it
);
5203 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5204 dy
= max ((window_box_height (w
)
5205 - next_screen_context_lines
* dy
),
5208 /* Note that move_it_vertically always moves the iterator to the
5209 start of a line. So, if the last line doesn't have a newline,
5210 we would end up at the start of the line ending at ZV. */
5213 move_it_vertically_backward (&it
, -dy
);
5214 /* Ensure we actually do move, e.g. in case we are currently
5215 looking at an image that is taller that the window height. */
5216 while (start_pos
== IT_CHARPOS (it
)
5217 && start_pos
> BEGV
)
5218 move_it_by_lines (&it
, -1, 1);
5222 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
5223 MOVE_TO_POS
| MOVE_TO_Y
);
5224 /* Ensure we actually do move, e.g. in case we are currently
5225 looking at an image that is taller that the window height. */
5226 while (start_pos
== IT_CHARPOS (it
)
5228 move_it_by_lines (&it
, 1, 1);
5232 move_it_by_lines (&it
, n
, 1);
5234 /* We failed if we find ZV is already on the screen (scrolling up,
5235 means there's nothing past the end), or if we can't start any
5236 earlier (scrolling down, means there's nothing past the top). */
5237 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
5238 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
5240 if (IT_CHARPOS (it
) == ZV
)
5242 if (it
.current_y
< it
.last_visible_y
5243 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
5244 > it
.last_visible_y
))
5246 /* The last line was only partially visible, make it fully
5248 w
->vscroll
= (it
.last_visible_y
5249 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
5250 adjust_glyphs (it
.f
);
5254 else if (n
< 0) /* could happen with empty buffers */
5255 xsignal0 (Qbeginning_of_buffer
);
5257 xsignal0 (Qend_of_buffer
);
5261 if (w
->vscroll
!= 0)
5262 /* The first line was only partially visible, make it fully
5268 xsignal0 (Qbeginning_of_buffer
);
5271 /* If control gets here, then we vscrolled. */
5273 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5275 /* Don't try to change the window start below. */
5281 int pos
= IT_CHARPOS (it
);
5284 /* If in the middle of a multi-glyph character move forward to
5285 the next character. */
5286 if (in_display_vector_p (&it
))
5289 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5292 /* Set the window start, and set up the window for redisplay. */
5293 set_marker_restricted (w
->start
, make_number (pos
),
5295 bytepos
= XMARKER (w
->start
)->bytepos
;
5296 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5298 w
->update_mode_line
= Qt
;
5299 XSETFASTINT (w
->last_modified
, 0);
5300 XSETFASTINT (w
->last_overlay_modified
, 0);
5301 /* Set force_start so that redisplay_window will run the
5302 window-scroll-functions. */
5303 w
->force_start
= Qt
;
5306 /* The rest of this function uses current_y in a nonstandard way,
5307 not including the height of the header line if any. */
5308 it
.current_y
= it
.vpos
= 0;
5310 /* Move PT out of scroll margins.
5311 This code wants current_y to be zero at the window start position
5312 even if there is a header line. */
5313 this_scroll_margin
= max (0, scroll_margin
);
5314 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5315 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5319 /* We moved the window start towards ZV, so PT may be now
5320 in the scroll margin at the top. */
5321 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5322 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5323 && (NILP (Vscroll_preserve_screen_position
)
5324 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5325 /* We found PT at a legitimate height. Leave it alone. */
5327 else if (window_scroll_pixel_based_preserve_y
>= 0)
5329 /* If we have a header line, take account of it.
5330 This is necessary because we set it.current_y to 0, above. */
5331 move_it_to (&it
, -1, -1,
5332 window_scroll_pixel_based_preserve_y
5333 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5335 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5339 while (it
.current_y
< this_scroll_margin
)
5341 int prev
= it
.current_y
;
5342 move_it_by_lines (&it
, 1, 1);
5343 if (prev
== it
.current_y
)
5346 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5351 int charpos
, bytepos
;
5354 /* Save our position, for the
5355 window_scroll_pixel_based_preserve_y case. */
5356 charpos
= IT_CHARPOS (it
);
5357 bytepos
= IT_BYTEPOS (it
);
5359 /* We moved the window start towards BEGV, so PT may be now
5360 in the scroll margin at the bottom. */
5361 move_it_to (&it
, PT
, -1,
5362 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5363 - this_scroll_margin
- 1),
5365 MOVE_TO_POS
| MOVE_TO_Y
);
5367 /* Save our position, in case it's correct. */
5368 charpos
= IT_CHARPOS (it
);
5369 bytepos
= IT_BYTEPOS (it
);
5371 /* See if point is on a partially visible line at the end. */
5372 if (it
.what
== IT_EOB
)
5373 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5376 move_it_by_lines (&it
, 1, 1);
5377 partial_p
= it
.current_y
> it
.last_visible_y
;
5380 if (charpos
== PT
&& !partial_p
5381 && (NILP (Vscroll_preserve_screen_position
)
5382 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5383 /* We found PT before we found the display margin, so PT is ok. */
5385 else if (window_scroll_pixel_based_preserve_y
>= 0)
5387 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5388 start_display (&it
, w
, start
);
5389 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5390 here because we called start_display again and did not
5391 alter it.current_y this time. */
5392 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5394 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5399 /* The last line was only partially visible, so back up two
5400 lines to make sure we're on a fully visible line. */
5402 move_it_by_lines (&it
, -2, 0);
5403 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5406 /* No, the position we saved is OK, so use it. */
5407 SET_PT_BOTH (charpos
, bytepos
);
5413 /* Implementation of window_scroll that works based on screen lines.
5414 See the comment of window_scroll for parameter descriptions. */
5417 window_scroll_line_based (window
, n
, whole
, noerror
)
5423 register struct window
*w
= XWINDOW (window
);
5424 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5425 register int pos
, pos_byte
;
5426 register int ht
= window_internal_height (w
);
5427 register Lisp_Object tem
;
5431 struct position posit
;
5434 /* If scrolling screen-fulls, compute the number of lines to
5435 scroll from the window's height. */
5437 n
*= max (1, ht
- next_screen_context_lines
);
5439 startpos
= marker_position (w
->start
);
5441 posit
= *compute_motion (startpos
, 0, 0, 0,
5443 -1, XINT (w
->hscroll
),
5445 original_vpos
= posit
.vpos
;
5447 XSETFASTINT (tem
, PT
);
5448 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5452 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5457 lose
= n
< 0 && PT
== BEGV
;
5458 Fvertical_motion (make_number (n
), window
);
5462 SET_PT_BOTH (opoint
, opoint_byte
);
5469 xsignal0 (Qbeginning_of_buffer
);
5474 int this_scroll_margin
= scroll_margin
;
5476 /* Don't use a scroll margin that is negative or too large. */
5477 if (this_scroll_margin
< 0)
5478 this_scroll_margin
= 0;
5480 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5481 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5483 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5484 w
->start_at_line_beg
= bolp
;
5485 w
->update_mode_line
= Qt
;
5486 XSETFASTINT (w
->last_modified
, 0);
5487 XSETFASTINT (w
->last_overlay_modified
, 0);
5488 /* Set force_start so that redisplay_window will run
5489 the window-scroll-functions. */
5490 w
->force_start
= Qt
;
5492 if (!NILP (Vscroll_preserve_screen_position
)
5493 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5495 SET_PT_BOTH (pos
, pos_byte
);
5496 Fvertical_motion (make_number (original_vpos
), window
);
5498 /* If we scrolled forward, put point enough lines down
5499 that it is outside the scroll margin. */
5504 if (this_scroll_margin
> 0)
5506 SET_PT_BOTH (pos
, pos_byte
);
5507 Fvertical_motion (make_number (this_scroll_margin
), window
);
5513 if (top_margin
<= opoint
)
5514 SET_PT_BOTH (opoint
, opoint_byte
);
5515 else if (!NILP (Vscroll_preserve_screen_position
))
5517 SET_PT_BOTH (pos
, pos_byte
);
5518 Fvertical_motion (make_number (original_vpos
), window
);
5521 SET_PT (top_margin
);
5527 /* If we scrolled backward, put point near the end of the window
5528 but not within the scroll margin. */
5529 SET_PT_BOTH (pos
, pos_byte
);
5530 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5531 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5534 bottom_margin
= PT
+ 1;
5536 if (bottom_margin
> opoint
)
5537 SET_PT_BOTH (opoint
, opoint_byte
);
5540 if (!NILP (Vscroll_preserve_screen_position
))
5542 SET_PT_BOTH (pos
, pos_byte
);
5543 Fvertical_motion (make_number (original_vpos
), window
);
5546 Fvertical_motion (make_number (-1), window
);
5555 xsignal0 (Qend_of_buffer
);
5560 /* Scroll selected_window up or down. If N is nil, scroll a
5561 screen-full which is defined as the height of the window minus
5562 next_screen_context_lines. If N is the symbol `-', scroll.
5563 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5564 up. This is the guts of Fscroll_up and Fscroll_down. */
5567 scroll_command (n
, direction
)
5571 int count
= SPECPDL_INDEX ();
5573 xassert (eabs (direction
) == 1);
5575 /* If selected window's buffer isn't current, make it current for
5576 the moment. But don't screw up if window_scroll gets an error. */
5577 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5579 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5580 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5582 /* Make redisplay consider other windows than just selected_window. */
5583 ++windows_or_buffers_changed
;
5587 window_scroll (selected_window
, direction
, 1, 0);
5588 else if (EQ (n
, Qminus
))
5589 window_scroll (selected_window
, -direction
, 1, 0);
5592 n
= Fprefix_numeric_value (n
);
5593 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5596 unbind_to (count
, Qnil
);
5599 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5600 doc
: /* Scroll text of current window upward ARG lines.
5601 If ARG is omitted or nil, scroll upward by a near full screen.
5602 A near full screen is `next-screen-context-lines' less than a full screen.
5603 Negative ARG means scroll downward.
5604 If ARG is the atom `-', scroll downward by nearly full screen.
5605 When calling from a program, supply as argument a number, nil, or `-'. */)
5609 scroll_command (arg
, 1);
5613 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5614 doc
: /* Scroll text of current window down ARG lines.
5615 If ARG is omitted or nil, scroll down by a near full screen.
5616 A near full screen is `next-screen-context-lines' less than a full screen.
5617 Negative ARG means scroll upward.
5618 If ARG is the atom `-', scroll upward by nearly full screen.
5619 When calling from a program, supply as argument a number, nil, or `-'. */)
5623 scroll_command (arg
, -1);
5627 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5628 doc
: /* Return the other window for \"other window scroll\" commands.
5629 If `other-window-scroll-buffer' is non-nil, a window
5630 showing that buffer is used.
5631 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5632 specifies the window. This takes precedence over
5633 `other-window-scroll-buffer'. */)
5638 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5639 && !NILP (Vminibuf_scroll_window
))
5640 window
= Vminibuf_scroll_window
;
5641 /* If buffer is specified, scroll that buffer. */
5642 else if (!NILP (Vother_window_scroll_buffer
))
5644 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5646 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5650 /* Nothing specified; look for a neighboring window on the same
5652 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5654 if (EQ (window
, selected_window
))
5655 /* That didn't get us anywhere; look for a window on another
5658 window
= Fnext_window (window
, Qnil
, Qt
);
5659 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5660 && ! EQ (window
, selected_window
));
5663 CHECK_LIVE_WINDOW (window
);
5665 if (EQ (window
, selected_window
))
5666 error ("There is no other window");
5671 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5672 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5673 A near full screen is `next-screen-context-lines' less than a full screen.
5674 The next window is the one below the current one; or the one at the top
5675 if the current one is at the bottom. Negative ARG means scroll downward.
5676 If ARG is the atom `-', scroll downward by nearly full screen.
5677 When calling from a program, supply as argument a number, nil, or `-'.
5679 If `other-window-scroll-buffer' is non-nil, scroll the window
5680 showing that buffer, popping the buffer up if necessary.
5681 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5682 specifies the window to scroll. This takes precedence over
5683 `other-window-scroll-buffer'. */)
5689 int count
= SPECPDL_INDEX ();
5691 window
= Fother_window_for_scrolling ();
5692 w
= XWINDOW (window
);
5694 /* Don't screw up if window_scroll gets an error. */
5695 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5696 ++windows_or_buffers_changed
;
5698 Fset_buffer (w
->buffer
);
5699 SET_PT (marker_position (w
->pointm
));
5702 window_scroll (window
, 1, 1, 1);
5703 else if (EQ (arg
, Qminus
))
5704 window_scroll (window
, -1, 1, 1);
5710 window_scroll (window
, XINT (arg
), 0, 1);
5713 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5714 unbind_to (count
, Qnil
);
5719 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5720 doc
: /* Scroll selected window display ARG columns left.
5721 Default for ARG is window width minus 2.
5722 Value is the total amount of leftward horizontal scrolling in
5723 effect after the change.
5724 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5725 lower bound for automatic scrolling, i.e. automatic scrolling
5726 will not scroll a window to a column less than the value returned
5727 by this function. This happens in an interactive call. */)
5729 register Lisp_Object arg
, set_minimum
;
5733 struct window
*w
= XWINDOW (selected_window
);
5736 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5738 arg
= Fprefix_numeric_value (arg
);
5740 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5741 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5743 if (!NILP (set_minimum
))
5744 w
->min_hscroll
= w
->hscroll
;
5749 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5750 doc
: /* Scroll selected window display ARG columns right.
5751 Default for ARG is window width minus 2.
5752 Value is the total amount of leftward horizontal scrolling in
5753 effect after the change.
5754 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5755 lower bound for automatic scrolling, i.e. automatic scrolling
5756 will not scroll a window to a column less than the value returned
5757 by this function. This happens in an interactive call. */)
5759 register Lisp_Object arg
, set_minimum
;
5763 struct window
*w
= XWINDOW (selected_window
);
5766 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5768 arg
= Fprefix_numeric_value (arg
);
5770 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5771 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5773 if (!NILP (set_minimum
))
5774 w
->min_hscroll
= w
->hscroll
;
5779 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5780 doc
: /* Return the window which was selected when entering the minibuffer.
5781 Returns nil, if current window is not a minibuffer window. */)
5784 if (minibuf_level
> 0
5785 && MINI_WINDOW_P (XWINDOW (selected_window
))
5786 && WINDOW_LIVE_P (minibuf_selected_window
))
5787 return minibuf_selected_window
;
5792 /* Value is the number of lines actually displayed in window W,
5793 as opposed to its height. */
5796 displayed_window_lines (w
)
5800 struct text_pos start
;
5801 int height
= window_box_height (w
);
5802 struct buffer
*old_buffer
;
5805 if (XBUFFER (w
->buffer
) != current_buffer
)
5807 old_buffer
= current_buffer
;
5808 set_buffer_internal (XBUFFER (w
->buffer
));
5813 /* In case W->start is out of the accessible range, do something
5814 reasonable. This happens in Info mode when Info-scroll-down
5815 calls (recenter -1) while W->start is 1. */
5816 if (XMARKER (w
->start
)->charpos
< BEGV
)
5817 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5818 else if (XMARKER (w
->start
)->charpos
> ZV
)
5819 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5821 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5823 start_display (&it
, w
, start
);
5824 move_it_vertically (&it
, height
);
5825 bottom_y
= line_bottom_y (&it
);
5827 /* rms: On a non-window display,
5828 the value of it.vpos at the bottom of the screen
5829 seems to be 1 larger than window_box_height (w).
5830 This kludge fixes a bug whereby (move-to-window-line -1)
5831 when ZV is on the last screen line
5832 moves to the previous screen line instead of the last one. */
5833 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5836 /* Add in empty lines at the bottom of the window. */
5837 if (bottom_y
< height
)
5839 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5840 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5844 set_buffer_internal (old_buffer
);
5850 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5851 doc
: /* Center point in window and redisplay frame.
5852 With prefix argument ARG, recenter putting point on screen line ARG
5853 relative to the current window. If ARG is negative, it counts up from the
5854 bottom of the window. (ARG should be less than the height of the window.)
5856 If ARG is omitted or nil, erase the entire frame and then redraw with point
5857 in the center of the current window. If `auto-resize-tool-bars' is set to
5858 `grow-only', this resets the tool-bar's height to the minimum height needed.
5860 Just C-u as prefix means put point in the center of the window
5861 and redisplay normally--don't erase and redraw the frame. */)
5863 register Lisp_Object arg
;
5865 struct window
*w
= XWINDOW (selected_window
);
5866 struct buffer
*buf
= XBUFFER (w
->buffer
);
5867 struct buffer
*obuf
= current_buffer
;
5869 int charpos
, bytepos
;
5871 int this_scroll_margin
;
5873 /* If redisplay is suppressed due to an error, try again. */
5874 obuf
->display_error_modiff
= 0;
5880 /* Invalidate pixel data calculated for all compositions. */
5881 for (i
= 0; i
< n_compositions
; i
++)
5882 composition_table
[i
]->font
= NULL
;
5884 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5886 Fredraw_frame (WINDOW_FRAME (w
));
5887 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5890 else if (CONSP (arg
)) /* Just C-u. */
5894 arg
= Fprefix_numeric_value (arg
);
5899 set_buffer_internal (buf
);
5901 /* Do this after making BUF current
5902 in case scroll_margin is buffer-local. */
5903 this_scroll_margin
= max (0, scroll_margin
);
5904 this_scroll_margin
= min (this_scroll_margin
,
5905 XFASTINT (w
->total_lines
) / 4);
5907 /* Handle centering on a graphical frame specially. Such frames can
5908 have variable-height lines and centering point on the basis of
5909 line counts would lead to strange effects. */
5910 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5917 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5918 start_display (&it
, w
, pt
);
5919 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5920 charpos
= IT_CHARPOS (it
);
5921 bytepos
= IT_BYTEPOS (it
);
5928 int extra_line_spacing
;
5929 int h
= window_box_height (w
);
5931 iarg
= - max (-iarg
, this_scroll_margin
);
5933 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5934 start_display (&it
, w
, pt
);
5936 /* Be sure we have the exact height of the full line containing PT. */
5937 move_it_by_lines (&it
, 0, 1);
5939 /* The amount of pixels we have to move back is the window
5940 height minus what's displayed in the line containing PT,
5941 and the lines below. */
5944 move_it_by_lines (&it
, nlines
, 1);
5946 if (it
.vpos
== nlines
)
5950 /* Last line has no newline */
5951 h
-= line_bottom_y (&it
);
5955 /* Don't reserve space for extra line spacing of last line. */
5956 extra_line_spacing
= it
.max_extra_line_spacing
;
5958 /* If we can't move down NLINES lines because we hit
5959 the end of the buffer, count in some empty lines. */
5960 if (it
.vpos
< nlines
)
5963 extra_line_spacing
= it
.extra_line_spacing
;
5964 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5969 /* Now find the new top line (starting position) of the window. */
5970 start_display (&it
, w
, pt
);
5972 move_it_vertically_backward (&it
, h
);
5974 /* If extra line spacing is present, we may move too far
5975 back. This causes the last line to be only partially
5976 visible (which triggers redisplay to recenter that line
5977 in the middle), so move forward.
5978 But ignore extra line spacing on last line, as it is not
5979 considered to be part of the visible height of the line.
5981 h
+= extra_line_spacing
;
5982 while (-it
.current_y
> h
)
5983 move_it_by_lines (&it
, 1, 1);
5985 charpos
= IT_CHARPOS (it
);
5986 bytepos
= IT_BYTEPOS (it
);
5990 struct position pos
;
5992 iarg
= max (iarg
, this_scroll_margin
);
5994 pos
= *vmotion (PT
, -iarg
, w
);
5995 charpos
= pos
.bufpos
;
5996 bytepos
= pos
.bytepos
;
6001 struct position pos
;
6002 int ht
= window_internal_height (w
);
6009 /* Don't let it get into the margin at either top or bottom. */
6010 iarg
= max (iarg
, this_scroll_margin
);
6011 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
6013 pos
= *vmotion (PT
, - iarg
, w
);
6014 charpos
= pos
.bufpos
;
6015 bytepos
= pos
.bytepos
;
6018 /* Set the new window start. */
6019 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
6020 w
->window_end_valid
= Qnil
;
6022 w
->optional_new_start
= Qt
;
6024 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
6025 w
->start_at_line_beg
= Qt
;
6027 w
->start_at_line_beg
= Qnil
;
6029 set_buffer_internal (obuf
);
6034 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
6036 doc
: /* Return the height in lines of the text display area of WINDOW.
6037 WINDOW defaults to the selected window.
6038 This doesn't include the mode-line (or header-line if any) or any
6039 partial-height lines in the text display area. */)
6043 struct window
*w
= decode_window (window
);
6044 int pixel_height
= window_box_height (w
);
6045 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
6046 return make_number (line_height
);
6051 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
6053 doc
: /* Position point relative to window.
6054 With no argument, position point at center of window.
6055 An argument specifies vertical position within the window;
6056 zero means top of window, negative means relative to bottom of window. */)
6060 struct window
*w
= XWINDOW (selected_window
);
6064 int this_scroll_margin
;
6067 window
= selected_window
;
6068 start
= marker_position (w
->start
);
6069 if (start
< BEGV
|| start
> ZV
)
6071 int height
= window_internal_height (w
);
6072 Fvertical_motion (make_number (- (height
/ 2)), window
);
6073 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
6074 w
->start_at_line_beg
= Fbolp ();
6075 w
->force_start
= Qt
;
6078 Fgoto_char (w
->start
);
6080 lines
= displayed_window_lines (w
);
6083 this_scroll_margin
= max (0, scroll_margin
);
6084 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
6088 XSETFASTINT (arg
, lines
/ 2);
6091 int iarg
= XINT (Fprefix_numeric_value (arg
));
6094 iarg
= iarg
+ lines
;
6096 #if 0 /* This code would prevent move-to-window-line from moving point
6097 to a place inside the scroll margins (which would cause the
6098 next redisplay to scroll). I wrote this code, but then concluded
6099 it is probably better not to install it. However, it is here
6100 inside #if 0 so as not to lose it. -- rms. */
6102 /* Don't let it get into the margin at either top or bottom. */
6103 iarg
= max (iarg
, this_scroll_margin
);
6104 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
6107 arg
= make_number (iarg
);
6110 /* Skip past a partially visible first line. */
6112 XSETINT (arg
, XINT (arg
) + 1);
6114 return Fvertical_motion (arg
, window
);
6119 /***********************************************************************
6120 Window Configuration
6121 ***********************************************************************/
6123 struct save_window_data
6126 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6127 Lisp_Object selected_frame
;
6128 Lisp_Object current_window
;
6129 Lisp_Object current_buffer
;
6130 Lisp_Object minibuf_scroll_window
;
6131 Lisp_Object minibuf_selected_window
;
6132 Lisp_Object root_window
;
6133 Lisp_Object focus_frame
;
6134 /* A vector, each of whose elements is a struct saved_window
6136 Lisp_Object saved_windows
;
6138 /* All fields above are traced by the GC.
6139 From `fame-cols' down, the fields are ignored by the GC. */
6141 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
6142 int frame_tool_bar_lines
;
6143 /* Record the values of window-min-width and window-min-height
6144 so that window sizes remain consistent with them. */
6145 int min_width
, min_height
;
6148 /* This is saved as a Lisp_Vector */
6151 /* these first two must agree with struct Lisp_Vector in lisp.h */
6153 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6156 Lisp_Object buffer
, start
, pointm
, mark
;
6157 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
6158 Lisp_Object hscroll
, min_hscroll
;
6159 Lisp_Object parent
, prev
;
6160 Lisp_Object start_at_line_beg
;
6161 Lisp_Object display_table
;
6162 Lisp_Object orig_top_line
, orig_total_lines
;
6163 Lisp_Object left_margin_cols
, right_margin_cols
;
6164 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
6165 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
6166 Lisp_Object dedicated
;
6169 #define SAVED_WINDOW_N(swv,n) \
6170 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
6172 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
6173 doc
: /* Return t if OBJECT is a window-configuration object. */)
6177 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
6180 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
6181 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
6185 register struct save_window_data
*data
;
6186 struct Lisp_Vector
*saved_windows
;
6188 CHECK_WINDOW_CONFIGURATION (config
);
6190 data
= (struct save_window_data
*) XVECTOR (config
);
6191 saved_windows
= XVECTOR (data
->saved_windows
);
6192 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6195 DEFUN ("set-window-configuration", Fset_window_configuration
,
6196 Sset_window_configuration
, 1, 1, 0,
6197 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
6198 CONFIGURATION must be a value previously returned
6199 by `current-window-configuration' (which see).
6200 If CONFIGURATION was made from a frame that is now deleted,
6201 only frame-independent values can be restored. In this case,
6202 the return value is nil. Otherwise the value is t. */)
6204 Lisp_Object configuration
;
6206 register struct save_window_data
*data
;
6207 struct Lisp_Vector
*saved_windows
;
6208 Lisp_Object new_current_buffer
;
6213 CHECK_WINDOW_CONFIGURATION (configuration
);
6215 data
= (struct save_window_data
*) XVECTOR (configuration
);
6216 saved_windows
= XVECTOR (data
->saved_windows
);
6218 new_current_buffer
= data
->current_buffer
;
6219 if (NILP (XBUFFER (new_current_buffer
)->name
))
6220 new_current_buffer
= Qnil
;
6223 if (XBUFFER (new_current_buffer
) == current_buffer
)
6224 /* The code further down "preserves point" by saving here PT in
6225 old_point and then setting it later back into PT. When the
6226 current-selected-window and the final-selected-window both show
6227 the current buffer, this suffers from the problem that the
6228 current PT is the window-point of the current-selected-window,
6229 while the final PT is the point of the final-selected-window, so
6230 this copy from one PT to the other would end up moving the
6231 window-point of the final-selected-window to the window-point of
6232 the current-selected-window. So we have to be careful which
6233 point of the current-buffer we copy into old_point. */
6234 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6235 && WINDOWP (selected_window
)
6236 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
6237 && !EQ (selected_window
, data
->current_window
))
6238 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6242 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6243 point in new_current_buffer as of the last time this buffer was
6244 used. This can be non-deterministic since it can be changed by
6245 things like jit-lock by mere temporary selection of some random
6246 window that happens to show this buffer.
6247 So if possible we want this arbitrary choice of "which point" to
6248 be the one from the to-be-selected-window so as to prevent this
6249 window's cursor from being copied from another window. */
6250 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6251 /* If current_window = selected_window, its point is in BUF_PT. */
6252 && !EQ (selected_window
, data
->current_window
))
6253 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6255 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
6258 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6261 /* If f is a dead frame, don't bother rebuilding its window tree.
6262 However, there is other stuff we should still try to do below. */
6263 if (FRAME_LIVE_P (f
))
6265 register struct window
*w
;
6266 register struct saved_window
*p
;
6267 struct window
*root_window
;
6268 struct window
**leaf_windows
;
6272 /* If the frame has been resized since this window configuration was
6273 made, we change the frame to the size specified in the
6274 configuration, restore the configuration, and then resize it
6275 back. We keep track of the prevailing height in these variables. */
6276 int previous_frame_lines
= FRAME_LINES (f
);
6277 int previous_frame_cols
= FRAME_COLS (f
);
6278 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6279 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6281 /* The mouse highlighting code could get screwed up
6282 if it runs during this. */
6285 if (data
->frame_lines
!= previous_frame_lines
6286 || data
->frame_cols
!= previous_frame_cols
)
6287 change_frame_size (f
, data
->frame_lines
,
6288 data
->frame_cols
, 0, 0, 0);
6289 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6290 if (data
->frame_menu_bar_lines
6291 != previous_frame_menu_bar_lines
)
6292 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
6294 #ifdef HAVE_WINDOW_SYSTEM
6295 if (data
->frame_tool_bar_lines
6296 != previous_frame_tool_bar_lines
)
6297 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
6302 /* "Swap out" point from the selected window's buffer
6303 into the window itself. (Normally the pointm of the selected
6304 window holds garbage.) We do this now, before
6305 restoring the window contents, and prevent it from
6306 being done later on when we select a new window. */
6307 if (! NILP (XWINDOW (selected_window
)->buffer
))
6309 w
= XWINDOW (selected_window
);
6310 set_marker_both (w
->pointm
,
6312 BUF_PT (XBUFFER (w
->buffer
)),
6313 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6316 windows_or_buffers_changed
++;
6317 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6319 /* Problem: Freeing all matrices and later allocating them again
6320 is a serious redisplay flickering problem. What we would
6321 really like to do is to free only those matrices not reused
6323 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6325 = (struct window
**) alloca (count_windows (root_window
)
6326 * sizeof (struct window
*));
6327 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6329 /* Temporarily avoid any problems with windows that are smaller
6330 than they are supposed to be. */
6331 window_min_height
= 1;
6332 window_min_width
= 1;
6335 Mark all windows now on frame as "deleted".
6336 Restoring the new configuration "undeletes" any that are in it.
6338 Save their current buffers in their height fields, since we may
6339 need it later, if a buffer saved in the configuration is now
6341 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6343 for (k
= 0; k
< saved_windows
->size
; k
++)
6345 p
= SAVED_WINDOW_N (saved_windows
, k
);
6346 w
= XWINDOW (p
->window
);
6349 if (!NILP (p
->parent
))
6350 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6351 XFASTINT (p
->parent
))->window
;
6355 if (!NILP (p
->prev
))
6357 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6358 XFASTINT (p
->prev
))->window
;
6359 XWINDOW (w
->prev
)->next
= p
->window
;
6364 if (!NILP (w
->parent
))
6366 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6368 XWINDOW (w
->parent
)->vchild
= p
->window
;
6369 XWINDOW (w
->parent
)->hchild
= Qnil
;
6373 XWINDOW (w
->parent
)->hchild
= p
->window
;
6374 XWINDOW (w
->parent
)->vchild
= Qnil
;
6379 /* If we squirreled away the buffer in the window's height,
6381 if (BUFFERP (w
->total_lines
))
6382 w
->buffer
= w
->total_lines
;
6383 w
->left_col
= p
->left_col
;
6384 w
->top_line
= p
->top_line
;
6385 w
->total_cols
= p
->total_cols
;
6386 w
->total_lines
= p
->total_lines
;
6387 w
->hscroll
= p
->hscroll
;
6388 w
->min_hscroll
= p
->min_hscroll
;
6389 w
->display_table
= p
->display_table
;
6390 w
->orig_top_line
= p
->orig_top_line
;
6391 w
->orig_total_lines
= p
->orig_total_lines
;
6392 w
->left_margin_cols
= p
->left_margin_cols
;
6393 w
->right_margin_cols
= p
->right_margin_cols
;
6394 w
->left_fringe_width
= p
->left_fringe_width
;
6395 w
->right_fringe_width
= p
->right_fringe_width
;
6396 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6397 w
->scroll_bar_width
= p
->scroll_bar_width
;
6398 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6399 w
->dedicated
= p
->dedicated
;
6400 XSETFASTINT (w
->last_modified
, 0);
6401 XSETFASTINT (w
->last_overlay_modified
, 0);
6403 /* Reinstall the saved buffer and pointers into it. */
6404 if (NILP (p
->buffer
))
6405 w
->buffer
= p
->buffer
;
6408 if (!NILP (XBUFFER (p
->buffer
)->name
))
6409 /* If saved buffer is alive, install it. */
6411 w
->buffer
= p
->buffer
;
6412 w
->start_at_line_beg
= p
->start_at_line_beg
;
6413 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6414 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6415 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6416 p
->mark
, w
->buffer
);
6418 /* As documented in Fcurrent_window_configuration, don't
6419 restore the location of point in the buffer which was
6420 current when the window configuration was recorded. */
6421 if (!EQ (p
->buffer
, new_current_buffer
)
6422 && XBUFFER (p
->buffer
) == current_buffer
)
6423 Fgoto_char (w
->pointm
);
6425 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6426 /* Else unless window has a live buffer, get one. */
6428 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6429 /* This will set the markers to beginning of visible
6431 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6432 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6433 w
->start_at_line_beg
= Qt
;
6436 /* Keeping window's old buffer; make sure the markers
6439 /* Set window markers at start of visible range. */
6440 if (XMARKER (w
->start
)->buffer
== 0)
6441 set_marker_restricted (w
->start
, make_number (0),
6443 if (XMARKER (w
->pointm
)->buffer
== 0)
6444 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6445 BUF_PT (XBUFFER (w
->buffer
)),
6446 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6447 w
->start_at_line_beg
= Qt
;
6452 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6453 /* Prevent "swapping out point" in the old selected window
6454 using the buffer that has been restored into it.
6455 We already swapped out point that from that window's old buffer. */
6456 selected_window
= Qnil
;
6458 /* Arrange *not* to restore point in the buffer that was
6459 current when the window configuration was saved. */
6460 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6461 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6462 make_number (old_point
),
6463 XWINDOW (data
->current_window
)->buffer
);
6465 Fselect_window (data
->current_window
, Qnil
);
6466 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6469 if (NILP (data
->focus_frame
)
6470 || (FRAMEP (data
->focus_frame
)
6471 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6472 Fredirect_frame_focus (frame
, data
->focus_frame
);
6474 #if 0 /* I don't understand why this is needed, and it causes problems
6475 when the frame's old selected window has been deleted. */
6476 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6477 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6481 /* Set the screen height to the value it had before this function. */
6482 if (previous_frame_lines
!= FRAME_LINES (f
)
6483 || previous_frame_cols
!= FRAME_COLS (f
))
6484 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6486 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6487 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6488 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6490 #ifdef HAVE_WINDOW_SYSTEM
6491 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6492 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6497 /* Now, free glyph matrices in windows that were not reused. */
6498 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6500 if (NILP (leaf_windows
[i
]->buffer
))
6502 /* Assert it's not reused as a combination. */
6503 xassert (NILP (leaf_windows
[i
]->hchild
)
6504 && NILP (leaf_windows
[i
]->vchild
));
6505 free_window_matrices (leaf_windows
[i
]);
6507 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6515 /* Fselect_window will have made f the selected frame, so we
6516 reselect the proper frame here. Fhandle_switch_frame will change the
6517 selected window too, but that doesn't make the call to
6518 Fselect_window above totally superfluous; it still sets f's
6520 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6521 do_switch_frame (data
->selected_frame
, 0, 0);
6523 run_window_configuration_change_hook (f
);
6526 if (!NILP (new_current_buffer
))
6527 Fset_buffer (new_current_buffer
);
6529 /* Restore the minimum heights recorded in the configuration. */
6530 window_min_height
= data
->min_height
;
6531 window_min_width
= data
->min_width
;
6533 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6534 minibuf_selected_window
= data
->minibuf_selected_window
;
6536 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6539 /* Mark all windows now on frame as deleted
6540 by setting their buffers to nil. */
6543 delete_all_subwindows (w
)
6544 register struct window
*w
;
6546 if (!NILP (w
->next
))
6547 delete_all_subwindows (XWINDOW (w
->next
));
6548 if (!NILP (w
->vchild
))
6549 delete_all_subwindows (XWINDOW (w
->vchild
));
6550 if (!NILP (w
->hchild
))
6551 delete_all_subwindows (XWINDOW (w
->hchild
));
6553 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6555 if (!NILP (w
->buffer
))
6558 /* We set all three of these fields to nil, to make sure that we can
6559 distinguish this dead window from any live window. Live leaf
6560 windows will have buffer set, and combination windows will have
6561 vchild or hchild set. */
6566 Vwindow_list
= Qnil
;
6570 count_windows (window
)
6571 register struct window
*window
;
6573 register int count
= 1;
6574 if (!NILP (window
->next
))
6575 count
+= count_windows (XWINDOW (window
->next
));
6576 if (!NILP (window
->vchild
))
6577 count
+= count_windows (XWINDOW (window
->vchild
));
6578 if (!NILP (window
->hchild
))
6579 count
+= count_windows (XWINDOW (window
->hchild
));
6584 /* Fill vector FLAT with leaf windows under W, starting at index I.
6585 Value is last index + 1. */
6588 get_leaf_windows (w
, flat
, i
)
6590 struct window
**flat
;
6595 if (!NILP (w
->hchild
))
6596 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6597 else if (!NILP (w
->vchild
))
6598 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6602 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6609 /* Return a pointer to the glyph W's physical cursor is on. Value is
6610 null if W's current matrix is invalid, so that no meaningfull glyph
6614 get_phys_cursor_glyph (w
)
6617 struct glyph_row
*row
;
6618 struct glyph
*glyph
;
6620 if (w
->phys_cursor
.vpos
>= 0
6621 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6622 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6624 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6625 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6634 save_window_save (window
, vector
, i
)
6636 struct Lisp_Vector
*vector
;
6639 register struct saved_window
*p
;
6640 register struct window
*w
;
6641 register Lisp_Object tem
;
6643 for (;!NILP (window
); window
= w
->next
)
6645 p
= SAVED_WINDOW_N (vector
, i
);
6646 w
= XWINDOW (window
);
6648 XSETFASTINT (w
->temslot
, i
); i
++;
6650 p
->buffer
= w
->buffer
;
6651 p
->left_col
= w
->left_col
;
6652 p
->top_line
= w
->top_line
;
6653 p
->total_cols
= w
->total_cols
;
6654 p
->total_lines
= w
->total_lines
;
6655 p
->hscroll
= w
->hscroll
;
6656 p
->min_hscroll
= w
->min_hscroll
;
6657 p
->display_table
= w
->display_table
;
6658 p
->orig_top_line
= w
->orig_top_line
;
6659 p
->orig_total_lines
= w
->orig_total_lines
;
6660 p
->left_margin_cols
= w
->left_margin_cols
;
6661 p
->right_margin_cols
= w
->right_margin_cols
;
6662 p
->left_fringe_width
= w
->left_fringe_width
;
6663 p
->right_fringe_width
= w
->right_fringe_width
;
6664 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6665 p
->scroll_bar_width
= w
->scroll_bar_width
;
6666 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6667 p
->dedicated
= w
->dedicated
;
6668 if (!NILP (w
->buffer
))
6670 /* Save w's value of point in the window configuration.
6671 If w is the selected window, then get the value of point
6672 from the buffer; pointm is garbage in the selected window. */
6673 if (EQ (window
, selected_window
))
6675 p
->pointm
= Fmake_marker ();
6676 set_marker_both (p
->pointm
, w
->buffer
,
6677 BUF_PT (XBUFFER (w
->buffer
)),
6678 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6681 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6683 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6684 p
->start_at_line_beg
= w
->start_at_line_beg
;
6686 tem
= XBUFFER (w
->buffer
)->mark
;
6687 p
->mark
= Fcopy_marker (tem
, Qnil
);
6694 p
->start_at_line_beg
= Qnil
;
6697 if (NILP (w
->parent
))
6700 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6705 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6707 if (!NILP (w
->vchild
))
6708 i
= save_window_save (w
->vchild
, vector
, i
);
6709 if (!NILP (w
->hchild
))
6710 i
= save_window_save (w
->hchild
, vector
, i
);
6716 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6717 Scurrent_window_configuration
, 0, 1, 0,
6718 doc
: /* Return an object representing the current window configuration of FRAME.
6719 If FRAME is nil or omitted, use the selected frame.
6720 This describes the number of windows, their sizes and current buffers,
6721 and for each displayed buffer, where display starts, and the positions of
6722 point and mark. An exception is made for point in the current buffer:
6723 its value is -not- saved.
6724 This also records the currently selected frame, and FRAME's focus
6725 redirection (see `redirect-frame-focus'). */)
6729 register Lisp_Object tem
;
6730 register int n_windows
;
6731 register struct save_window_data
*data
;
6736 frame
= selected_frame
;
6737 CHECK_LIVE_FRAME (frame
);
6740 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6741 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6742 PVEC_WINDOW_CONFIGURATION
);
6744 data
->frame_cols
= FRAME_COLS (f
);
6745 data
->frame_lines
= FRAME_LINES (f
);
6746 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6747 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6748 data
->selected_frame
= selected_frame
;
6749 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6750 XSETBUFFER (data
->current_buffer
, current_buffer
);
6751 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6752 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6753 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6754 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6755 data
->min_height
= window_min_height
;
6756 data
->min_width
= window_min_width
;
6757 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6758 data
->saved_windows
= tem
;
6759 for (i
= 0; i
< n_windows
; i
++)
6760 XVECTOR (tem
)->contents
[i
]
6761 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6762 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6763 XSETWINDOW_CONFIGURATION (tem
, data
);
6767 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6769 doc
: /* Execute BODY, preserving window sizes and contents.
6770 Return the value of the last form in BODY.
6771 Restore which buffer appears in which window, where display starts,
6772 and the value of point and mark for each window.
6773 Also restore the choice of selected window.
6774 Also restore which buffer is current.
6775 Does not restore the value of point in current buffer.
6776 usage: (save-window-excursion BODY...) */)
6780 register Lisp_Object val
;
6781 register int count
= SPECPDL_INDEX ();
6783 record_unwind_protect (Fset_window_configuration
,
6784 Fcurrent_window_configuration (Qnil
));
6785 val
= Fprogn (args
);
6786 return unbind_to (count
, val
);
6791 /***********************************************************************
6793 ***********************************************************************/
6799 Lisp_Object tail
= Qnil
;
6800 Lisp_Object result
= Qnil
;
6807 if (!NILP (w
->hchild
))
6808 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6809 window_tree (XWINDOW (w
->hchild
))));
6810 else if (!NILP (w
->vchild
))
6811 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6812 window_tree (XWINDOW (w
->vchild
))));
6816 result
= tail
= Fcons (wn
, Qnil
);
6820 XSETCDR (tail
, Fcons (wn
, Qnil
));
6824 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6832 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6834 doc
: /* Return the window tree for frame FRAME.
6836 The return value is a list of the form (ROOT MINI), where ROOT
6837 represents the window tree of the frame's root window, and MINI
6838 is the frame's minibuffer window.
6840 If the root window is not split, ROOT is the root window itself.
6841 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6842 horizontal split, and t for a vertical split, EDGES gives the combined
6843 size and position of the subwindows in the split, and the rest of the
6844 elements are the subwindows in the split. Each of the subwindows may
6845 again be a window or a list representing a window split, and so on.
6846 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6848 If FRAME is nil or omitted, return information on the currently
6856 frame
= selected_frame
;
6858 CHECK_FRAME (frame
);
6861 if (!FRAME_LIVE_P (f
))
6864 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6868 /***********************************************************************
6870 ***********************************************************************/
6872 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6874 doc
: /* Set width of marginal areas of window WINDOW.
6875 If WINDOW is nil, set margins of the currently selected window.
6876 Second arg LEFT-WIDTH specifies the number of character cells to
6877 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6878 does the same for the right marginal area. A nil width parameter
6879 means no margin. */)
6880 (window
, left_width
, right_width
)
6881 Lisp_Object window
, left_width
, right_width
;
6883 struct window
*w
= decode_window (window
);
6885 /* Translate negative or zero widths to nil.
6886 Margins that are too wide have to be checked elsewhere. */
6888 if (!NILP (left_width
))
6890 CHECK_NUMBER (left_width
);
6891 if (XINT (left_width
) <= 0)
6895 if (!NILP (right_width
))
6897 CHECK_NUMBER (right_width
);
6898 if (XINT (right_width
) <= 0)
6902 if (!EQ (w
->left_margin_cols
, left_width
)
6903 || !EQ (w
->right_margin_cols
, right_width
))
6905 w
->left_margin_cols
= left_width
;
6906 w
->right_margin_cols
= right_width
;
6908 adjust_window_margins (w
);
6910 ++windows_or_buffers_changed
;
6911 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6918 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6920 doc
: /* Get width of marginal areas of window WINDOW.
6921 If WINDOW is omitted or nil, use the currently selected window.
6922 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6923 If a marginal area does not exist, its width will be returned
6928 struct window
*w
= decode_window (window
);
6929 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6934 /***********************************************************************
6936 ***********************************************************************/
6938 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6940 doc
: /* Set the fringe widths of window WINDOW.
6941 If WINDOW is nil, set the fringe widths of the currently selected
6943 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6944 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6945 fringe width. If a fringe width arg is nil, that means to use the
6946 frame's default fringe width. Default fringe widths can be set with
6947 the command `set-fringe-style'.
6948 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6949 outside of the display margins. By default, fringes are drawn between
6950 display marginal areas and the text area. */)
6951 (window
, left_width
, right_width
, outside_margins
)
6952 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6954 struct window
*w
= decode_window (window
);
6956 if (!NILP (left_width
))
6957 CHECK_NATNUM (left_width
);
6958 if (!NILP (right_width
))
6959 CHECK_NATNUM (right_width
);
6961 /* Do nothing on a tty. */
6962 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6963 && (!EQ (w
->left_fringe_width
, left_width
)
6964 || !EQ (w
->right_fringe_width
, right_width
)
6965 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6967 w
->left_fringe_width
= left_width
;
6968 w
->right_fringe_width
= right_width
;
6969 w
->fringes_outside_margins
= outside_margins
;
6971 adjust_window_margins (w
);
6973 clear_glyph_matrix (w
->current_matrix
);
6974 w
->window_end_valid
= Qnil
;
6976 ++windows_or_buffers_changed
;
6977 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6984 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6986 doc
: /* Get width of fringes of window WINDOW.
6987 If WINDOW is omitted or nil, use the currently selected window.
6988 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6992 struct window
*w
= decode_window (window
);
6994 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6995 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6996 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6997 ? Qt
: Qnil
), Qnil
)));
7002 /***********************************************************************
7004 ***********************************************************************/
7006 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
7008 doc
: /* Set width and type of scroll bars of window WINDOW.
7009 If window is nil, set scroll bars of the currently selected window.
7010 Second parameter WIDTH specifies the pixel width for the scroll bar;
7011 this is automatically adjusted to a multiple of the frame column width.
7012 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
7013 bar: left, right, or nil.
7014 If WIDTH is nil, use the frame's scroll-bar width.
7015 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
7016 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
7017 (window
, width
, vertical_type
, horizontal_type
)
7018 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
7020 struct window
*w
= decode_window (window
);
7024 CHECK_NATNUM (width
);
7026 if (XINT (width
) == 0)
7027 vertical_type
= Qnil
;
7030 if (!(NILP (vertical_type
)
7031 || EQ (vertical_type
, Qleft
)
7032 || EQ (vertical_type
, Qright
)
7033 || EQ (vertical_type
, Qt
)))
7034 error ("Invalid type of vertical scroll bar");
7036 if (!EQ (w
->scroll_bar_width
, width
)
7037 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
7039 w
->scroll_bar_width
= width
;
7040 w
->vertical_scroll_bar_type
= vertical_type
;
7042 adjust_window_margins (w
);
7044 clear_glyph_matrix (w
->current_matrix
);
7045 w
->window_end_valid
= Qnil
;
7047 ++windows_or_buffers_changed
;
7048 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
7055 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
7057 doc
: /* Get width and type of scroll bars of window WINDOW.
7058 If WINDOW is omitted or nil, use the currently selected window.
7059 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
7060 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
7065 struct window
*w
= decode_window (window
);
7066 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
7067 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
7068 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
7069 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
7070 Fcons (w
->vertical_scroll_bar_type
,
7071 Fcons (Qnil
, Qnil
))));
7076 /***********************************************************************
7078 ***********************************************************************/
7080 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
7081 doc
: /* Return the amount by which WINDOW is scrolled vertically.
7082 Use the selected window if WINDOW is nil or omitted.
7083 Normally, value is a multiple of the canonical character height of WINDOW;
7084 optional second arg PIXELS-P means value is measured in pixels. */)
7086 Lisp_Object window
, pixels_p
;
7093 window
= selected_window
;
7095 CHECK_WINDOW (window
);
7096 w
= XWINDOW (window
);
7097 f
= XFRAME (w
->frame
);
7099 if (FRAME_WINDOW_P (f
))
7100 result
= (NILP (pixels_p
)
7101 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
7102 : make_number (-w
->vscroll
));
7104 result
= make_number (0);
7109 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
7111 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
7112 WINDOW nil means use the selected window. Normally, VSCROLL is a
7113 non-negative multiple of the canonical character height of WINDOW;
7114 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
7115 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
7116 corresponds to an integral number of pixels. The return value is the
7117 result of this rounding.
7118 If PIXELS-P is non-nil, the return value is VSCROLL. */)
7119 (window
, vscroll
, pixels_p
)
7120 Lisp_Object window
, vscroll
, pixels_p
;
7126 window
= selected_window
;
7128 CHECK_WINDOW (window
);
7129 CHECK_NUMBER_OR_FLOAT (vscroll
);
7131 w
= XWINDOW (window
);
7132 f
= XFRAME (w
->frame
);
7134 if (FRAME_WINDOW_P (f
))
7136 int old_dy
= w
->vscroll
;
7138 w
->vscroll
= - (NILP (pixels_p
)
7139 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
7140 : XFLOATINT (vscroll
));
7141 w
->vscroll
= min (w
->vscroll
, 0);
7143 if (w
->vscroll
!= old_dy
)
7145 /* Adjust glyph matrix of the frame if the virtual display
7146 area becomes larger than before. */
7147 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
7150 /* Prevent redisplay shortcuts. */
7151 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
7155 return Fwindow_vscroll (window
, pixels_p
);
7159 /* Call FN for all leaf windows on frame F. FN is called with the
7160 first argument being a pointer to the leaf window, and with
7161 additional argument USER_DATA. Stops when FN returns 0. */
7164 foreach_window (f
, fn
, user_data
)
7166 int (* fn
) P_ ((struct window
*, void *));
7169 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
7170 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
7171 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
7175 /* Helper function for foreach_window. Call FN for all leaf windows
7176 reachable from W. FN is called with the first argument being a
7177 pointer to the leaf window, and with additional argument USER_DATA.
7178 Stop when FN returns 0. Value is 0 if stopped by FN. */
7181 foreach_window_1 (w
, fn
, user_data
)
7183 int (* fn
) P_ ((struct window
*, void *));
7188 for (cont
= 1; w
&& cont
;)
7190 if (!NILP (w
->hchild
))
7191 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
7192 else if (!NILP (w
->vchild
))
7193 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
7195 cont
= fn (w
, user_data
);
7197 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
7204 /* Freeze or unfreeze the window start of W unless it is a
7205 mini-window or the selected window. FREEZE_P non-null means freeze
7206 the window start. */
7209 freeze_window_start (w
, freeze_p
)
7213 if (MINI_WINDOW_P (w
)
7214 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
7215 && (w
== XWINDOW (selected_window
)
7216 || (MINI_WINDOW_P (XWINDOW (selected_window
))
7217 && ! NILP (Vminibuf_scroll_window
)
7218 && w
== XWINDOW (Vminibuf_scroll_window
)))))
7221 w
->frozen_window_start_p
= freeze_p
!= NULL
;
7226 /* Freeze or unfreeze the window starts of all leaf windows on frame
7227 F, except the selected window and a mini-window. FREEZE_P non-zero
7228 means freeze the window start. */
7231 freeze_window_starts (f
, freeze_p
)
7235 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
7239 /***********************************************************************
7241 ***********************************************************************/
7243 /* Return 1 if window configurations C1 and C2
7244 describe the same state of affairs. This is used by Fequal. */
7247 compare_window_configurations (c1
, c2
, ignore_positions
)
7249 int ignore_positions
;
7251 register struct save_window_data
*d1
, *d2
;
7252 struct Lisp_Vector
*sw1
, *sw2
;
7255 CHECK_WINDOW_CONFIGURATION (c1
);
7256 CHECK_WINDOW_CONFIGURATION (c2
);
7258 d1
= (struct save_window_data
*) XVECTOR (c1
);
7259 d2
= (struct save_window_data
*) XVECTOR (c2
);
7260 sw1
= XVECTOR (d1
->saved_windows
);
7261 sw2
= XVECTOR (d2
->saved_windows
);
7263 if (d1
->frame_cols
!= d2
->frame_cols
)
7265 if (d1
->frame_lines
!= d2
->frame_lines
)
7267 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
7269 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
7271 /* Don't compare the current_window field directly.
7272 Instead see w1_is_current and w2_is_current, below. */
7273 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
7275 if (! ignore_positions
)
7277 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
7279 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
7282 /* Don't compare the root_window field.
7283 We don't require the two configurations
7284 to use the same window object,
7285 and the two root windows must be equivalent
7286 if everything else compares equal. */
7287 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
7289 if (d1
->min_width
!= d2
->min_width
)
7291 if (d1
->min_height
!= d2
->min_height
)
7294 /* Verify that the two confis have the same number of windows. */
7295 if (sw1
->size
!= sw2
->size
)
7298 for (i
= 0; i
< sw1
->size
; i
++)
7300 struct saved_window
*p1
, *p2
;
7301 int w1_is_current
, w2_is_current
;
7303 p1
= SAVED_WINDOW_N (sw1
, i
);
7304 p2
= SAVED_WINDOW_N (sw2
, i
);
7306 /* Verify that the current windows in the two
7307 configurations correspond to each other. */
7308 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7309 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7311 if (w1_is_current
!= w2_is_current
)
7314 /* Verify that the corresponding windows do match. */
7315 if (! EQ (p1
->buffer
, p2
->buffer
))
7317 if (! EQ (p1
->left_col
, p2
->left_col
))
7319 if (! EQ (p1
->top_line
, p2
->top_line
))
7321 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7323 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7325 if (! EQ (p1
->display_table
, p2
->display_table
))
7327 if (! EQ (p1
->parent
, p2
->parent
))
7329 if (! EQ (p1
->prev
, p2
->prev
))
7331 if (! ignore_positions
)
7333 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7335 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7337 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7339 if (NILP (Fequal (p1
->start
, p2
->start
)))
7341 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7343 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7346 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7348 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7350 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7352 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7354 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7356 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7358 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7365 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7366 Scompare_window_configurations
, 2, 2, 0,
7367 doc
: /* Compare two window configurations as regards the structure of windows.
7368 This function ignores details such as the values of point and mark
7369 and scrolling positions. */)
7373 if (compare_window_configurations (x
, y
, 1))
7381 struct frame
*f
= make_initial_frame ();
7382 XSETFRAME (selected_frame
, f
);
7383 Vterminal_frame
= selected_frame
;
7384 minibuf_window
= f
->minibuffer_window
;
7385 selected_window
= f
->selected_window
;
7386 last_nonminibuf_frame
= f
;
7388 window_initialized
= 1;
7394 Vwindow_list
= Qnil
;
7400 Qscroll_up
= intern ("scroll-up");
7401 staticpro (&Qscroll_up
);
7403 Qscroll_down
= intern ("scroll-down");
7404 staticpro (&Qscroll_down
);
7406 Qwindow_size_fixed
= intern ("window-size-fixed");
7407 staticpro (&Qwindow_size_fixed
);
7408 Fset (Qwindow_size_fixed
, Qnil
);
7410 staticpro (&Qwindow_configuration_change_hook
);
7411 Qwindow_configuration_change_hook
7412 = intern ("window-configuration-change-hook");
7414 Qwindowp
= intern ("windowp");
7415 staticpro (&Qwindowp
);
7417 Qwindow_configuration_p
= intern ("window-configuration-p");
7418 staticpro (&Qwindow_configuration_p
);
7420 Qwindow_live_p
= intern ("window-live-p");
7421 staticpro (&Qwindow_live_p
);
7423 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7424 staticpro (&Qtemp_buffer_show_hook
);
7426 staticpro (&Vwindow_list
);
7428 minibuf_selected_window
= Qnil
;
7429 staticpro (&minibuf_selected_window
);
7431 window_scroll_pixel_based_preserve_y
= -1;
7433 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7434 doc
: /* Non-nil means call as function to display a help buffer.
7435 The function is called with one argument, the buffer to be displayed.
7436 Used by `with-output-to-temp-buffer'.
7437 If this function is used, then it must do the entire job of showing
7438 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7439 Vtemp_buffer_show_function
= Qnil
;
7441 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7442 doc
: /* If non-nil, function to call to handle `display-buffer'.
7443 It will receive two args, the buffer and a flag which if non-nil means
7444 that the currently selected window is not acceptable.
7445 It should choose or create a window, display the specified buffer in it,
7446 and return the window.
7447 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7448 work using this function. */);
7449 Vdisplay_buffer_function
= Qnil
;
7451 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7452 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7453 If nil, `display-buffer' will leave the window configuration alone. */);
7454 Veven_window_heights
= Qt
;
7456 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7457 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7458 Vminibuf_scroll_window
= Qnil
;
7460 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7461 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7462 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7463 is displayed in the `mode-line' face. */);
7464 mode_line_in_non_selected_windows
= 1;
7466 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7467 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7468 Vother_window_scroll_buffer
= Qnil
;
7470 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7471 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7474 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7475 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7476 auto_window_vscroll_p
= 1;
7478 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7479 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7480 If the buffer in question is already displayed in a frame, raise that frame. */);
7481 display_buffer_reuse_frames
= 0;
7483 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7484 doc
: /* Function to call to handle automatic new frame creation.
7485 It is called with no arguments and should return a newly created frame.
7487 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7488 where `pop-up-frame-alist' would hold the default frame parameters. */);
7489 Vpop_up_frame_function
= Qnil
;
7491 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7492 doc
: /* *List of buffer names that should have their own special frames.
7493 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7494 if its name is in this list, makes a special frame for it
7495 using `special-display-function'. See also `special-display-regexps'.
7497 An element of the list can be a list instead of just a string.
7498 There are two ways to use a list as an element:
7499 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7500 In the first case, the FRAME-PARAMETERS are pairs of the form
7501 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7502 In the second case, FUNCTION is called with BUFFER as the first argument,
7503 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7504 All this is done by the function found in `special-display-function'.
7506 If the specified frame parameters include (same-buffer . t), the
7507 buffer is displayed in the currently selected window. Otherwise, if
7508 they include (same-frame . t), the buffer is displayed in a new window
7509 in the currently selected frame.
7511 If this variable appears \"not to work\", because you add a name to it
7512 but that buffer still appears in the selected window, look at the
7513 values of `same-window-buffer-names' and `same-window-regexps'.
7514 Those variables take precedence over this one. */);
7515 Vspecial_display_buffer_names
= Qnil
;
7517 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7518 doc
: /* *List of regexps saying which buffers should have their own special frames.
7519 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7520 if any regexp in this list matches the buffer name, it makes a
7521 special frame for the buffer by calling `special-display-function'.
7523 An element of the list can be a list instead of just a string.
7524 There are two ways to use a list as an element:
7525 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7526 In the first case, the FRAME-PARAMETERS are pairs of the form
7527 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7528 In the second case, FUNCTION is called with BUFFER as the first argument,
7529 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7530 All this is done by the function found in `special-display-function'.
7532 If the specified frame parameters include (same-buffer . t), the
7533 buffer is displayed in the currently selected window. Otherwise, if
7534 they include (same-frame . t), the buffer is displayed in a new window
7535 in the currently selected frame.
7537 If this variable appears \"not to work\", because you add a regexp to it
7538 but the matching buffers still appear in the selected window, look at the
7539 values of `same-window-buffer-names' and `same-window-regexps'.
7540 Those variables take precedence over this one. */);
7541 Vspecial_display_regexps
= Qnil
;
7543 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7544 doc
: /* Function to call to make a new frame for a special buffer.
7545 It is called with two arguments, the buffer and optional buffer specific
7546 data, and should return a window displaying that buffer.
7547 The default value normally makes a separate frame for the buffer,
7548 using `special-display-frame-alist' to specify the frame parameters.
7549 But if the buffer specific data includes (same-buffer . t) then the
7550 buffer is displayed in the current selected window.
7551 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7552 a new window in the currently selected frame.
7554 A buffer is special if it is listed in `special-display-buffer-names'
7555 or matches a regexp in `special-display-regexps'. */);
7556 Vspecial_display_function
= Qnil
;
7558 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7559 doc
: /* *List of buffer names that should appear in the selected window.
7560 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7561 switches to it in the selected window, rather than making it appear
7562 in some other window.
7564 An element of the list can be a cons cell instead of just a string.
7565 Then the car must be a string, which specifies the buffer name.
7566 This is for compatibility with `special-display-buffer-names';
7567 the cdr of the cons cell is ignored.
7569 See also `same-window-regexps'. */);
7570 Vsame_window_buffer_names
= Qnil
;
7572 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7573 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7574 If a buffer name matches one of these regexps, then displaying it
7575 using `display-buffer' or `pop-to-buffer' switches to it
7576 in the selected window, rather than making it appear in some other window.
7578 An element of the list can be a cons cell instead of just a string.
7579 Then the car must be a string, which specifies the buffer name.
7580 This is for compatibility with `special-display-buffer-names';
7581 the cdr of the cons cell is ignored.
7583 See also `same-window-buffer-names'. */);
7584 Vsame_window_regexps
= Qnil
;
7586 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7587 doc
: /* *Non-nil means display-buffer should make new windows. */);
7590 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7591 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7592 next_screen_context_lines
= 2;
7594 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7595 doc
: /* *A window must be at least this tall to be eligible for splitting
7596 by `display-buffer'. The value is in line units.
7597 If there is only one window, it is split regardless of this value. */);
7598 split_height_threshold
= 500;
7600 DEFVAR_LISP ("split-window-preferred-function",
7601 &Vsplit_window_preferred_function
,
7602 doc
: /* Function to use to split a window.
7603 This is used by `display-buffer' to allow the user to choose whether
7604 to split windows horizontally or vertically or some mix of the two.
7605 When this variable is nil, `display-buffer' splits windows vertically.
7606 Otherwise, `display-buffer' calls this function to split a window.
7607 It is called with a window as single argument and should split it in two
7608 and return the new window, or return an appropriate existing window
7609 if splitting is not eligible. */);
7610 Vsplit_window_preferred_function
= Qnil
;
7612 DEFVAR_INT ("window-min-height", &window_min_height
,
7613 doc
: /* *Delete any window less than this tall (including its mode line).
7614 The value is in line units. */);
7615 window_min_height
= 4;
7617 DEFVAR_INT ("window-min-width", &window_min_width
,
7618 doc
: /* *Delete any window less than this wide (measured in characters). */);
7619 window_min_width
= 10;
7621 DEFVAR_LISP ("scroll-preserve-screen-position",
7622 &Vscroll_preserve_screen_position
,
7623 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7624 A value of nil means point does not keep its screen position except
7625 at the scroll margin or window boundary respectively.
7626 A value of t means point keeps its screen position if the scroll
7627 command moved it vertically out of the window, e.g. when scrolling
7629 Any other value means point always keeps its screen position. */);
7630 Vscroll_preserve_screen_position
= Qnil
;
7632 DEFVAR_LISP ("window-configuration-change-hook",
7633 &Vwindow_configuration_change_hook
,
7634 doc
: /* Functions to call when window configuration changes.
7635 The buffer-local part is run once per window, with the relevant window
7636 selected; while the global part is run only once for the modified frame,
7637 with the relevant frame selected. */);
7638 Vwindow_configuration_change_hook
= Qnil
;
7640 defsubr (&Sselected_window
);
7641 defsubr (&Sminibuffer_window
);
7642 defsubr (&Swindow_minibuffer_p
);
7643 defsubr (&Swindowp
);
7644 defsubr (&Swindow_live_p
);
7645 defsubr (&Spos_visible_in_window_p
);
7646 defsubr (&Swindow_line_height
);
7647 defsubr (&Swindow_buffer
);
7648 defsubr (&Swindow_height
);
7649 defsubr (&Swindow_width
);
7650 defsubr (&Swindow_full_width_p
);
7651 defsubr (&Swindow_hscroll
);
7652 defsubr (&Sset_window_hscroll
);
7653 defsubr (&Swindow_redisplay_end_trigger
);
7654 defsubr (&Sset_window_redisplay_end_trigger
);
7655 defsubr (&Swindow_edges
);
7656 defsubr (&Swindow_pixel_edges
);
7657 defsubr (&Swindow_inside_edges
);
7658 defsubr (&Swindow_inside_pixel_edges
);
7659 defsubr (&Scoordinates_in_window_p
);
7660 defsubr (&Swindow_at
);
7661 defsubr (&Swindow_point
);
7662 defsubr (&Swindow_start
);
7663 defsubr (&Swindow_end
);
7664 defsubr (&Sset_window_point
);
7665 defsubr (&Sset_window_start
);
7666 defsubr (&Swindow_dedicated_p
);
7667 defsubr (&Sset_window_dedicated_p
);
7668 defsubr (&Swindow_display_table
);
7669 defsubr (&Sset_window_display_table
);
7670 defsubr (&Snext_window
);
7671 defsubr (&Sprevious_window
);
7672 defsubr (&Sother_window
);
7673 defsubr (&Sget_lru_window
);
7674 defsubr (&Sget_largest_window
);
7675 defsubr (&Sget_buffer_window
);
7676 defsubr (&Sdelete_other_windows
);
7677 defsubr (&Sdelete_windows_on
);
7678 defsubr (&Sreplace_buffer_in_windows
);
7679 defsubr (&Sdelete_window
);
7680 defsubr (&Sset_window_buffer
);
7681 defsubr (&Sselect_window
);
7682 defsubr (&Sspecial_display_p
);
7683 defsubr (&Ssame_window_p
);
7684 defsubr (&Sdisplay_buffer
);
7685 defsubr (&Sforce_window_update
);
7686 defsubr (&Ssplit_window
);
7687 defsubr (&Senlarge_window
);
7688 defsubr (&Sshrink_window
);
7689 defsubr (&Sadjust_window_trailing_edge
);
7690 defsubr (&Sscroll_up
);
7691 defsubr (&Sscroll_down
);
7692 defsubr (&Sscroll_left
);
7693 defsubr (&Sscroll_right
);
7694 defsubr (&Sother_window_for_scrolling
);
7695 defsubr (&Sscroll_other_window
);
7696 defsubr (&Sminibuffer_selected_window
);
7697 defsubr (&Srecenter
);
7698 defsubr (&Swindow_text_height
);
7699 defsubr (&Smove_to_window_line
);
7700 defsubr (&Swindow_configuration_p
);
7701 defsubr (&Swindow_configuration_frame
);
7702 defsubr (&Sset_window_configuration
);
7703 defsubr (&Scurrent_window_configuration
);
7704 defsubr (&Ssave_window_excursion
);
7705 defsubr (&Swindow_tree
);
7706 defsubr (&Sset_window_margins
);
7707 defsubr (&Swindow_margins
);
7708 defsubr (&Sset_window_fringes
);
7709 defsubr (&Swindow_fringes
);
7710 defsubr (&Sset_window_scroll_bars
);
7711 defsubr (&Swindow_scroll_bars
);
7712 defsubr (&Swindow_vscroll
);
7713 defsubr (&Sset_window_vscroll
);
7714 defsubr (&Scompare_window_configurations
);
7715 defsubr (&Swindow_list
);
7721 initial_define_key (control_x_map
, '1', "delete-other-windows");
7722 initial_define_key (control_x_map
, '2', "split-window");
7723 initial_define_key (control_x_map
, '0', "delete-window");
7724 initial_define_key (control_x_map
, 'o', "other-window");
7725 initial_define_key (control_x_map
, '^', "enlarge-window");
7726 initial_define_key (control_x_map
, '<', "scroll-left");
7727 initial_define_key (control_x_map
, '>', "scroll-right");
7729 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7730 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7731 initial_define_key (meta_map
, 'v', "scroll-down");
7733 initial_define_key (global_map
, Ctl('L'), "recenter");
7734 initial_define_key (meta_map
, 'r', "move-to-window-line");
7737 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7738 (do not change this comment) */