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 Lisp_Object Qwindow_configuration_change_hook
;
216 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
;
1486 delete_window (window
);
1488 if (! NILP (Vwindow_configuration_change_hook
)
1489 && ! NILP (Vrun_hooks
))
1490 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1496 delete_window (window
)
1497 register Lisp_Object window
;
1499 register Lisp_Object tem
, parent
, sib
;
1500 register struct window
*p
;
1501 register struct window
*par
;
1504 /* Because this function is called by other C code on non-leaf
1505 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1506 so we can't decode_window here. */
1508 window
= selected_window
;
1510 CHECK_WINDOW (window
);
1511 p
= XWINDOW (window
);
1513 /* It's a no-op to delete an already-deleted window. */
1514 if (NILP (p
->buffer
)
1516 && NILP (p
->vchild
))
1521 error ("Attempt to delete minibuffer or sole ordinary window");
1522 par
= XWINDOW (parent
);
1524 windows_or_buffers_changed
++;
1525 Vwindow_list
= Qnil
;
1526 f
= XFRAME (WINDOW_FRAME (p
));
1527 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1529 /* Are we trying to delete any frame's selected window? */
1531 Lisp_Object swindow
, pwindow
;
1533 /* See if the frame's selected window is either WINDOW
1534 or any subwindow of it, by finding all that window's parents
1535 and comparing each one with WINDOW. */
1536 swindow
= FRAME_SELECTED_WINDOW (f
);
1541 while (!NILP (pwindow
))
1543 if (EQ (window
, pwindow
))
1545 pwindow
= XWINDOW (pwindow
)->parent
;
1548 /* If the window being deleted is not a parent of SWINDOW,
1549 then SWINDOW is ok as the new selected window. */
1550 if (!EQ (window
, pwindow
))
1552 /* Otherwise, try another window for SWINDOW. */
1553 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);
1555 /* If we get back to the frame's selected window,
1556 it means there was no acceptable alternative,
1557 so we cannot delete. */
1558 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1559 error ("Cannot delete window");
1562 /* If we need to change SWINDOW, do it. */
1563 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1565 /* If we're about to delete the selected window on the
1566 selected frame, then we should use Fselect_window to select
1567 the new window. On the other hand, if we're about to
1568 delete the selected window on any other frame, we shouldn't do
1569 anything but set the frame's selected_window slot. */
1570 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1571 Fselect_window (swindow
, Qnil
);
1573 FRAME_SELECTED_WINDOW (f
) = swindow
;
1577 /* Now we know we can delete this one. */
1578 window_deletion_count
++;
1581 /* tem is null for dummy parent windows
1582 (which have inferiors but not any contents themselves) */
1586 unchain_marker (XMARKER (p
->pointm
));
1587 unchain_marker (XMARKER (p
->start
));
1590 /* Free window glyph matrices. It is sure that they are allocated
1591 again when ADJUST_GLYPHS is called. Block input so that expose
1592 events and other events that access glyph matrices are not
1593 processed while we are changing them. */
1595 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1599 XWINDOW (tem
)->prev
= p
->prev
;
1603 XWINDOW (tem
)->next
= p
->next
;
1605 if (EQ (window
, par
->hchild
))
1606 par
->hchild
= p
->next
;
1607 if (EQ (window
, par
->vchild
))
1608 par
->vchild
= p
->next
;
1610 /* Find one of our siblings to give our space to. */
1614 /* If p gives its space to its next sibling, that sibling needs
1615 to have its top/left side pulled back to where p's is.
1616 set_window_{height,width} will re-position the sibling's
1619 XWINDOW (sib
)->top_line
= p
->top_line
;
1620 XWINDOW (sib
)->left_col
= p
->left_col
;
1623 /* Stretch that sibling. */
1624 if (!NILP (par
->vchild
))
1625 set_window_height (sib
,
1626 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1628 if (!NILP (par
->hchild
))
1629 set_window_width (sib
,
1630 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1633 /* If parent now has only one child,
1634 put the child into the parent's place. */
1638 if (NILP (XWINDOW (tem
)->next
)) {
1639 replace_window (parent
, tem
);
1640 par
= XWINDOW (tem
);
1643 /* Since we may be deleting combination windows, we must make sure that
1644 not only p but all its children have been marked as deleted. */
1645 if (! NILP (p
->hchild
))
1646 delete_all_subwindows (XWINDOW (p
->hchild
));
1647 else if (! NILP (p
->vchild
))
1648 delete_all_subwindows (XWINDOW (p
->vchild
));
1650 /* Mark this window as deleted. */
1651 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1653 if (! NILP (par
->parent
))
1654 par
= XWINDOW (par
->parent
);
1656 /* Check if we have a v/hchild with a v/hchild. In that case remove
1659 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1661 p
= XWINDOW (par
->vchild
);
1662 par
->vchild
= p
->vchild
;
1665 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1667 p
= XWINDOW (par
->hchild
);
1668 par
->hchild
= p
->hchild
;
1676 while (! NILP (tem
)) {
1677 XWINDOW (tem
)->parent
= p
->parent
;
1678 if (NILP (XWINDOW (tem
)->next
))
1680 tem
= XWINDOW (tem
)->next
;
1683 /* The next of the v/hchild we are removing is now the next of the
1684 last child for the v/hchild:
1685 Before v/hchild -> v/hchild -> next1 -> next2
1688 After: v/hchild -> next1 -> next2 -> next3
1690 XWINDOW (tem
)->next
= p
->next
;
1691 if (! NILP (p
->next
))
1692 XWINDOW (p
->next
)->prev
= tem
;
1694 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1698 /* Adjust glyph matrices. */
1705 /***********************************************************************
1707 ***********************************************************************/
1709 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1710 pointer. This is a callback function for foreach_window, used in
1711 function window_list. */
1714 add_window_to_list (w
, user_data
)
1718 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1720 XSETWINDOW (window
, w
);
1721 *list
= Fcons (window
, *list
);
1726 /* Return a list of all windows, for use by next_window. If
1727 Vwindow_list is a list, return that list. Otherwise, build a new
1728 list, cache it in Vwindow_list, and return that. */
1733 if (!CONSP (Vwindow_list
))
1737 Vwindow_list
= Qnil
;
1738 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1740 Lisp_Object args
[2];
1742 /* We are visiting windows in canonical order, and add
1743 new windows at the front of args[1], which means we
1744 have to reverse this list at the end. */
1746 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1747 args
[0] = Vwindow_list
;
1748 args
[1] = Fnreverse (args
[1]);
1749 Vwindow_list
= Fnconc (2, args
);
1753 return Vwindow_list
;
1757 /* Value is non-zero if WINDOW satisfies the constraints given by
1758 OWINDOW, MINIBUF and ALL_FRAMES.
1760 MINIBUF t means WINDOW may be minibuffer windows.
1761 `lambda' means WINDOW may not be a minibuffer window.
1762 a window means a specific minibuffer window
1764 ALL_FRAMES t means search all frames,
1765 nil means search just current frame,
1766 `visible' means search just visible frames,
1767 0 means search visible and iconified frames,
1768 a window means search the frame that window belongs to,
1769 a frame means consider windows on that frame, only. */
1772 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1773 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1775 struct window
*w
= XWINDOW (window
);
1776 struct frame
*f
= XFRAME (w
->frame
);
1777 int candidate_p
= 1;
1779 if (!BUFFERP (w
->buffer
))
1781 else if (MINI_WINDOW_P (w
)
1782 && (EQ (minibuf
, Qlambda
)
1783 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1785 /* If MINIBUF is `lambda' don't consider any mini-windows.
1786 If it is a window, consider only that one. */
1789 else if (EQ (all_frames
, Qt
))
1791 else if (NILP (all_frames
))
1793 xassert (WINDOWP (owindow
));
1794 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1796 else if (EQ (all_frames
, Qvisible
))
1798 FRAME_SAMPLE_VISIBILITY (f
);
1799 candidate_p
= FRAME_VISIBLE_P (f
)
1800 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1801 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1804 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1806 FRAME_SAMPLE_VISIBILITY (f
);
1807 candidate_p
= (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)
1808 #ifdef HAVE_X_WINDOWS
1809 /* Yuck!! If we've just created the frame and the
1810 window-manager requested the user to place it
1811 manually, the window may still not be considered
1812 `visible'. I'd argue it should be at least
1813 something like `iconified', but don't know how to do
1815 || (FRAME_X_P (f
) && f
->output_data
.x
->asked_for_visible
1816 && !f
->output_data
.x
->has_been_visible
)
1819 && (FRAME_TERMINAL (XFRAME (w
->frame
))
1820 == FRAME_TERMINAL (XFRAME (selected_frame
)));
1822 else if (WINDOWP (all_frames
))
1823 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1824 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1825 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1826 else if (FRAMEP (all_frames
))
1827 candidate_p
= EQ (all_frames
, w
->frame
);
1833 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1834 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1838 decode_next_window_args (window
, minibuf
, all_frames
)
1839 Lisp_Object
*window
, *minibuf
, *all_frames
;
1842 *window
= selected_window
;
1844 CHECK_LIVE_WINDOW (*window
);
1846 /* MINIBUF nil may or may not include minibuffers. Decide if it
1848 if (NILP (*minibuf
))
1849 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1850 else if (!EQ (*minibuf
, Qt
))
1853 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1854 => count none of them, or a specific minibuffer window (the
1855 active one) to count. */
1857 /* ALL_FRAMES nil doesn't specify which frames to include. */
1858 if (NILP (*all_frames
))
1859 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1860 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1862 else if (EQ (*all_frames
, Qvisible
))
1864 else if (EQ (*all_frames
, make_number (0)))
1866 else if (FRAMEP (*all_frames
))
1868 else if (!EQ (*all_frames
, Qt
))
1871 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1872 search just current frame, `visible' meaning search just visible
1873 frames, 0 meaning search visible and iconified frames, or a
1874 window, meaning search the frame that window belongs to, or a
1875 frame, meaning consider windows on that frame, only. */
1879 /* Return the next or previous window of WINDOW in canonical ordering
1880 of windows. NEXT_P non-zero means return the next window. See the
1881 documentation string of next-window for the meaning of MINIBUF and
1885 next_window (window
, minibuf
, all_frames
, next_p
)
1886 Lisp_Object window
, minibuf
, all_frames
;
1889 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1891 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1892 return the first window on the frame. */
1893 if (FRAMEP (all_frames
)
1894 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1895 return Fframe_first_window (all_frames
);
1901 /* Find WINDOW in the list of all windows. */
1902 list
= Fmemq (window
, window_list ());
1904 /* Scan forward from WINDOW to the end of the window list. */
1906 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1907 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1910 /* Scan from the start of the window list up to WINDOW. */
1912 for (list
= Vwindow_list
;
1913 CONSP (list
) && !EQ (XCAR (list
), window
);
1915 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1919 window
= XCAR (list
);
1923 Lisp_Object candidate
, list
;
1925 /* Scan through the list of windows for candidates. If there are
1926 candidate windows in front of WINDOW, the last one of these
1927 is the one we want. If there are candidates following WINDOW
1928 in the list, again the last one of these is the one we want. */
1930 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1932 if (EQ (XCAR (list
), window
))
1934 if (WINDOWP (candidate
))
1937 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1939 candidate
= XCAR (list
);
1942 if (WINDOWP (candidate
))
1950 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1951 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1952 If omitted, WINDOW defaults to the selected window.
1954 Optional second arg MINIBUF t means count the minibuffer window even
1955 if not active. MINIBUF nil or omitted means count the minibuffer iff
1956 it is active. MINIBUF neither t nor nil means not to count the
1957 minibuffer even if it is active.
1959 Several frames may share a single minibuffer; if the minibuffer
1960 counts, all windows on all frames that share that minibuffer count
1961 too. Therefore, `next-window' can be used to iterate through the
1962 set of windows even when the minibuffer is on another frame. If the
1963 minibuffer does not count, only windows from WINDOW's frame count.
1965 Optional third arg ALL-FRAMES t means include windows on all frames.
1966 ALL-FRAMES nil or omitted means cycle within the frames as specified
1967 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1968 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1969 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1970 Anything else means restrict to WINDOW's frame.
1972 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1973 `next-window' to iterate through the entire cycle of acceptable
1974 windows, eventually ending up back at the window you started with.
1975 `previous-window' traverses the same cycle, in the reverse order. */)
1976 (window
, minibuf
, all_frames
)
1977 Lisp_Object window
, minibuf
, all_frames
;
1979 return next_window (window
, minibuf
, all_frames
, 1);
1983 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1984 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1985 If omitted, WINDOW defaults to the selected window.
1987 Optional second arg MINIBUF t means count the minibuffer window even
1988 if not active. MINIBUF nil or omitted means count the minibuffer iff
1989 it is active. MINIBUF neither t nor nil means not to count the
1990 minibuffer even if it is active.
1992 Several frames may share a single minibuffer; if the minibuffer
1993 counts, all windows on all frames that share that minibuffer count
1994 too. Therefore, `previous-window' can be used to iterate through
1995 the set of windows even when the minibuffer is on another frame. If
1996 the minibuffer does not count, only windows from WINDOW's frame count
1998 Optional third arg ALL-FRAMES t means include windows on all frames.
1999 ALL-FRAMES nil or omitted means cycle within the frames as specified
2000 above. ALL-FRAMES = `visible' means include windows on all visible frames.
2001 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
2002 If ALL-FRAMES is a frame, restrict search to windows on that frame.
2003 Anything else means restrict to WINDOW's frame.
2005 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
2006 `previous-window' to iterate through the entire cycle of acceptable
2007 windows, eventually ending up back at the window you started with.
2008 `next-window' traverses the same cycle, in the reverse order. */)
2009 (window
, minibuf
, all_frames
)
2010 Lisp_Object window
, minibuf
, all_frames
;
2012 return next_window (window
, minibuf
, all_frames
, 0);
2016 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
2017 doc
: /* Select the ARG'th different window on this frame.
2018 All windows on current frame are arranged in a cyclic order.
2019 This command selects the window ARG steps away in that order.
2020 A negative ARG moves in the opposite order. The optional second
2021 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
2023 Lisp_Object arg
, all_frames
;
2029 window
= selected_window
;
2031 for (i
= XINT (arg
); i
> 0; --i
)
2032 window
= Fnext_window (window
, Qnil
, all_frames
);
2034 window
= Fprevious_window (window
, Qnil
, all_frames
);
2036 Fselect_window (window
, Qnil
);
2041 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2042 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2043 FRAME nil or omitted means use the selected frame.
2044 WINDOW nil or omitted means use the selected window.
2045 MINIBUF t means include the minibuffer window, even if it isn't active.
2046 MINIBUF nil or omitted means include the minibuffer window only
2048 MINIBUF neither nil nor t means never include the minibuffer window. */)
2049 (frame
, minibuf
, window
)
2050 Lisp_Object frame
, minibuf
, window
;
2053 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2054 CHECK_WINDOW (window
);
2056 frame
= selected_frame
;
2058 if (!EQ (frame
, XWINDOW (window
)->frame
))
2059 error ("Window is on a different frame");
2061 return window_list_1 (window
, minibuf
, frame
);
2065 /* Return a list of windows in canonical ordering. Arguments are like
2066 for `next-window'. */
2069 window_list_1 (window
, minibuf
, all_frames
)
2070 Lisp_Object window
, minibuf
, all_frames
;
2072 Lisp_Object tail
, list
, rest
;
2074 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2077 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2078 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2079 list
= Fcons (XCAR (tail
), list
);
2081 /* Rotate the list to start with WINDOW. */
2082 list
= Fnreverse (list
);
2083 rest
= Fmemq (window
, list
);
2084 if (!NILP (rest
) && !EQ (rest
, list
))
2086 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2088 XSETCDR (tail
, Qnil
);
2089 list
= nconc2 (rest
, list
);
2096 /* Look at all windows, performing an operation specified by TYPE
2098 If FRAMES is Qt, look at all frames;
2099 Qnil, look at just the selected frame;
2100 Qvisible, look at visible frames;
2101 a frame, just look at windows on that frame.
2102 If MINI is non-zero, perform the operation on minibuffer windows too. */
2107 GET_BUFFER_WINDOW
, /* Arg is buffer */
2108 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2109 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2110 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2112 UNSHOW_BUFFER
, /* Arg is buffer */
2113 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2118 window_loop (type
, obj
, mini
, frames
)
2119 enum window_loop type
;
2120 Lisp_Object obj
, frames
;
2123 Lisp_Object window
, windows
, best_window
, frame_arg
;
2125 struct gcpro gcpro1
;
2127 /* If we're only looping through windows on a particular frame,
2128 frame points to that frame. If we're looping through windows
2129 on all frames, frame is 0. */
2130 if (FRAMEP (frames
))
2131 f
= XFRAME (frames
);
2132 else if (NILP (frames
))
2133 f
= SELECTED_FRAME ();
2138 frame_arg
= Qlambda
;
2139 else if (EQ (frames
, make_number (0)))
2141 else if (EQ (frames
, Qvisible
))
2146 /* frame_arg is Qlambda to stick to one frame,
2147 Qvisible to consider all visible frames,
2150 /* Pick a window to start with. */
2154 window
= FRAME_SELECTED_WINDOW (f
);
2156 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2158 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2162 for (; CONSP (windows
); windows
= XCDR (windows
))
2166 window
= XCAR (windows
);
2167 w
= XWINDOW (window
);
2169 /* Note that we do not pay attention here to whether the frame
2170 is visible, since Fwindow_list skips non-visible frames if
2171 that is desired, under the control of frame_arg. */
2172 if (!MINI_WINDOW_P (w
)
2173 /* For UNSHOW_BUFFER, we must always consider all windows. */
2174 || type
== UNSHOW_BUFFER
2175 || (mini
&& minibuf_level
> 0))
2178 case GET_BUFFER_WINDOW
:
2179 if (EQ (w
->buffer
, obj
)
2180 /* Don't find any minibuffer window
2181 except the one that is currently in use. */
2182 && (MINI_WINDOW_P (w
)
2183 ? EQ (window
, minibuf_window
)
2186 if (NILP (best_window
))
2187 best_window
= window
;
2188 else if (EQ (window
, selected_window
))
2189 /* Prefer to return selected-window. */
2190 RETURN_UNGCPRO (window
);
2191 else if (EQ (Fwindow_frame (window
), selected_frame
))
2192 /* Prefer windows on the current frame. */
2193 best_window
= window
;
2197 case GET_LRU_WINDOW
:
2198 /* `obj' is an integer encoding a bitvector.
2199 `obj & 1' means consider only full-width windows.
2200 `obj & 2' means consider also dedicated windows. */
2201 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2202 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2203 /* Minibuffer windows are always ignored. */
2204 || MINI_WINDOW_P (w
))
2206 if (NILP (best_window
)
2207 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2208 > XFASTINT (w
->use_time
)))
2209 best_window
= window
;
2212 case DELETE_OTHER_WINDOWS
:
2213 if (!EQ (window
, obj
))
2214 Fdelete_window (window
);
2217 case DELETE_BUFFER_WINDOWS
:
2218 if (EQ (w
->buffer
, obj
))
2220 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2222 /* If this window is dedicated, and in a frame of its own,
2224 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2225 && !NILP (w
->dedicated
)
2226 && other_visible_frames (f
))
2228 /* Skip the other windows on this frame.
2229 There might be one, the minibuffer! */
2230 while (CONSP (XCDR (windows
))
2231 && EQ (XWINDOW (XCAR (windows
))->frame
,
2232 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2233 windows
= XCDR (windows
);
2235 /* Now we can safely delete the frame. */
2236 Fdelete_frame (w
->frame
, Qnil
);
2238 else if (NILP (w
->parent
))
2240 /* If we're deleting the buffer displayed in the
2241 only window on the frame, find a new buffer to
2244 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2245 Fset_window_buffer (window
, buffer
, Qnil
);
2246 if (EQ (window
, selected_window
))
2247 Fset_buffer (w
->buffer
);
2250 Fdelete_window (window
);
2254 case GET_LARGEST_WINDOW
:
2255 { /* nil `obj' means to ignore dedicated windows. */
2256 /* Ignore dedicated windows and minibuffers. */
2257 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2260 if (NILP (best_window
))
2261 best_window
= window
;
2264 struct window
*b
= XWINDOW (best_window
);
2265 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2266 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2267 best_window
= window
;
2273 if (EQ (w
->buffer
, obj
))
2276 struct frame
*f
= XFRAME (w
->frame
);
2278 /* Find another buffer to show in this window. */
2279 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2281 /* If this window is dedicated, and in a frame of its own,
2283 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2284 && !NILP (w
->dedicated
)
2285 && other_visible_frames (f
))
2287 /* Skip the other windows on this frame.
2288 There might be one, the minibuffer! */
2289 while (CONSP (XCDR (windows
))
2290 && EQ (XWINDOW (XCAR (windows
))->frame
,
2291 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2292 windows
= XCDR (windows
);
2294 /* Now we can safely delete the frame. */
2295 Fdelete_frame (w
->frame
, Qnil
);
2297 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2300 XSETWINDOW (window
, w
);
2301 /* If this window is dedicated and not the only window
2302 in its frame, then kill it. */
2303 Fdelete_window (window
);
2307 /* Otherwise show a different buffer in the window. */
2308 w
->dedicated
= Qnil
;
2309 Fset_window_buffer (window
, buffer
, Qnil
);
2310 if (EQ (window
, selected_window
))
2311 Fset_buffer (w
->buffer
);
2316 case REDISPLAY_BUFFER_WINDOWS
:
2317 if (EQ (w
->buffer
, obj
))
2319 mark_window_display_accurate (window
, 0);
2320 w
->update_mode_line
= Qt
;
2321 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2322 ++update_mode_lines
;
2323 best_window
= window
;
2327 /* Check for a window that has a killed buffer. */
2328 case CHECK_ALL_WINDOWS
:
2329 if (! NILP (w
->buffer
)
2330 && NILP (XBUFFER (w
->buffer
)->name
))
2334 case WINDOW_LOOP_UNUSED
:
2343 /* Used for debugging. Abort if any window has a dead buffer. */
2346 check_all_windows ()
2348 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2351 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2352 doc
: /* Return the window least recently selected or used for display.
2353 \(LRU means Least Recently Used.)
2355 Return a full-width window if possible.
2356 A minibuffer window is never a candidate.
2357 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2358 so if all windows are dedicated, the value is nil.
2359 If optional argument FRAME is `visible', search all visible frames.
2360 If FRAME is 0, search all visible and iconified frames.
2361 If FRAME is t, search all frames.
2362 If FRAME is nil, search only the selected frame.
2363 If FRAME is a frame, search only that frame. */)
2365 Lisp_Object frame
, dedicated
;
2367 register Lisp_Object w
;
2368 /* First try for a window that is full-width */
2369 w
= window_loop (GET_LRU_WINDOW
,
2370 NILP (dedicated
) ? make_number (1) : make_number (3),
2372 if (!NILP (w
) && !EQ (w
, selected_window
))
2374 /* If none of them, try the rest */
2375 return window_loop (GET_LRU_WINDOW
,
2376 NILP (dedicated
) ? make_number (0) : make_number (2),
2380 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2381 doc
: /* Return the largest window in area.
2382 A minibuffer window is never a candidate.
2383 A dedicated window is never a candidate unless DEDICATED is non-nil,
2384 so if all windows are dedicated, the value is nil.
2385 If optional argument FRAME is `visible', search all visible frames.
2386 If FRAME is 0, search all visible and iconified frames.
2387 If FRAME is t, search all frames.
2388 If FRAME is nil, search only the selected frame.
2389 If FRAME is a frame, search only that frame. */)
2391 Lisp_Object frame
, dedicated
;
2393 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2397 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2398 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2399 BUFFER can be a buffer or a buffer name.
2400 If optional argument FRAME is `visible', search all visible frames.
2401 If optional argument FRAME is 0, search all visible and iconified frames.
2402 If FRAME is t, search all frames.
2403 If FRAME is nil, search only the selected frame.
2404 If FRAME is a frame, search only that frame. */)
2406 Lisp_Object buffer
, frame
;
2408 buffer
= Fget_buffer (buffer
);
2409 if (BUFFERP (buffer
))
2410 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2415 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2417 doc
: /* Make WINDOW (or the selected window) fill its frame.
2418 Only the frame WINDOW is on is affected.
2419 This function tries to reduce display jumps
2420 by keeping the text previously visible in WINDOW
2421 in the same place on the frame. Doing this depends on
2422 the value of (window-start WINDOW), so if calling this function
2423 in a program gives strange scrolling, make sure the window-start
2424 value is reasonable when this function is called. */)
2433 window
= selected_window
;
2435 CHECK_LIVE_WINDOW (window
);
2436 w
= XWINDOW (window
);
2438 startpos
= marker_position (w
->start
);
2439 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2441 if (MINI_WINDOW_P (w
) && top
> 0)
2442 error ("Can't expand minibuffer to full frame");
2444 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2446 /* Try to minimize scrolling, by setting the window start to the point
2447 will cause the text at the old window start to be at the same place
2448 on the frame. But don't try to do this if the window start is
2449 outside the visible portion (as might happen when the display is
2450 not current, due to typeahead). */
2451 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2453 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2454 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2456 struct position pos
;
2457 struct buffer
*obuf
= current_buffer
;
2459 Fset_buffer (w
->buffer
);
2460 /* This computation used to temporarily move point, but that can
2461 have unwanted side effects due to text properties. */
2462 pos
= *vmotion (startpos
, -top
, w
);
2464 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2465 w
->window_end_valid
= Qnil
;
2466 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2467 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2469 /* We need to do this, so that the window-scroll-functions
2471 w
->optional_new_start
= Qt
;
2473 set_buffer_internal (obuf
);
2479 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2480 1, 2, "bDelete windows on (buffer): ",
2481 doc
: /* Delete all windows showing BUFFER.
2482 BUFFER must be a buffer or the name of an existing buffer.
2483 Optional second argument FRAME controls which frames are affected.
2484 If optional argument FRAME is `visible', search all visible frames.
2485 If FRAME is 0, search all visible and iconified frames.
2486 If FRAME is nil, search all frames.
2487 If FRAME is t, search only the selected frame.
2488 If FRAME is a frame, search only that frame. */)
2490 Lisp_Object buffer
, frame
;
2492 /* FRAME uses t and nil to mean the opposite of what window_loop
2496 else if (EQ (frame
, Qt
))
2501 buffer
= Fget_buffer (buffer
);
2502 CHECK_BUFFER (buffer
);
2503 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2509 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2510 Sreplace_buffer_in_windows
,
2511 1, 1, "bReplace buffer in windows: ",
2512 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2513 BUFFER may be a buffer or the name of an existing buffer. */)
2519 buffer
= Fget_buffer (buffer
);
2520 CHECK_BUFFER (buffer
);
2521 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2526 /* Replace BUFFER with some other buffer in all windows
2527 of all frames, even those on other keyboards. */
2530 replace_buffer_in_all_windows (buffer
)
2534 Lisp_Object tail
, frame
;
2536 /* A single call to window_loop won't do the job
2537 because it only considers frames on the current keyboard.
2538 So loop manually over frames, and handle each one. */
2539 FOR_EACH_FRAME (tail
, frame
)
2540 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2542 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2546 /* Set the height of WINDOW and all its inferiors. */
2548 /* The smallest acceptable dimensions for a window. Anything smaller
2549 might crash Emacs. */
2551 #define MIN_SAFE_WINDOW_WIDTH (2)
2552 #define MIN_SAFE_WINDOW_HEIGHT (1)
2554 /* Make sure that window_min_height and window_min_width are
2555 not too small; if they are, set them to safe minima. */
2558 check_min_window_sizes ()
2560 /* Smaller values might permit a crash. */
2561 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2562 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2563 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2564 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2567 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2568 minimum allowable size. */
2571 check_frame_size (frame
, rows
, cols
)
2575 /* For height, we have to see:
2576 how many windows the frame has at minimum (one or two),
2577 and whether it has a menu bar or other special stuff at the top. */
2579 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2580 ? MIN_SAFE_WINDOW_HEIGHT
2581 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2583 if (FRAME_TOP_MARGIN (frame
) > 0)
2584 min_height
+= FRAME_TOP_MARGIN (frame
);
2586 if (*rows
< min_height
)
2588 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2589 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2592 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2593 check if W's width can be changed, otherwise check W's height.
2594 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2595 siblings, too. If none of the siblings is resizable, WINDOW isn't
2599 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2601 int width_p
, check_siblings_p
;
2606 if (!NILP (w
->hchild
))
2608 c
= XWINDOW (w
->hchild
);
2612 /* A horiz. combination is fixed-width if all of if its
2614 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2615 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2616 fixed_p
= c
== NULL
;
2620 /* A horiz. combination is fixed-height if one of if its
2622 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2623 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2624 fixed_p
= c
!= NULL
;
2627 else if (!NILP (w
->vchild
))
2629 c
= XWINDOW (w
->vchild
);
2633 /* A vert. combination is fixed-width if one of if its
2635 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2636 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2637 fixed_p
= c
!= NULL
;
2641 /* A vert. combination is fixed-height if all of if its
2643 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2644 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2645 fixed_p
= c
== NULL
;
2648 else if (BUFFERP (w
->buffer
))
2650 struct buffer
*old
= current_buffer
;
2653 current_buffer
= XBUFFER (w
->buffer
);
2654 val
= find_symbol_value (Qwindow_size_fixed
);
2655 current_buffer
= old
;
2658 if (!EQ (val
, Qunbound
))
2660 fixed_p
= !NILP (val
);
2663 && ((EQ (val
, Qheight
) && width_p
)
2664 || (EQ (val
, Qwidth
) && !width_p
)))
2668 /* Can't tell if this one is resizable without looking at
2669 siblings. If all siblings are fixed-size this one is too. */
2670 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2674 for (child
= w
->prev
; WINDOWP (child
); child
= XWINDOW (child
)->prev
)
2675 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2679 for (child
= w
->next
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
2680 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2693 /* Return the minimum size for leaf window W. WIDTH_P non-zero means
2694 take into account fringes and the scrollbar of W. WIDTH_P zero means
2695 take into account mode-line of W. Return 1 for the minibuffer. */
2698 window_min_size_2 (w
, width_p
)
2705 size
= max (window_min_width
,
2706 (MIN_SAFE_WINDOW_WIDTH
2707 + WINDOW_FRINGE_COLS (w
)
2708 + WINDOW_SCROLL_BAR_COLS (w
)));
2709 else if (MINI_WINDOW_P (w
))
2712 size
= max (window_min_height
,
2713 (MIN_SAFE_WINDOW_HEIGHT
2714 /* Don't count the header-line here. It would break
2715 splitting a window with a header-line when the new
2716 window shall have a height of two (calculator does
2718 + (WINDOW_WANTS_MODELINE_P (w
) ? 1 : 0)));
2723 /* Return the minimum size of window W, not taking fixed-width windows
2724 into account. WIDTH_P non-zero means return the minimum width,
2725 otherwise return the minimum height. If W is a combination window,
2726 compute the minimum size from the minimum sizes of W's children. */
2729 window_min_size_1 (w
, width_p
)
2736 if (!NILP (w
->hchild
))
2738 c
= XWINDOW (w
->hchild
);
2743 /* The min width of a horizontal combination is
2744 the sum of the min widths of its children. */
2747 size
+= window_min_size_1 (c
, width_p
);
2748 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2753 /* The min height a horizontal combination equals
2754 the maximum of all min height of its children. */
2757 int min_size
= window_min_size_1 (c
, width_p
);
2758 size
= max (min_size
, size
);
2759 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2763 else if (!NILP (w
->vchild
))
2765 c
= XWINDOW (w
->vchild
);
2770 /* The min width of a vertical combination is
2771 the maximum of the min widths of its children. */
2774 int min_size
= window_min_size_1 (c
, width_p
);
2775 size
= max (min_size
, size
);
2776 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2781 /* The min height of a vertical combination equals
2782 the sum of the min height of its children. */
2785 size
+= window_min_size_1 (c
, width_p
);
2786 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2791 size
= window_min_size_2 (w
, width_p
);
2797 /* Return the minimum size of window W, taking fixed-size windows into
2798 account. WIDTH_P non-zero means return the minimum width,
2799 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2800 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2801 unless FIXED is null. */
2804 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2806 int width_p
, ignore_fixed_p
, *fixed
;
2813 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2819 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2821 size
= window_min_size_1 (w
, width_p
);
2827 /* Adjust the margins of window W if text area is too small.
2828 Return 1 if window width is ok after adjustment; 0 if window
2829 is still too narrow. */
2832 adjust_window_margins (w
)
2835 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2836 - WINDOW_FRINGE_COLS (w
)
2837 - WINDOW_SCROLL_BAR_COLS (w
));
2838 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2839 + WINDOW_RIGHT_MARGIN_COLS (w
));
2841 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2844 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2847 /* Window's text area is too narrow, but reducing the window
2848 margins will fix that. */
2849 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2850 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2852 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2853 w
->left_margin_cols
= w
->right_margin_cols
2854 = make_number (margin_cols
/2);
2856 w
->right_margin_cols
= make_number (margin_cols
);
2859 w
->left_margin_cols
= make_number (margin_cols
);
2863 /* Calculate new sizes for windows in the list FORWARD when the window size
2864 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2865 The number of windows in FORWARD is NCHILDREN, and the number that
2866 can shrink is SHRINKABLE.
2867 The minimum size a window can have is MIN_SIZE.
2868 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2869 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2872 This function returns an allocated array of new sizes that the caller
2873 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2874 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2875 the second, and so on.
2877 This function tries to keep windows at least at the minimum size
2878 and resize other windows before it resizes any window to zero (i.e.
2879 delete that window).
2881 Windows are resized proportional to their size, so bigger windows
2882 shrink more than smaller windows. */
2884 shrink_windows (total
, size
, nchildren
, shrinkable
,
2885 min_size
, resize_fixed_p
, forward
, width_p
)
2886 int total
, size
, nchildren
, shrinkable
, min_size
;
2887 int resize_fixed_p
, width_p
;
2888 Lisp_Object forward
;
2890 int available_resize
= 0;
2894 int smallest
= total
;
2895 int total_removed
= 0;
2896 int total_shrink
= total
- size
;
2899 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2901 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2905 c
= XWINDOW (child
);
2906 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2908 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2912 new_sizes
[i
] = child_size
;
2913 if (child_size
> min_size
)
2914 available_resize
+= child_size
- min_size
;
2917 /* We might need to shrink some windows to zero. Find the smallest
2918 windows and set them to 0 until we can fulfil the new size. */
2920 while (shrinkable
> 1 && size
+ available_resize
< total
)
2922 for (i
= 0; i
< nchildren
; ++i
)
2923 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2924 smallest
= new_sizes
[i
];
2926 for (i
= 0; i
< nchildren
; ++i
)
2927 if (new_sizes
[i
] == smallest
)
2929 /* Resize this window down to zero. */
2931 if (smallest
> min_size
)
2932 available_resize
-= smallest
- min_size
;
2933 available_resize
+= smallest
;
2935 total_removed
+= smallest
;
2937 /* We don't know what the smallest is now. */
2940 /* Out of for, just remove one window at the time and
2941 check again if we have enough space. */
2946 /* Now, calculate the new sizes. Try to shrink each window
2947 proportional to its size. */
2948 for (i
= 0; i
< nchildren
; ++i
)
2950 if (new_sizes
[i
] > min_size
)
2952 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2953 if (new_sizes
[i
] - to_shrink
< min_size
)
2954 to_shrink
= new_sizes
[i
] - min_size
;
2955 new_sizes
[i
] -= to_shrink
;
2956 total_removed
+= to_shrink
;
2960 /* Any reminder due to rounding, we just subtract from windows
2961 that are left and still can be shrunk. */
2962 while (total_shrink
> total_removed
)
2964 int nonzero_sizes
= 0;
2965 int nonzero_idx
= -1;
2967 for (i
= 0; i
< nchildren
; ++i
)
2968 if (new_sizes
[i
] > 0)
2974 for (i
= 0; i
< nchildren
; ++i
)
2975 if (new_sizes
[i
] > min_size
)
2980 /* Out of for, just shrink one window at the time and
2981 check again if we have enough space. */
2986 /* Special case, only one window left. */
2987 if (nonzero_sizes
== 1)
2991 /* Any surplus due to rounding, we add to windows that are left. */
2992 while (total_shrink
< total_removed
)
2994 for (i
= 0; i
< nchildren
; ++i
)
2996 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
3008 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
3009 WINDOW's width. Resize WINDOW's children, if any, so that they
3010 keep their proportionate size relative to WINDOW.
3012 If FIRST_ONLY is 1, change only the first of WINDOW's children when
3013 they are in series. If LAST_ONLY is 1, change only the last of
3014 WINDOW's children when they are in series.
3016 Propagate WINDOW's top or left edge position to children. Delete
3017 windows that become too small unless NODELETE_P is non-zero.
3019 If NODELETE_P is 2, that means we do delete windows that are
3020 too small, even if they were too small before! */
3023 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
3025 int size
, width_p
, nodelete_p
;
3026 int first_only
, last_only
;
3028 struct window
*w
= XWINDOW (window
);
3030 Lisp_Object child
, *forward
, *sideward
;
3031 int old_size
, min_size
, safe_min_size
;
3033 check_min_window_sizes ();
3034 size
= max (0, size
);
3036 /* If the window has been "too small" at one point,
3037 don't delete it for being "too small" in the future.
3038 Preserve it as long as that is at all possible. */
3041 old_size
= WINDOW_TOTAL_COLS (w
);
3042 min_size
= window_min_width
;
3043 safe_min_size
= window_min_size_2 (w
, 1);
3047 old_size
= XINT (w
->total_lines
);
3048 min_size
= window_min_height
;
3049 safe_min_size
= window_min_size_2 (w
, 0);
3052 if (old_size
< min_size
&& nodelete_p
!= 2)
3053 w
->too_small_ok
= Qt
;
3055 /* Move the following test here since otherwise the
3056 preceding test doesn't make sense. martin. */
3057 if (nodelete_p
== 2)
3060 /* Maybe delete WINDOW if it's too small. */
3061 if (nodelete_p
!= 1 && !NILP (w
->parent
))
3063 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
3064 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
3065 if (min_size
< safe_min_size
)
3066 min_size
= safe_min_size
;
3067 if (size
< min_size
)
3069 delete_window (window
);
3074 /* Set redisplay hints. */
3075 w
->last_modified
= make_number (0);
3076 w
->last_overlay_modified
= make_number (0);
3077 windows_or_buffers_changed
++;
3078 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3082 sideward
= &w
->vchild
;
3083 forward
= &w
->hchild
;
3084 w
->total_cols
= make_number (size
);
3085 adjust_window_margins (w
);
3089 sideward
= &w
->hchild
;
3090 forward
= &w
->vchild
;
3091 w
->total_lines
= make_number (size
);
3092 w
->orig_total_lines
= Qnil
;
3095 if (!NILP (*sideward
))
3097 /* We have a chain of parallel siblings whose size should all change. */
3098 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3100 c
= XWINDOW (child
);
3102 c
->left_col
= w
->left_col
;
3104 c
->top_line
= w
->top_line
;
3105 size_window (child
, size
, width_p
, nodelete_p
,
3106 first_only
, last_only
);
3109 else if (!NILP (*forward
) && last_only
)
3111 /* Change the last in a series of siblings. */
3112 Lisp_Object last_child
;
3115 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3117 c
= XWINDOW (child
);
3121 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3122 size_window (last_child
,
3123 size
- old_size
+ child_size
,
3124 width_p
, nodelete_p
, first_only
, last_only
);
3126 else if (!NILP (*forward
) && first_only
)
3128 /* Change the first in a series of siblings. */
3132 c
= XWINDOW (child
);
3135 c
->left_col
= w
->left_col
;
3137 c
->top_line
= w
->top_line
;
3139 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3141 size
- old_size
+ child_size
,
3142 width_p
, nodelete_p
, first_only
, last_only
);
3144 else if (!NILP (*forward
))
3146 int fixed_size
, each
, extra
, n
;
3147 int resize_fixed_p
, nfixed
;
3148 int last_pos
, first_pos
, nchildren
, total
;
3149 int *new_sizes
= NULL
;
3151 /* Determine the fixed-size portion of this window, and the
3152 number of child windows. */
3153 fixed_size
= nchildren
= nfixed
= total
= 0;
3154 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3158 c
= XWINDOW (child
);
3159 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3160 total
+= child_size
;
3162 if (window_fixed_size_p (c
, width_p
, 0))
3164 fixed_size
+= child_size
;
3169 /* If the new size is smaller than fixed_size, or if there
3170 aren't any resizable windows, allow resizing fixed-size
3172 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3174 /* Compute how many lines/columns to add/remove to each child. The
3175 value of extra takes care of rounding errors. */
3176 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3177 if (size
< total
&& n
> 1)
3178 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
3179 resize_fixed_p
, *forward
, width_p
);
3182 each
= (size
- total
) / n
;
3183 extra
= (size
- total
) - n
* each
;
3186 /* Compute new children heights and edge positions. */
3187 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3188 last_pos
= first_pos
;
3189 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3191 int new_size
, old_size
;
3193 c
= XWINDOW (child
);
3194 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
3195 new_size
= old_size
;
3197 /* The top or left edge position of this child equals the
3198 bottom or right edge of its predecessor. */
3200 c
->left_col
= make_number (last_pos
);
3202 c
->top_line
= make_number (last_pos
);
3204 /* If this child can be resized, do it. */
3205 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3207 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3211 /* Set new height. Note that size_window also propagates
3212 edge positions to children, so it's not a no-op if we
3213 didn't change the child's size. */
3214 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3216 /* Remember the bottom/right edge position of this child; it
3217 will be used to set the top/left edge of the next child. */
3218 last_pos
+= new_size
;
3221 if (new_sizes
) xfree (new_sizes
);
3223 /* We should have covered the parent exactly with child windows. */
3224 xassert (size
== last_pos
- first_pos
);
3226 /* Now delete any children that became too small. */
3228 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3231 c
= XWINDOW (child
);
3232 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3233 size_window (child
, child_size
, width_p
, 2, first_only
, last_only
);
3238 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3239 WINDOW's children. NODELETE non-zero means don't delete windows
3240 that become too small in the process. (The caller should check
3241 later and do so if appropriate.) */
3244 set_window_height (window
, height
, nodelete
)
3249 size_window (window
, height
, 0, nodelete
, 0, 0);
3253 /* Set WINDOW's width to WIDTH, and recursively change the width of
3254 WINDOW's children. NODELETE non-zero means don't delete windows
3255 that become too small in the process. (The caller should check
3256 later and do so if appropriate.) */
3259 set_window_width (window
, width
, nodelete
)
3264 size_window (window
, width
, 1, nodelete
, 0, 0);
3267 /* Change window heights in windows rooted in WINDOW by N lines. */
3270 change_window_heights (window
, n
)
3274 struct window
*w
= XWINDOW (window
);
3276 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3277 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3279 if (INTEGERP (w
->orig_top_line
))
3280 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3281 if (INTEGERP (w
->orig_total_lines
))
3282 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3284 /* Handle just the top child in a vertical split. */
3285 if (!NILP (w
->vchild
))
3286 change_window_heights (w
->vchild
, n
);
3288 /* Adjust all children in a horizontal split. */
3289 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3291 w
= XWINDOW (window
);
3292 change_window_heights (window
, n
);
3297 int window_select_count
;
3300 Fset_window_buffer_unwind (obuf
)
3307 EXFUN (Fset_window_fringes
, 4);
3308 EXFUN (Fset_window_scroll_bars
, 4);
3310 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3311 means it's allowed to run hooks. See make_frame for a case where
3312 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3313 margins, fringes, and scroll-bar settings of the window are not
3314 reset from the buffer's local settings. */
3317 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3318 Lisp_Object window
, buffer
;
3319 int run_hooks_p
, keep_margins_p
;
3321 struct window
*w
= XWINDOW (window
);
3322 struct buffer
*b
= XBUFFER (buffer
);
3323 int count
= SPECPDL_INDEX ();
3324 int samebuf
= EQ (buffer
, w
->buffer
);
3328 if (EQ (window
, selected_window
))
3329 b
->last_selected_window
= window
;
3331 /* Let redisplay errors through. */
3332 b
->display_error_modiff
= 0;
3334 /* Update time stamps of buffer display. */
3335 if (INTEGERP (b
->display_count
))
3336 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3337 b
->display_time
= Fcurrent_time ();
3339 XSETFASTINT (w
->window_end_pos
, 0);
3340 XSETFASTINT (w
->window_end_vpos
, 0);
3341 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3342 w
->window_end_valid
= Qnil
;
3343 if (!(keep_margins_p
&& samebuf
))
3344 { /* If we're not actually changing the buffer, Don't reset hscroll and
3345 vscroll. This case happens for example when called from
3346 change_frame_size_1, where we use a dummy call to
3347 Fset_window_buffer on the frame's selected window (and no other)
3348 just in order to run window-configuration-change-hook.
3349 Resetting hscroll and vscroll here is problematic for things like
3350 image-mode and doc-view-mode since it resets the image's position
3351 whenever we resize the frame. */
3352 w
->hscroll
= w
->min_hscroll
= make_number (0);
3354 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3355 set_marker_restricted (w
->start
,
3356 make_number (b
->last_window_start
),
3358 w
->start_at_line_beg
= Qnil
;
3359 w
->force_start
= Qnil
;
3360 XSETFASTINT (w
->last_modified
, 0);
3361 XSETFASTINT (w
->last_overlay_modified
, 0);
3363 /* Maybe we could move this into the `if' but it's not obviously safe and
3364 I doubt it's worth the trouble. */
3365 windows_or_buffers_changed
++;
3367 /* We must select BUFFER for running the window-scroll-functions.
3368 If WINDOW is selected, switch permanently.
3369 Otherwise, switch but go back to the ambient buffer afterward. */
3370 if (EQ (window
, selected_window
))
3371 Fset_buffer (buffer
);
3372 /* We can't check ! NILP (Vwindow_scroll_functions) here
3373 because that might itself be a local variable. */
3374 else if (window_initialized
)
3376 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3377 Fset_buffer (buffer
);
3380 if (!keep_margins_p
)
3382 /* Set left and right marginal area width etc. from buffer. */
3384 /* This may call adjust_window_margins three times, so
3385 temporarily disable window margins. */
3386 Lisp_Object save_left
= w
->left_margin_cols
;
3387 Lisp_Object save_right
= w
->right_margin_cols
;
3389 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3391 Fset_window_fringes (window
,
3392 b
->left_fringe_width
, b
->right_fringe_width
,
3393 b
->fringes_outside_margins
);
3395 Fset_window_scroll_bars (window
,
3396 b
->scroll_bar_width
,
3397 b
->vertical_scroll_bar_type
, Qnil
);
3399 w
->left_margin_cols
= save_left
;
3400 w
->right_margin_cols
= save_right
;
3402 Fset_window_margins (window
,
3403 b
->left_margin_cols
, b
->right_margin_cols
);
3408 if (! NILP (Vwindow_scroll_functions
))
3409 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3410 Fmarker_position (w
->start
));
3412 if (! NILP (Vwindow_configuration_change_hook
)
3413 && ! NILP (Vrun_hooks
))
3414 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3417 unbind_to (count
, Qnil
);
3421 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3422 doc
: /* Make WINDOW display BUFFER as its contents.
3423 BUFFER can be a buffer or the name of an existing buffer.
3424 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3425 display margins, fringe widths, and scroll bar settings are maintained;
3426 the default is to reset these from BUFFER's local settings or the frame
3429 This function runs the hook `window-scroll-functions'. */)
3430 (window
, buffer
, keep_margins
)
3431 register Lisp_Object window
, buffer
, keep_margins
;
3433 register Lisp_Object tem
;
3434 register struct window
*w
= decode_window (window
);
3436 XSETWINDOW (window
, w
);
3437 buffer
= Fget_buffer (buffer
);
3438 CHECK_BUFFER (buffer
);
3440 if (NILP (XBUFFER (buffer
)->name
))
3441 error ("Attempt to display deleted buffer");
3445 error ("Window is deleted");
3446 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3447 is first being set up. */
3449 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3450 error ("Window is dedicated to `%s'",
3451 SDATA (XBUFFER (tem
)->name
));
3456 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3460 /* Note that selected_window can be nil
3461 when this is called from Fset_window_configuration. */
3463 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3464 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3465 If WINDOW is not already selected, make WINDOW's buffer current
3466 and make WINDOW the frame's selected window. Return WINDOW.
3467 Optional second arg NORECORD non-nil means
3468 do not put this buffer at the front of the list of recently selected ones.
3470 Note that the main editor command loop
3471 selects the buffer of the selected window before each command. */)
3473 register Lisp_Object window
, norecord
;
3475 register struct window
*w
;
3476 register struct window
*ow
;
3479 CHECK_LIVE_WINDOW (window
);
3481 w
= XWINDOW (window
);
3482 w
->frozen_window_start_p
= 0;
3484 ++window_select_count
;
3485 XSETFASTINT (w
->use_time
, window_select_count
);
3486 if (EQ (window
, selected_window
))
3489 sf
= SELECTED_FRAME ();
3490 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3492 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3493 /* Use this rather than Fhandle_switch_frame
3494 so that FRAME_FOCUS_FRAME is moved appropriately as we
3495 move around in the state where a minibuffer in a separate
3497 Fselect_frame (WINDOW_FRAME (w
));
3498 /* Fselect_frame called us back so we've done all the work already. */
3499 eassert (EQ (window
, selected_window
));
3503 sf
->selected_window
= window
;
3505 /* Store the current buffer's actual point into the
3506 old selected window. It belongs to that window,
3507 and when the window is not selected, must be in the window. */
3508 if (!NILP (selected_window
))
3510 ow
= XWINDOW (selected_window
);
3511 if (! NILP (ow
->buffer
))
3512 set_marker_both (ow
->pointm
, ow
->buffer
,
3513 BUF_PT (XBUFFER (ow
->buffer
)),
3514 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3517 selected_window
= window
;
3519 if (NILP (norecord
))
3520 record_buffer (w
->buffer
);
3521 Fset_buffer (w
->buffer
);
3523 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3525 /* Go to the point recorded in the window.
3526 This is important when the buffer is in more
3527 than one window. It also matters when
3528 redisplay_window has altered point after scrolling,
3529 because it makes the change only in the window. */
3531 register int new_point
= marker_position (w
->pointm
);
3532 if (new_point
< BEGV
)
3534 else if (new_point
> ZV
)
3540 windows_or_buffers_changed
++;
3545 select_window_norecord (window
)
3548 return Fselect_window (window
, Qt
);
3551 /* Deiconify the frame containing the window WINDOW,
3552 unless it is the selected frame;
3555 The reason for the exception for the selected frame
3556 is that it seems better not to change the selected frames visibility
3557 merely because of displaying a different buffer in it.
3558 The deiconification is useful when a buffer gets shown in
3559 another frame that you were not using lately. */
3562 display_buffer_1 (window
)
3565 Lisp_Object frame
= XWINDOW (window
)->frame
;
3566 FRAME_PTR f
= XFRAME (frame
);
3568 FRAME_SAMPLE_VISIBILITY (f
);
3570 if (EQ (frame
, selected_frame
))
3571 ; /* Assume the selected frame is already visible enough. */
3572 else if (minibuf_level
> 0
3573 && MINI_WINDOW_P (XWINDOW (selected_window
))
3574 && WINDOW_LIVE_P (minibuf_selected_window
)
3575 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3576 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3579 if (FRAME_ICONIFIED_P (f
))
3580 Fmake_frame_visible (frame
);
3581 else if (FRAME_VISIBLE_P (f
))
3582 Fraise_frame (frame
);
3588 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3589 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3590 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3591 special frame for that buffer using the default frame parameters.
3593 If the value is a list, it is a list of frame parameters that would be used
3594 to make a frame for that buffer.
3595 The variables `special-display-buffer-names'
3596 and `special-display-regexps' control this. */)
3598 Lisp_Object buffer_name
;
3602 CHECK_STRING (buffer_name
);
3604 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3608 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3612 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3614 Lisp_Object car
= XCAR (tem
);
3616 && fast_string_match (car
, buffer_name
) >= 0)
3618 else if (CONSP (car
)
3619 && STRINGP (XCAR (car
))
3620 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3626 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3627 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3628 More precisely, if `display-buffer' or `pop-to-buffer' would display
3629 that buffer in the selected window rather than (as usual) in some other window.
3630 See `same-window-buffer-names' and `same-window-regexps'. */)
3632 Lisp_Object buffer_name
;
3636 CHECK_STRING (buffer_name
);
3638 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3642 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3646 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3648 Lisp_Object car
= XCAR (tem
);
3650 && fast_string_match (car
, buffer_name
) >= 0)
3652 else if (CONSP (car
)
3653 && STRINGP (XCAR (car
))
3654 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3660 /* Use B so the default is (other-buffer). */
3661 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3662 "BDisplay buffer: \nP",
3663 doc
: /* Make BUFFER appear in some window but don't select it.
3664 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3666 If BUFFER is shown already in some window, just use that one,
3667 unless the window is the selected window and the optional second
3668 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3669 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3670 Returns the window displaying BUFFER.
3671 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3672 displaying BUFFER, then simply raise that frame.
3674 The variables `special-display-buffer-names',
3675 `special-display-regexps', `same-window-buffer-names', and
3676 `same-window-regexps' customize how certain buffer names are handled.
3677 The latter two take effect only if NOT-THIS-WINDOW is nil.
3679 If optional argument FRAME is `visible', check all visible frames
3680 for a window to use.
3681 If FRAME is 0, check all visible and iconified frames.
3682 If FRAME is t, check all frames.
3683 If FRAME is a frame, check only that frame.
3684 If FRAME is nil, check only the selected frame
3685 (actually the last nonminibuffer frame),
3686 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3687 which means search visible and iconified frames.
3689 If a full-width window on a splittable frame is available to display
3690 the buffer, it may be split, subject to the value of the variable
3691 `split-height-threshold'.
3693 If `even-window-heights' is non-nil, window heights will be evened out
3694 if displaying the buffer causes two vertically adjacent windows to be
3696 (buffer
, not_this_window
, frame
)
3697 Lisp_Object buffer
, not_this_window
, frame
;
3699 register Lisp_Object window
, tem
, swp
;
3703 buffer
= Fget_buffer (buffer
);
3704 CHECK_BUFFER (buffer
);
3706 if (!NILP (Vdisplay_buffer_function
))
3707 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3709 if (NILP (not_this_window
)
3710 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3711 return display_buffer_1 (selected_window
);
3713 /* See if the user has specified this buffer should appear
3714 in the selected window. */
3715 if (NILP (not_this_window
))
3717 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3718 if (!NILP (swp
) && !no_switch_window (selected_window
))
3720 Fswitch_to_buffer (buffer
, Qnil
);
3721 return display_buffer_1 (selected_window
);
3725 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3726 look for a window showing BUFFER on any visible or iconified frame.
3727 Otherwise search only the current frame. */
3730 else if (pop_up_frames
3731 || display_buffer_reuse_frames
3732 || last_nonminibuf_frame
== 0)
3733 XSETFASTINT (tem
, 0);
3735 XSETFRAME (tem
, last_nonminibuf_frame
);
3737 window
= Fget_buffer_window (buffer
, tem
);
3739 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3740 return display_buffer_1 (window
);
3742 /* Certain buffer names get special handling. */
3743 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3745 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3747 return call1 (Vspecial_display_function
, buffer
);
3749 return call2 (Vspecial_display_function
, buffer
, tem
);
3752 /* If there are no frames open that have more than a minibuffer,
3753 we need to create a new frame. */
3754 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3756 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3757 Fset_window_buffer (window
, buffer
, Qnil
);
3758 return display_buffer_1 (window
);
3761 f
= SELECTED_FRAME ();
3763 || FRAME_MINIBUF_ONLY_P (f
)
3764 /* If the current frame is a special display frame,
3765 don't try to reuse its windows. */
3766 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3769 struct gcpro gcpro1
;
3773 if (FRAME_MINIBUF_ONLY_P (f
))
3774 XSETFRAME (frames
, last_nonminibuf_frame
);
3776 /* Note that both Fget_largest_window and Fget_lru_window
3777 ignore minibuffers and dedicated windows.
3778 This means they can return nil. */
3780 /* If the frame we would try to split cannot be split,
3781 try other frames. */
3782 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3784 /* Try visible frames first. */
3785 window
= Fget_largest_window (Qvisible
, Qt
);
3786 /* If that didn't work, try iconified frames. */
3788 window
= Fget_largest_window (make_number (0), Qt
);
3789 #if 0 /* Don't try windows on other displays. */
3791 window
= Fget_largest_window (Qt
, Qt
);
3795 window
= Fget_largest_window (frames
, Qt
);
3797 /* If the largest window is tall enough, full-width, and either eligible
3798 for splitting or the only window, split it. */
3800 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3801 && WINDOW_FULL_WIDTH_P (XWINDOW (window
))
3802 && (window_height (window
) >= split_height_threshold
3803 || (NILP (XWINDOW (window
)->parent
)))
3804 && (window_height (window
)
3805 >= (2 * window_min_size_2 (XWINDOW (window
), 0))))
3806 window
= call1 (Vsplit_window_preferred_function
, window
);
3809 Lisp_Object upper
, lower
, other
;
3811 window
= Fget_lru_window (frames
, Qt
);
3812 /* If the LRU window is tall enough, and either eligible for
3813 splitting and selected or the only window, split it. */
3815 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3816 && ((EQ (window
, selected_window
)
3817 && window_height (window
) >= split_height_threshold
)
3818 || (NILP (XWINDOW (window
)->parent
)))
3819 && (window_height (window
)
3820 >= (2 * window_min_size_2 (XWINDOW (window
), 0))))
3821 window
= call1 (Vsplit_window_preferred_function
, window
);
3823 window
= Fget_lru_window (frames
, Qnil
);
3824 /* If Fget_lru_window returned nil, try other approaches. */
3826 /* Try visible frames first. */
3828 window
= Fget_buffer_window (buffer
, Qvisible
);
3830 window
= Fget_largest_window (Qvisible
, Qnil
);
3831 /* If that didn't work, try iconified frames. */
3833 window
= Fget_buffer_window (buffer
, make_number (0));
3835 window
= Fget_largest_window (make_number (0), Qnil
);
3837 #if 0 /* Don't try frames on other displays. */
3839 window
= Fget_buffer_window (buffer
, Qt
);
3841 window
= Fget_largest_window (Qt
, Qnil
);
3843 /* As a last resort, make a new frame. */
3845 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3846 /* If window appears above or below another,
3847 even out their heights. */
3848 other
= upper
= lower
= Qnil
;
3849 if (!NILP (XWINDOW (window
)->prev
))
3850 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3851 if (!NILP (XWINDOW (window
)->next
))
3852 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3854 && !NILP (Veven_window_heights
)
3855 /* Check that OTHER and WINDOW are vertically arrayed. */
3856 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3857 && (XFASTINT (XWINDOW (other
)->total_lines
)
3858 > XFASTINT (XWINDOW (window
)->total_lines
)))
3860 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3861 + XFASTINT (XWINDOW (window
)->total_lines
));
3862 enlarge_window (upper
,
3863 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3870 window
= Fget_lru_window (Qnil
, Qnil
);
3872 Fset_window_buffer (window
, buffer
, Qnil
);
3873 return display_buffer_1 (window
);
3877 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3879 doc
: /* Force all windows to be updated on next redisplay.
3880 If optional arg OBJECT is a window, force redisplay of that window only.
3881 If OBJECT is a buffer or buffer name, force redisplay of all windows
3882 displaying that buffer. */)
3888 windows_or_buffers_changed
++;
3889 update_mode_lines
++;
3893 if (WINDOWP (object
))
3895 struct window
*w
= XWINDOW (object
);
3896 mark_window_display_accurate (object
, 0);
3897 w
->update_mode_line
= Qt
;
3898 if (BUFFERP (w
->buffer
))
3899 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3900 ++update_mode_lines
;
3904 if (STRINGP (object
))
3905 object
= Fget_buffer (object
);
3906 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3908 /* Walk all windows looking for buffer, and force update
3909 of each of those windows. */
3911 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3912 return NILP (object
) ? Qnil
: Qt
;
3915 /* If nothing suitable was found, just return.
3916 We could signal an error, but this feature will typically be used
3917 asynchronously in timers or process sentinels, so we don't. */
3923 temp_output_buffer_show (buf
)
3924 register Lisp_Object buf
;
3926 register struct buffer
*old
= current_buffer
;
3927 register Lisp_Object window
;
3928 register struct window
*w
;
3930 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3933 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3937 #if 0 /* rms: there should be no reason for this. */
3938 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3940 set_buffer_internal (old
);
3942 if (!NILP (Vtemp_buffer_show_function
))
3943 call1 (Vtemp_buffer_show_function
, buf
);
3946 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3948 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3949 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3950 Vminibuf_scroll_window
= window
;
3951 w
= XWINDOW (window
);
3952 XSETFASTINT (w
->hscroll
, 0);
3953 XSETFASTINT (w
->min_hscroll
, 0);
3954 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3955 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3957 /* Run temp-buffer-show-hook, with the chosen window selected
3958 and its buffer current. */
3960 if (!NILP (Vrun_hooks
)
3961 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3962 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3964 int count
= SPECPDL_INDEX ();
3965 Lisp_Object prev_window
, prev_buffer
;
3966 prev_window
= selected_window
;
3967 XSETBUFFER (prev_buffer
, old
);
3969 /* Select the window that was chosen, for running the hook.
3970 Note: Both Fselect_window and select_window_norecord may
3971 set-buffer to the buffer displayed in the window,
3972 so we need to save the current buffer. --stef */
3973 record_unwind_protect (Fset_buffer
, prev_buffer
);
3974 record_unwind_protect (select_window_norecord
, prev_window
);
3975 Fselect_window (window
, Qt
);
3976 Fset_buffer (w
->buffer
);
3977 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3978 unbind_to (count
, Qnil
);
3984 make_dummy_parent (window
)
3988 register struct window
*o
, *p
;
3991 o
= XWINDOW (window
);
3992 p
= allocate_window ();
3993 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3994 ((struct Lisp_Vector
*) p
)->contents
[i
]
3995 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3996 XSETWINDOW (new, p
);
3999 XSETFASTINT (p
->sequence_number
, sequence_number
);
4001 /* Put new into window structure in place of window */
4002 replace_window (window
, new);
4015 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
4016 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
4017 WINDOW defaults to selected one and SIZE to half its size.
4018 If optional third arg HORFLAG is non-nil, split side by side
4019 and put SIZE columns in the first of the pair. In that case,
4020 SIZE includes that window's scroll bar, or the divider column to its right.
4021 Interactively, all arguments are nil.
4023 Returns the newly created window (which is the lower or rightmost one).
4024 The upper or leftmost window is the original one, and remains selected
4025 if it was selected before.
4027 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
4028 (window
, size
, horflag
)
4029 Lisp_Object window
, size
, horflag
;
4031 register Lisp_Object
new;
4032 register struct window
*o
, *p
;
4034 register int size_int
;
4037 window
= selected_window
;
4039 CHECK_LIVE_WINDOW (window
);
4041 o
= XWINDOW (window
);
4042 fo
= XFRAME (WINDOW_FRAME (o
));
4046 if (!NILP (horflag
))
4047 /* Calculate the size of the left-hand window, by dividing
4048 the usable space in columns by two.
4049 We round up, since the left-hand window may include
4050 a dividing line, while the right-hand may not. */
4051 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
4053 size_int
= XFASTINT (o
->total_lines
) >> 1;
4057 CHECK_NUMBER (size
);
4058 size_int
= XINT (size
);
4061 if (MINI_WINDOW_P (o
))
4062 error ("Attempt to split minibuffer window");
4063 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
4064 error ("Attempt to split fixed-size window");
4066 check_min_window_sizes ();
4070 int window_safe_height
= window_min_size_2 (o
, 0);
4072 if (size_int
< window_safe_height
)
4073 error ("Window height %d too small (after splitting)", size_int
);
4074 if (size_int
+ window_safe_height
> XFASTINT (o
->total_lines
))
4075 error ("Window height %d too small (after splitting)",
4076 XFASTINT (o
->total_lines
) - size_int
);
4077 if (NILP (o
->parent
)
4078 || NILP (XWINDOW (o
->parent
)->vchild
))
4080 make_dummy_parent (window
);
4082 XWINDOW (new)->vchild
= window
;
4087 int window_safe_width
= window_min_size_2 (o
, 1);
4089 if (size_int
< window_safe_width
)
4090 error ("Window width %d too small (after splitting)", size_int
);
4091 if (size_int
+ window_safe_width
> XFASTINT (o
->total_cols
))
4092 error ("Window width %d too small (after splitting)",
4093 XFASTINT (o
->total_cols
) - size_int
);
4094 if (NILP (o
->parent
)
4095 || NILP (XWINDOW (o
->parent
)->hchild
))
4097 make_dummy_parent (window
);
4099 XWINDOW (new)->hchild
= window
;
4103 /* Now we know that window's parent is a vertical combination
4104 if we are dividing vertically, or a horizontal combination
4105 if we are making side-by-side windows */
4107 windows_or_buffers_changed
++;
4108 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
4109 new = make_window ();
4112 p
->frame
= o
->frame
;
4114 if (!NILP (p
->next
))
4115 XWINDOW (p
->next
)->prev
= new;
4118 p
->parent
= o
->parent
;
4120 p
->window_end_valid
= Qnil
;
4121 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
4123 /* Duplicate special geometry settings. */
4125 p
->left_margin_cols
= o
->left_margin_cols
;
4126 p
->right_margin_cols
= o
->right_margin_cols
;
4127 p
->left_fringe_width
= o
->left_fringe_width
;
4128 p
->right_fringe_width
= o
->right_fringe_width
;
4129 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
4130 p
->scroll_bar_width
= o
->scroll_bar_width
;
4131 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
4133 /* Apportion the available frame space among the two new windows */
4135 if (!NILP (horflag
))
4137 p
->total_lines
= o
->total_lines
;
4138 p
->top_line
= o
->top_line
;
4139 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
4140 XSETFASTINT (o
->total_cols
, size_int
);
4141 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
4142 adjust_window_margins (p
);
4143 adjust_window_margins (o
);
4147 p
->left_col
= o
->left_col
;
4148 p
->total_cols
= o
->total_cols
;
4149 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
4150 XSETFASTINT (o
->total_lines
, size_int
);
4151 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
4154 /* Adjust glyph matrices. */
4157 Fset_window_buffer (new, o
->buffer
, Qt
);
4161 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
4162 doc
: /* Make current window ARG lines bigger.
4163 From program, optional second arg non-nil means grow sideways ARG columns.
4164 Interactively, if an argument is not given, make the window one line bigger.
4165 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
4166 This function can delete windows, even the second window, if they get
4169 Lisp_Object arg
, horizontal
;
4172 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
4174 if (! NILP (Vwindow_configuration_change_hook
))
4175 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4180 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
4181 doc
: /* Make current window ARG lines smaller.
4182 From program, optional second arg non-nil means shrink sideways arg columns.
4183 Interactively, if an argument is not given, make the window one line smaller.
4184 Only siblings to the right or below are changed. */)
4186 Lisp_Object arg
, side
;
4189 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
4191 if (! NILP (Vwindow_configuration_change_hook
))
4192 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4198 window_height (window
)
4201 register struct window
*p
= XWINDOW (window
);
4202 return WINDOW_TOTAL_LINES (p
);
4206 window_width (window
)
4209 register struct window
*p
= XWINDOW (window
);
4210 return WINDOW_TOTAL_COLS (p
);
4215 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4217 #define CURSIZE(w) \
4218 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4221 /* Enlarge WINDOW by DELTA.
4222 HORIZ_FLAG nonzero means enlarge it horizontally;
4223 zero means do it vertically.
4225 Siblings of the selected window are resized to fulfill the size
4226 request. If they become too small in the process, they will be
4230 enlarge_window (window
, delta
, horiz_flag
)
4232 int delta
, horiz_flag
;
4234 Lisp_Object parent
, next
, prev
;
4238 int (*sizefun
) P_ ((Lisp_Object
))
4239 = horiz_flag
? window_width
: window_height
;
4240 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
4241 = (horiz_flag
? set_window_width
: set_window_height
);
4243 /* Check values of window_min_width and window_min_height for
4245 check_min_window_sizes ();
4247 /* Give up if this window cannot be resized. */
4248 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4249 error ("Window is not resizable");
4251 /* Find the parent of the selected window. */
4254 p
= XWINDOW (window
);
4260 error ("No other window to side of this one");
4265 ? !NILP (XWINDOW (parent
)->hchild
)
4266 : !NILP (XWINDOW (parent
)->vchild
))
4272 sizep
= &CURSIZE (window
);
4275 register int maxdelta
;
4277 /* Compute the maximum size increment this window can have. */
4279 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4280 /* This is a main window followed by a minibuffer. */
4281 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4282 - window_min_size (XWINDOW (p
->next
),
4284 /* This is a minibuffer following a main window. */
4285 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4286 - window_min_size (XWINDOW (p
->prev
),
4288 /* This is a frame with only one window, a minibuffer-only
4289 or a minibufferless frame. */
4292 if (delta
> maxdelta
)
4293 /* This case traps trying to make the minibuffer
4294 the full frame, or make the only window aside from the
4295 minibuffer the full frame. */
4299 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4301 delete_window (window
);
4308 /* Find the total we can get from other siblings without deleting them. */
4310 for (next
= p
->next
; WINDOWP (next
); next
= XWINDOW (next
)->next
)
4311 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4313 for (prev
= p
->prev
; WINDOWP (prev
); prev
= XWINDOW (prev
)->prev
)
4314 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4317 /* If we can get it all from them without deleting them, do so. */
4318 if (delta
<= maximum
)
4320 Lisp_Object first_unaffected
;
4321 Lisp_Object first_affected
;
4326 first_affected
= window
;
4327 /* Look at one sibling at a time,
4328 moving away from this window in both directions alternately,
4329 and take as much as we can get without deleting that sibling. */
4331 && (!NILP (next
) || !NILP (prev
)))
4335 int this_one
= ((*sizefun
) (next
)
4336 - window_min_size (XWINDOW (next
),
4337 horiz_flag
, 0, &fixed_p
));
4340 if (this_one
> delta
)
4343 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4344 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4349 next
= XWINDOW (next
)->next
;
4357 int this_one
= ((*sizefun
) (prev
)
4358 - window_min_size (XWINDOW (prev
),
4359 horiz_flag
, 0, &fixed_p
));
4362 if (this_one
> delta
)
4365 first_affected
= prev
;
4367 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4368 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4373 prev
= XWINDOW (prev
)->prev
;
4377 xassert (delta
== 0);
4379 /* Now recalculate the edge positions of all the windows affected,
4380 based on the new sizes. */
4381 first_unaffected
= next
;
4382 prev
= first_affected
;
4383 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4384 prev
= next
, next
= XWINDOW (next
)->next
)
4386 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4387 /* This does not change size of NEXT,
4388 but it propagates the new top edge to its children */
4389 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4394 register int delta1
;
4395 register int opht
= (*sizefun
) (parent
);
4397 if (opht
<= XINT (*sizep
) + delta
)
4399 /* If trying to grow this window to or beyond size of the parent,
4400 just delete all the sibling windows. */
4401 Lisp_Object start
, tem
, next
;
4403 start
= XWINDOW (parent
)->vchild
;
4405 start
= XWINDOW (parent
)->hchild
;
4407 /* Delete any siblings that come after WINDOW. */
4408 tem
= XWINDOW (window
)->next
;
4409 while (! NILP (tem
))
4411 next
= XWINDOW (tem
)->next
;
4412 delete_window (tem
);
4416 /* Delete any siblings that come after WINDOW.
4417 Note that if START is not WINDOW, then WINDOW still
4418 Fhas siblings, so WINDOW has not yet replaced its parent. */
4420 while (! EQ (tem
, window
))
4422 next
= XWINDOW (tem
)->next
;
4423 delete_window (tem
);
4429 /* Otherwise, make delta1 just right so that if we add
4430 delta1 lines to this window and to the parent, and then
4431 shrink the parent back to its original size, the new
4432 proportional size of this window will increase by delta.
4434 The function size_window will compute the new height h'
4435 of the window from delta1 as:
4438 x = delta1 - delta1/n * n for the 1st resizable child
4441 where n is the number of children that can be resized.
4442 We can ignore x by choosing a delta1 that is a multiple of
4443 n. We want the height of this window to come out as
4453 The number of children n equals the number of resizable
4454 children of this window + 1 because we know window itself
4455 is resizable (otherwise we would have signalled an error). */
4457 struct window
*w
= XWINDOW (window
);
4461 for (s
= w
->next
; WINDOWP (s
); s
= XWINDOW (s
)->next
)
4462 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4464 for (s
= w
->prev
; WINDOWP (s
); s
= XWINDOW (s
)->prev
)
4465 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4470 /* Add delta1 lines or columns to this window, and to the parent,
4471 keeping things consistent while not affecting siblings. */
4472 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4473 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4475 /* Squeeze out delta1 lines or columns from our parent,
4476 shriking this window and siblings proportionately.
4477 This brings parent back to correct size.
4478 Delta1 was calculated so this makes this window the desired size,
4479 taking it all out of the siblings. */
4480 (*setsizefun
) (parent
, opht
, 0);
4485 XSETFASTINT (p
->last_modified
, 0);
4486 XSETFASTINT (p
->last_overlay_modified
, 0);
4488 /* Adjust glyph matrices. */
4489 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4493 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4494 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4495 zero means adjust the height, moving the bottom edge.
4497 Following siblings of the selected window are resized to fulfill
4498 the size request. If they become too small in the process, they
4499 are not deleted; instead, we signal an error. */
4502 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4504 int delta
, horiz_flag
;
4506 Lisp_Object parent
, child
;
4508 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4509 int delcount
= window_deletion_count
;
4511 /* Check values of window_min_width and window_min_height for
4513 check_min_window_sizes ();
4516 window
= Fselected_window ();
4518 CHECK_WINDOW (window
);
4520 /* Give up if this window cannot be resized. */
4521 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4522 error ("Window is not resizable");
4526 Lisp_Object first_parallel
= Qnil
;
4530 /* This happens if WINDOW on the previous iteration was
4531 at top level of the window tree. */
4532 Fset_window_configuration (old_config
);
4533 error ("Specified window edge is fixed");
4536 p
= XWINDOW (window
);
4539 /* See if this level has windows in parallel in the specified
4540 direction. If so, set FIRST_PARALLEL to the first one. */
4543 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4544 first_parallel
= XWINDOW (parent
)->vchild
;
4545 else if (NILP (parent
) && !NILP (p
->next
))
4547 /* Handle the vertical chain of main window and minibuffer
4548 which has no parent. */
4549 first_parallel
= window
;
4550 while (! NILP (XWINDOW (first_parallel
)->prev
))
4551 first_parallel
= XWINDOW (first_parallel
)->prev
;
4556 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4557 first_parallel
= XWINDOW (parent
)->hchild
;
4560 /* If this level's succession is in the desired dimension,
4561 and this window is the last one, and there is no higher level,
4562 its trailing edge is fixed. */
4563 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4566 Fset_window_configuration (old_config
);
4567 error ("Specified window edge is fixed");
4570 /* Don't make this window too small. */
4571 if (XINT (CURSIZE (window
)) + delta
4572 < window_min_size_2 (XWINDOW (window
), horiz_flag
))
4574 Fset_window_configuration (old_config
);
4575 error ("Cannot adjust window size as specified");
4578 /* Clear out some redisplay caches. */
4579 XSETFASTINT (p
->last_modified
, 0);
4580 XSETFASTINT (p
->last_overlay_modified
, 0);
4582 /* Adjust this window's edge. */
4583 XSETINT (CURSIZE (window
),
4584 XINT (CURSIZE (window
)) + delta
);
4586 /* If this window has following siblings in the desired dimension,
4587 make them smaller, and exit the loop.
4589 (If we reach the top of the tree and can never do this,
4590 we will fail and report an error, above.) */
4591 if (NILP (first_parallel
))
4593 if (!NILP (p
->next
))
4595 /* This may happen for the minibuffer. In that case
4596 the window_deletion_count check below does not work. */
4597 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4599 Fset_window_configuration (old_config
);
4600 error ("Cannot adjust window size as specified");
4603 XSETINT (CURBEG (p
->next
),
4604 XINT (CURBEG (p
->next
)) + delta
);
4605 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4606 horiz_flag
, 0, 1, 0);
4611 /* Here we have a chain of parallel siblings, in the other dimension.
4612 Change the size of the other siblings. */
4613 for (child
= first_parallel
;
4615 child
= XWINDOW (child
)->next
)
4616 if (! EQ (child
, window
))
4617 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4618 horiz_flag
, 0, 0, 1);
4623 /* If we made a window so small it got deleted,
4624 we failed. Report failure. */
4625 if (delcount
!= window_deletion_count
)
4627 Fset_window_configuration (old_config
);
4628 error ("Cannot adjust window size as specified");
4631 /* Adjust glyph matrices. */
4632 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4638 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4639 Sadjust_window_trailing_edge
, 3, 3, 0,
4640 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4641 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4642 Otherwise, adjust the height, moving the bottom edge.
4644 Following siblings of the selected window are resized to fulfill
4645 the size request. If they become too small in the process, they
4646 are not deleted; instead, we signal an error. */)
4647 (window
, delta
, horizontal
)
4648 Lisp_Object window
, delta
, horizontal
;
4650 CHECK_NUMBER (delta
);
4651 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4653 if (! NILP (Vwindow_configuration_change_hook
))
4654 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4661 /***********************************************************************
4662 Resizing Mini-Windows
4663 ***********************************************************************/
4665 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4667 enum save_restore_action
4674 static int save_restore_orig_size
P_ ((struct window
*,
4675 enum save_restore_action
));
4677 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4678 from lowest windows first. */
4681 shrink_window_lowest_first (w
, height
)
4689 xassert (!MINI_WINDOW_P (w
));
4691 /* Set redisplay hints. */
4692 XSETFASTINT (w
->last_modified
, 0);
4693 XSETFASTINT (w
->last_overlay_modified
, 0);
4694 windows_or_buffers_changed
++;
4695 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4697 old_height
= XFASTINT (w
->total_lines
);
4698 XSETFASTINT (w
->total_lines
, height
);
4700 if (!NILP (w
->hchild
))
4702 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4704 c
= XWINDOW (child
);
4705 c
->top_line
= w
->top_line
;
4706 shrink_window_lowest_first (c
, height
);
4709 else if (!NILP (w
->vchild
))
4711 Lisp_Object last_child
;
4712 int delta
= old_height
- height
;
4717 /* Find the last child. We are taking space from lowest windows
4718 first, so we iterate over children from the last child
4720 for (child
= w
->vchild
; WINDOWP (child
); child
= XWINDOW (child
)->next
)
4723 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4724 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4728 c
= XWINDOW (child
);
4729 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4731 if (this_one
> delta
)
4734 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4738 /* Compute new positions. */
4739 last_top
= XINT (w
->top_line
);
4740 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4742 c
= XWINDOW (child
);
4743 c
->top_line
= make_number (last_top
);
4744 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4745 last_top
+= XFASTINT (c
->total_lines
);
4751 /* Save, restore, or check positions and sizes in the window tree
4752 rooted at W. ACTION says what to do.
4754 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4755 orig_total_lines members are valid for all windows in the window
4756 tree. Value is non-zero if they are valid.
4758 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4759 orig_top_line and orig_total_lines for all windows in the tree.
4761 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4762 stored in orig_top_line and orig_total_lines for all windows. */
4765 save_restore_orig_size (w
, action
)
4767 enum save_restore_action action
;
4773 if (!NILP (w
->hchild
))
4775 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4778 else if (!NILP (w
->vchild
))
4780 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4786 case CHECK_ORIG_SIZES
:
4787 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4791 case SAVE_ORIG_SIZES
:
4792 w
->orig_top_line
= w
->top_line
;
4793 w
->orig_total_lines
= w
->total_lines
;
4794 XSETFASTINT (w
->last_modified
, 0);
4795 XSETFASTINT (w
->last_overlay_modified
, 0);
4798 case RESTORE_ORIG_SIZES
:
4799 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4800 w
->top_line
= w
->orig_top_line
;
4801 w
->total_lines
= w
->orig_total_lines
;
4802 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4803 XSETFASTINT (w
->last_modified
, 0);
4804 XSETFASTINT (w
->last_overlay_modified
, 0);
4811 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4818 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4819 without deleting other windows. */
4822 grow_mini_window (w
, delta
)
4826 struct frame
*f
= XFRAME (w
->frame
);
4827 struct window
*root
;
4829 xassert (MINI_WINDOW_P (w
));
4830 xassert (delta
>= 0);
4832 /* Check values of window_min_width and window_min_height for
4834 check_min_window_sizes ();
4836 /* Compute how much we can enlarge the mini-window without deleting
4838 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4841 int min_height
= window_min_size (root
, 0, 0, 0);
4842 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4843 /* Note that the root window may already be smaller than
4845 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4850 /* Save original window sizes and positions, if not already done. */
4851 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4852 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4854 /* Shrink other windows. */
4855 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4857 /* Grow the mini-window. */
4858 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4859 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4860 XSETFASTINT (w
->last_modified
, 0);
4861 XSETFASTINT (w
->last_overlay_modified
, 0);
4868 /* Shrink mini-window W. If there is recorded info about window sizes
4869 before a call to grow_mini_window, restore recorded window sizes.
4870 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4874 shrink_mini_window (w
)
4877 struct frame
*f
= XFRAME (w
->frame
);
4878 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4880 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4882 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4884 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4885 windows_or_buffers_changed
= 1;
4887 else if (XFASTINT (w
->total_lines
) > 1)
4889 /* Distribute the additional lines of the mini-window
4890 among the other windows. */
4892 XSETWINDOW (window
, w
);
4893 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4899 /* Mark window cursors off for all windows in the window tree rooted
4900 at W by setting their phys_cursor_on_p flag to zero. Called from
4901 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4902 the frame are cleared. */
4905 mark_window_cursors_off (w
)
4910 if (!NILP (w
->hchild
))
4911 mark_window_cursors_off (XWINDOW (w
->hchild
));
4912 else if (!NILP (w
->vchild
))
4913 mark_window_cursors_off (XWINDOW (w
->vchild
));
4915 w
->phys_cursor_on_p
= 0;
4917 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4922 /* Return number of lines of text (not counting mode lines) in W. */
4925 window_internal_height (w
)
4928 int ht
= XFASTINT (w
->total_lines
);
4930 if (!MINI_WINDOW_P (w
))
4932 if (!NILP (w
->parent
)
4933 || !NILP (w
->vchild
)
4934 || !NILP (w
->hchild
)
4937 || WINDOW_WANTS_MODELINE_P (w
))
4940 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4948 /* Return the number of columns in W.
4949 Don't count columns occupied by scroll bars or the vertical bar
4950 separating W from the sibling to its right. */
4953 window_box_text_cols (w
)
4956 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4957 int width
= XINT (w
->total_cols
);
4959 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4960 /* Scroll bars occupy a few columns. */
4961 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4962 else if (!FRAME_WINDOW_P (f
)
4963 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4964 /* The column of `|' characters separating side-by-side windows
4965 occupies one column only. */
4968 if (FRAME_WINDOW_P (f
))
4969 /* On window-systems, fringes and display margins cannot be
4970 used for normal text. */
4971 width
-= (WINDOW_FRINGE_COLS (w
)
4972 + WINDOW_LEFT_MARGIN_COLS (w
)
4973 + WINDOW_RIGHT_MARGIN_COLS (w
));
4979 /************************************************************************
4981 ***********************************************************************/
4983 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4984 N screen-fulls, which is defined as the height of the window minus
4985 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4986 instead. Negative values of N mean scroll down. NOERROR non-zero
4987 means don't signal an error if we try to move over BEGV or ZV,
4991 window_scroll (window
, n
, whole
, noerror
)
4999 /* If we must, use the pixel-based version which is much slower than
5000 the line-based one but can handle varying line heights. */
5001 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
5002 window_scroll_pixel_based (window
, n
, whole
, noerror
);
5004 window_scroll_line_based (window
, n
, whole
, noerror
);
5010 /* Implementation of window_scroll that works based on pixel line
5011 heights. See the comment of window_scroll for parameter
5015 window_scroll_pixel_based (window
, n
, whole
, noerror
)
5022 struct window
*w
= XWINDOW (window
);
5023 struct text_pos start
;
5024 int this_scroll_margin
;
5025 /* True if we fiddled the window vscroll field without really scrolling. */
5027 int x
, y
, rtop
, rbot
, rowh
, vpos
;
5029 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5031 /* If PT is not visible in WINDOW, move back one half of
5032 the screen. Allow PT to be partially visible, otherwise
5033 something like (scroll-down 1) with PT in the line before
5034 the partially visible one would recenter. */
5036 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
5038 /* Move backward half the height of the window. Performance note:
5039 vmotion used here is about 10% faster, but would give wrong
5040 results for variable height lines. */
5041 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
5042 it
.current_y
= it
.last_visible_y
;
5043 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5045 /* The function move_iterator_vertically may move over more than
5046 the specified y-distance. If it->w is small, e.g. a
5047 mini-buffer window, we may end up in front of the window's
5048 display area. This is the case when Start displaying at the
5049 start of the line containing PT in this case. */
5050 if (it
.current_y
<= 0)
5052 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
5053 move_it_vertically_backward (&it
, 0);
5057 start
= it
.current
.pos
;
5059 else if (auto_window_vscroll_p
)
5061 if (rtop
|| rbot
) /* partially visible */
5064 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5066 dy
= max ((window_box_height (w
)
5067 - next_screen_context_lines
* dy
),
5073 /* Only vscroll backwards if already vscrolled forwards. */
5074 if (w
->vscroll
< 0 && rtop
> 0)
5076 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
5077 Fset_window_vscroll (window
, make_number (px
), Qt
);
5083 /* Do vscroll if already vscrolled or only display line. */
5084 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
5086 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
5087 Fset_window_vscroll (window
, make_number (px
), Qt
);
5091 /* Maybe modify window start instead of scrolling. */
5092 if (rbot
> 0 || w
->vscroll
< 0)
5096 Fset_window_vscroll (window
, make_number (0), Qt
);
5097 /* If there are other text lines above the current row,
5098 move window start to current row. Else to next row. */
5100 spos
= XINT (Fline_beginning_position (Qnil
));
5102 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
5103 set_marker_restricted (w
->start
, make_number (spos
),
5105 w
->start_at_line_beg
= Qt
;
5106 w
->update_mode_line
= Qt
;
5107 XSETFASTINT (w
->last_modified
, 0);
5108 XSETFASTINT (w
->last_overlay_modified
, 0);
5109 /* Set force_start so that redisplay_window will run the
5110 window-scroll-functions. */
5111 w
->force_start
= Qt
;
5116 /* Cancel previous vscroll. */
5117 Fset_window_vscroll (window
, make_number (0), Qt
);
5120 /* If scroll_preserve_screen_position is non-nil, we try to set
5121 point in the same window line as it is now, so get that line. */
5122 if (!NILP (Vscroll_preserve_screen_position
))
5124 /* We preserve the goal pixel coordinate across consecutive
5125 calls to scroll-up or scroll-down. This avoids the
5126 possibility of point becoming "stuck" on a tall line when
5127 scrolling by one line. */
5128 if (window_scroll_pixel_based_preserve_y
< 0
5129 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5130 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5132 start_display (&it
, w
, start
);
5133 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5134 window_scroll_pixel_based_preserve_y
= it
.current_y
;
5138 window_scroll_pixel_based_preserve_y
= -1;
5140 /* Move iterator it from start the specified distance forward or
5141 backward. The result is the new window start. */
5142 start_display (&it
, w
, start
);
5145 int start_pos
= IT_CHARPOS (it
);
5146 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5147 dy
= max ((window_box_height (w
)
5148 - next_screen_context_lines
* dy
),
5151 /* Note that move_it_vertically always moves the iterator to the
5152 start of a line. So, if the last line doesn't have a newline,
5153 we would end up at the start of the line ending at ZV. */
5156 move_it_vertically_backward (&it
, -dy
);
5157 /* Ensure we actually do move, e.g. in case we are currently
5158 looking at an image that is taller that the window height. */
5159 while (start_pos
== IT_CHARPOS (it
)
5160 && start_pos
> BEGV
)
5161 move_it_by_lines (&it
, -1, 1);
5165 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
5166 MOVE_TO_POS
| MOVE_TO_Y
);
5167 /* Ensure we actually do move, e.g. in case we are currently
5168 looking at an image that is taller that the window height. */
5169 while (start_pos
== IT_CHARPOS (it
)
5171 move_it_by_lines (&it
, 1, 1);
5175 move_it_by_lines (&it
, n
, 1);
5177 /* We failed if we find ZV is already on the screen (scrolling up,
5178 means there's nothing past the end), or if we can't start any
5179 earlier (scrolling down, means there's nothing past the top). */
5180 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
5181 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
5183 if (IT_CHARPOS (it
) == ZV
)
5185 if (it
.current_y
< it
.last_visible_y
5186 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
5187 > it
.last_visible_y
))
5189 /* The last line was only partially visible, make it fully
5191 w
->vscroll
= (it
.last_visible_y
5192 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
5193 adjust_glyphs (it
.f
);
5197 else if (n
< 0) /* could happen with empty buffers */
5198 xsignal0 (Qbeginning_of_buffer
);
5200 xsignal0 (Qend_of_buffer
);
5204 if (w
->vscroll
!= 0)
5205 /* The first line was only partially visible, make it fully
5211 xsignal0 (Qbeginning_of_buffer
);
5214 /* If control gets here, then we vscrolled. */
5216 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5218 /* Don't try to change the window start below. */
5224 int pos
= IT_CHARPOS (it
);
5227 /* If in the middle of a multi-glyph character move forward to
5228 the next character. */
5229 if (in_display_vector_p (&it
))
5232 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5235 /* Set the window start, and set up the window for redisplay. */
5236 set_marker_restricted (w
->start
, make_number (pos
),
5238 bytepos
= XMARKER (w
->start
)->bytepos
;
5239 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5241 w
->update_mode_line
= Qt
;
5242 XSETFASTINT (w
->last_modified
, 0);
5243 XSETFASTINT (w
->last_overlay_modified
, 0);
5244 /* Set force_start so that redisplay_window will run the
5245 window-scroll-functions. */
5246 w
->force_start
= Qt
;
5249 /* The rest of this function uses current_y in a nonstandard way,
5250 not including the height of the header line if any. */
5251 it
.current_y
= it
.vpos
= 0;
5253 /* Move PT out of scroll margins.
5254 This code wants current_y to be zero at the window start position
5255 even if there is a header line. */
5256 this_scroll_margin
= max (0, scroll_margin
);
5257 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5258 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5262 /* We moved the window start towards ZV, so PT may be now
5263 in the scroll margin at the top. */
5264 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5265 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5266 && (NILP (Vscroll_preserve_screen_position
)
5267 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5268 /* We found PT at a legitimate height. Leave it alone. */
5270 else if (window_scroll_pixel_based_preserve_y
>= 0)
5272 /* If we have a header line, take account of it.
5273 This is necessary because we set it.current_y to 0, above. */
5274 move_it_to (&it
, -1, -1,
5275 window_scroll_pixel_based_preserve_y
5276 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5278 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5282 while (it
.current_y
< this_scroll_margin
)
5284 int prev
= it
.current_y
;
5285 move_it_by_lines (&it
, 1, 1);
5286 if (prev
== it
.current_y
)
5289 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5294 int charpos
, bytepos
;
5297 /* Save our position, for the
5298 window_scroll_pixel_based_preserve_y case. */
5299 charpos
= IT_CHARPOS (it
);
5300 bytepos
= IT_BYTEPOS (it
);
5302 /* We moved the window start towards BEGV, so PT may be now
5303 in the scroll margin at the bottom. */
5304 move_it_to (&it
, PT
, -1,
5305 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5306 - this_scroll_margin
- 1),
5308 MOVE_TO_POS
| MOVE_TO_Y
);
5310 /* Save our position, in case it's correct. */
5311 charpos
= IT_CHARPOS (it
);
5312 bytepos
= IT_BYTEPOS (it
);
5314 /* See if point is on a partially visible line at the end. */
5315 if (it
.what
== IT_EOB
)
5316 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5319 move_it_by_lines (&it
, 1, 1);
5320 partial_p
= it
.current_y
> it
.last_visible_y
;
5323 if (charpos
== PT
&& !partial_p
5324 && (NILP (Vscroll_preserve_screen_position
)
5325 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5326 /* We found PT before we found the display margin, so PT is ok. */
5328 else if (window_scroll_pixel_based_preserve_y
>= 0)
5330 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5331 start_display (&it
, w
, start
);
5332 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5333 here because we called start_display again and did not
5334 alter it.current_y this time. */
5335 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5337 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5342 /* The last line was only partially visible, so back up two
5343 lines to make sure we're on a fully visible line. */
5345 move_it_by_lines (&it
, -2, 0);
5346 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5349 /* No, the position we saved is OK, so use it. */
5350 SET_PT_BOTH (charpos
, bytepos
);
5356 /* Implementation of window_scroll that works based on screen lines.
5357 See the comment of window_scroll for parameter descriptions. */
5360 window_scroll_line_based (window
, n
, whole
, noerror
)
5366 register struct window
*w
= XWINDOW (window
);
5367 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5368 register int pos
, pos_byte
;
5369 register int ht
= window_internal_height (w
);
5370 register Lisp_Object tem
;
5374 struct position posit
;
5377 /* If scrolling screen-fulls, compute the number of lines to
5378 scroll from the window's height. */
5380 n
*= max (1, ht
- next_screen_context_lines
);
5382 startpos
= marker_position (w
->start
);
5384 posit
= *compute_motion (startpos
, 0, 0, 0,
5386 -1, XINT (w
->hscroll
),
5388 original_vpos
= posit
.vpos
;
5390 XSETFASTINT (tem
, PT
);
5391 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5395 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5400 lose
= n
< 0 && PT
== BEGV
;
5401 Fvertical_motion (make_number (n
), window
);
5405 SET_PT_BOTH (opoint
, opoint_byte
);
5412 xsignal0 (Qbeginning_of_buffer
);
5417 int this_scroll_margin
= scroll_margin
;
5419 /* Don't use a scroll margin that is negative or too large. */
5420 if (this_scroll_margin
< 0)
5421 this_scroll_margin
= 0;
5423 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5424 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5426 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5427 w
->start_at_line_beg
= bolp
;
5428 w
->update_mode_line
= Qt
;
5429 XSETFASTINT (w
->last_modified
, 0);
5430 XSETFASTINT (w
->last_overlay_modified
, 0);
5431 /* Set force_start so that redisplay_window will run
5432 the window-scroll-functions. */
5433 w
->force_start
= Qt
;
5435 if (!NILP (Vscroll_preserve_screen_position
)
5436 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5438 SET_PT_BOTH (pos
, pos_byte
);
5439 Fvertical_motion (make_number (original_vpos
), window
);
5441 /* If we scrolled forward, put point enough lines down
5442 that it is outside the scroll margin. */
5447 if (this_scroll_margin
> 0)
5449 SET_PT_BOTH (pos
, pos_byte
);
5450 Fvertical_motion (make_number (this_scroll_margin
), window
);
5456 if (top_margin
<= opoint
)
5457 SET_PT_BOTH (opoint
, opoint_byte
);
5458 else if (!NILP (Vscroll_preserve_screen_position
))
5460 SET_PT_BOTH (pos
, pos_byte
);
5461 Fvertical_motion (make_number (original_vpos
), window
);
5464 SET_PT (top_margin
);
5470 /* If we scrolled backward, put point near the end of the window
5471 but not within the scroll margin. */
5472 SET_PT_BOTH (pos
, pos_byte
);
5473 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5474 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5477 bottom_margin
= PT
+ 1;
5479 if (bottom_margin
> opoint
)
5480 SET_PT_BOTH (opoint
, opoint_byte
);
5483 if (!NILP (Vscroll_preserve_screen_position
))
5485 SET_PT_BOTH (pos
, pos_byte
);
5486 Fvertical_motion (make_number (original_vpos
), window
);
5489 Fvertical_motion (make_number (-1), window
);
5498 xsignal0 (Qend_of_buffer
);
5503 /* Scroll selected_window up or down. If N is nil, scroll a
5504 screen-full which is defined as the height of the window minus
5505 next_screen_context_lines. If N is the symbol `-', scroll.
5506 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5507 up. This is the guts of Fscroll_up and Fscroll_down. */
5510 scroll_command (n
, direction
)
5514 int count
= SPECPDL_INDEX ();
5516 xassert (eabs (direction
) == 1);
5518 /* If selected window's buffer isn't current, make it current for
5519 the moment. But don't screw up if window_scroll gets an error. */
5520 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5522 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5523 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5525 /* Make redisplay consider other windows than just selected_window. */
5526 ++windows_or_buffers_changed
;
5530 window_scroll (selected_window
, direction
, 1, 0);
5531 else if (EQ (n
, Qminus
))
5532 window_scroll (selected_window
, -direction
, 1, 0);
5535 n
= Fprefix_numeric_value (n
);
5536 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5539 unbind_to (count
, Qnil
);
5542 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5543 doc
: /* Scroll text of current window upward ARG lines.
5544 If ARG is omitted or nil, scroll upward by a near full screen.
5545 A near full screen is `next-screen-context-lines' less than a full screen.
5546 Negative ARG means scroll downward.
5547 If ARG is the atom `-', scroll downward by nearly full screen.
5548 When calling from a program, supply as argument a number, nil, or `-'. */)
5552 scroll_command (arg
, 1);
5556 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5557 doc
: /* Scroll text of current window down ARG lines.
5558 If ARG is omitted or nil, scroll down by a near full screen.
5559 A near full screen is `next-screen-context-lines' less than a full screen.
5560 Negative ARG means scroll upward.
5561 If ARG is the atom `-', scroll upward by nearly full screen.
5562 When calling from a program, supply as argument a number, nil, or `-'. */)
5566 scroll_command (arg
, -1);
5570 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5571 doc
: /* Return the other window for \"other window scroll\" commands.
5572 If `other-window-scroll-buffer' is non-nil, a window
5573 showing that buffer is used.
5574 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5575 specifies the window. This takes precedence over
5576 `other-window-scroll-buffer'. */)
5581 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5582 && !NILP (Vminibuf_scroll_window
))
5583 window
= Vminibuf_scroll_window
;
5584 /* If buffer is specified, scroll that buffer. */
5585 else if (!NILP (Vother_window_scroll_buffer
))
5587 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5589 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5593 /* Nothing specified; look for a neighboring window on the same
5595 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5597 if (EQ (window
, selected_window
))
5598 /* That didn't get us anywhere; look for a window on another
5601 window
= Fnext_window (window
, Qnil
, Qt
);
5602 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5603 && ! EQ (window
, selected_window
));
5606 CHECK_LIVE_WINDOW (window
);
5608 if (EQ (window
, selected_window
))
5609 error ("There is no other window");
5614 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5615 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5616 A near full screen is `next-screen-context-lines' less than a full screen.
5617 The next window is the one below the current one; or the one at the top
5618 if the current one is at the bottom. Negative ARG means scroll downward.
5619 If ARG is the atom `-', scroll downward by nearly full screen.
5620 When calling from a program, supply as argument a number, nil, or `-'.
5622 If `other-window-scroll-buffer' is non-nil, scroll the window
5623 showing that buffer, popping the buffer up if necessary.
5624 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5625 specifies the window to scroll. This takes precedence over
5626 `other-window-scroll-buffer'. */)
5632 int count
= SPECPDL_INDEX ();
5634 window
= Fother_window_for_scrolling ();
5635 w
= XWINDOW (window
);
5637 /* Don't screw up if window_scroll gets an error. */
5638 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5639 ++windows_or_buffers_changed
;
5641 Fset_buffer (w
->buffer
);
5642 SET_PT (marker_position (w
->pointm
));
5645 window_scroll (window
, 1, 1, 1);
5646 else if (EQ (arg
, Qminus
))
5647 window_scroll (window
, -1, 1, 1);
5653 window_scroll (window
, XINT (arg
), 0, 1);
5656 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5657 unbind_to (count
, Qnil
);
5662 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5663 doc
: /* Scroll selected window display ARG columns left.
5664 Default for ARG is window width minus 2.
5665 Value is the total amount of leftward horizontal scrolling in
5666 effect after the change.
5667 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5668 lower bound for automatic scrolling, i.e. automatic scrolling
5669 will not scroll a window to a column less than the value returned
5670 by this function. This happens in an interactive call. */)
5672 register Lisp_Object arg
, set_minimum
;
5676 struct window
*w
= XWINDOW (selected_window
);
5679 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5681 arg
= Fprefix_numeric_value (arg
);
5683 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5684 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5686 if (!NILP (set_minimum
))
5687 w
->min_hscroll
= w
->hscroll
;
5692 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5693 doc
: /* Scroll selected window display ARG columns right.
5694 Default for ARG is window width minus 2.
5695 Value is the total amount of leftward horizontal scrolling in
5696 effect after the change.
5697 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5698 lower bound for automatic scrolling, i.e. automatic scrolling
5699 will not scroll a window to a column less than the value returned
5700 by this function. This happens in an interactive call. */)
5702 register Lisp_Object arg
, set_minimum
;
5706 struct window
*w
= XWINDOW (selected_window
);
5709 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5711 arg
= Fprefix_numeric_value (arg
);
5713 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5714 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5716 if (!NILP (set_minimum
))
5717 w
->min_hscroll
= w
->hscroll
;
5722 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5723 doc
: /* Return the window which was selected when entering the minibuffer.
5724 Returns nil, if current window is not a minibuffer window. */)
5727 if (minibuf_level
> 0
5728 && MINI_WINDOW_P (XWINDOW (selected_window
))
5729 && WINDOW_LIVE_P (minibuf_selected_window
))
5730 return minibuf_selected_window
;
5735 /* Value is the number of lines actually displayed in window W,
5736 as opposed to its height. */
5739 displayed_window_lines (w
)
5743 struct text_pos start
;
5744 int height
= window_box_height (w
);
5745 struct buffer
*old_buffer
;
5748 if (XBUFFER (w
->buffer
) != current_buffer
)
5750 old_buffer
= current_buffer
;
5751 set_buffer_internal (XBUFFER (w
->buffer
));
5756 /* In case W->start is out of the accessible range, do something
5757 reasonable. This happens in Info mode when Info-scroll-down
5758 calls (recenter -1) while W->start is 1. */
5759 if (XMARKER (w
->start
)->charpos
< BEGV
)
5760 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5761 else if (XMARKER (w
->start
)->charpos
> ZV
)
5762 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5764 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5766 start_display (&it
, w
, start
);
5767 move_it_vertically (&it
, height
);
5768 bottom_y
= line_bottom_y (&it
);
5770 /* rms: On a non-window display,
5771 the value of it.vpos at the bottom of the screen
5772 seems to be 1 larger than window_box_height (w).
5773 This kludge fixes a bug whereby (move-to-window-line -1)
5774 when ZV is on the last screen line
5775 moves to the previous screen line instead of the last one. */
5776 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5779 /* Add in empty lines at the bottom of the window. */
5780 if (bottom_y
< height
)
5782 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5783 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5787 set_buffer_internal (old_buffer
);
5793 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5794 doc
: /* Center point in window and redisplay frame.
5795 With prefix argument ARG, recenter putting point on screen line ARG
5796 relative to the current window. If ARG is negative, it counts up from the
5797 bottom of the window. (ARG should be less than the height of the window.)
5799 If ARG is omitted or nil, erase the entire frame and then redraw with point
5800 in the center of the current window. If `auto-resize-tool-bars' is set to
5801 `grow-only', this resets the tool-bar's height to the minimum height needed.
5803 Just C-u as prefix means put point in the center of the window
5804 and redisplay normally--don't erase and redraw the frame. */)
5806 register Lisp_Object arg
;
5808 struct window
*w
= XWINDOW (selected_window
);
5809 struct buffer
*buf
= XBUFFER (w
->buffer
);
5810 struct buffer
*obuf
= current_buffer
;
5812 int charpos
, bytepos
;
5814 int this_scroll_margin
;
5816 /* If redisplay is suppressed due to an error, try again. */
5817 obuf
->display_error_modiff
= 0;
5823 /* Invalidate pixel data calculated for all compositions. */
5824 for (i
= 0; i
< n_compositions
; i
++)
5825 composition_table
[i
]->font
= NULL
;
5827 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5829 Fredraw_frame (WINDOW_FRAME (w
));
5830 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5833 else if (CONSP (arg
)) /* Just C-u. */
5837 arg
= Fprefix_numeric_value (arg
);
5842 set_buffer_internal (buf
);
5844 /* Do this after making BUF current
5845 in case scroll_margin is buffer-local. */
5846 this_scroll_margin
= max (0, scroll_margin
);
5847 this_scroll_margin
= min (this_scroll_margin
,
5848 XFASTINT (w
->total_lines
) / 4);
5850 /* Handle centering on a graphical frame specially. Such frames can
5851 have variable-height lines and centering point on the basis of
5852 line counts would lead to strange effects. */
5853 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5860 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5861 start_display (&it
, w
, pt
);
5862 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5863 charpos
= IT_CHARPOS (it
);
5864 bytepos
= IT_BYTEPOS (it
);
5871 int extra_line_spacing
;
5872 int h
= window_box_height (w
);
5874 iarg
= - max (-iarg
, this_scroll_margin
);
5876 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5877 start_display (&it
, w
, pt
);
5879 /* Be sure we have the exact height of the full line containing PT. */
5880 move_it_by_lines (&it
, 0, 1);
5882 /* The amount of pixels we have to move back is the window
5883 height minus what's displayed in the line containing PT,
5884 and the lines below. */
5887 move_it_by_lines (&it
, nlines
, 1);
5889 if (it
.vpos
== nlines
)
5893 /* Last line has no newline */
5894 h
-= line_bottom_y (&it
);
5898 /* Don't reserve space for extra line spacing of last line. */
5899 extra_line_spacing
= it
.max_extra_line_spacing
;
5901 /* If we can't move down NLINES lines because we hit
5902 the end of the buffer, count in some empty lines. */
5903 if (it
.vpos
< nlines
)
5906 extra_line_spacing
= it
.extra_line_spacing
;
5907 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5912 /* Now find the new top line (starting position) of the window. */
5913 start_display (&it
, w
, pt
);
5915 move_it_vertically_backward (&it
, h
);
5917 /* If extra line spacing is present, we may move too far
5918 back. This causes the last line to be only partially
5919 visible (which triggers redisplay to recenter that line
5920 in the middle), so move forward.
5921 But ignore extra line spacing on last line, as it is not
5922 considered to be part of the visible height of the line.
5924 h
+= extra_line_spacing
;
5925 while (-it
.current_y
> h
)
5926 move_it_by_lines (&it
, 1, 1);
5928 charpos
= IT_CHARPOS (it
);
5929 bytepos
= IT_BYTEPOS (it
);
5933 struct position pos
;
5935 iarg
= max (iarg
, this_scroll_margin
);
5937 pos
= *vmotion (PT
, -iarg
, w
);
5938 charpos
= pos
.bufpos
;
5939 bytepos
= pos
.bytepos
;
5944 struct position pos
;
5945 int ht
= window_internal_height (w
);
5952 /* Don't let it get into the margin at either top or bottom. */
5953 iarg
= max (iarg
, this_scroll_margin
);
5954 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5956 pos
= *vmotion (PT
, - iarg
, w
);
5957 charpos
= pos
.bufpos
;
5958 bytepos
= pos
.bytepos
;
5961 /* Set the new window start. */
5962 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5963 w
->window_end_valid
= Qnil
;
5965 w
->optional_new_start
= Qt
;
5967 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5968 w
->start_at_line_beg
= Qt
;
5970 w
->start_at_line_beg
= Qnil
;
5972 set_buffer_internal (obuf
);
5977 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5979 doc
: /* Return the height in lines of the text display area of WINDOW.
5980 WINDOW defaults to the selected window.
5981 This doesn't include the mode-line (or header-line if any) or any
5982 partial-height lines in the text display area. */)
5986 struct window
*w
= decode_window (window
);
5987 int pixel_height
= window_box_height (w
);
5988 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5989 return make_number (line_height
);
5994 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5996 doc
: /* Position point relative to window.
5997 With no argument, position point at center of window.
5998 An argument specifies vertical position within the window;
5999 zero means top of window, negative means relative to bottom of window. */)
6003 struct window
*w
= XWINDOW (selected_window
);
6007 int this_scroll_margin
;
6010 window
= selected_window
;
6011 start
= marker_position (w
->start
);
6012 if (start
< BEGV
|| start
> ZV
)
6014 int height
= window_internal_height (w
);
6015 Fvertical_motion (make_number (- (height
/ 2)), window
);
6016 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
6017 w
->start_at_line_beg
= Fbolp ();
6018 w
->force_start
= Qt
;
6021 Fgoto_char (w
->start
);
6023 lines
= displayed_window_lines (w
);
6026 this_scroll_margin
= max (0, scroll_margin
);
6027 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
6031 XSETFASTINT (arg
, lines
/ 2);
6034 int iarg
= XINT (Fprefix_numeric_value (arg
));
6037 iarg
= iarg
+ lines
;
6039 #if 0 /* This code would prevent move-to-window-line from moving point
6040 to a place inside the scroll margins (which would cause the
6041 next redisplay to scroll). I wrote this code, but then concluded
6042 it is probably better not to install it. However, it is here
6043 inside #if 0 so as not to lose it. -- rms. */
6045 /* Don't let it get into the margin at either top or bottom. */
6046 iarg
= max (iarg
, this_scroll_margin
);
6047 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
6050 arg
= make_number (iarg
);
6053 /* Skip past a partially visible first line. */
6055 XSETINT (arg
, XINT (arg
) + 1);
6057 return Fvertical_motion (arg
, window
);
6062 /***********************************************************************
6063 Window Configuration
6064 ***********************************************************************/
6066 struct save_window_data
6069 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6070 Lisp_Object selected_frame
;
6071 Lisp_Object current_window
;
6072 Lisp_Object current_buffer
;
6073 Lisp_Object minibuf_scroll_window
;
6074 Lisp_Object minibuf_selected_window
;
6075 Lisp_Object root_window
;
6076 Lisp_Object focus_frame
;
6077 /* A vector, each of whose elements is a struct saved_window
6079 Lisp_Object saved_windows
;
6081 /* All fields above are traced by the GC.
6082 From `fame-cols' down, the fields are ignored by the GC. */
6084 int frame_cols
, frame_lines
, frame_menu_bar_lines
;
6085 int frame_tool_bar_lines
;
6086 /* Record the values of window-min-width and window-min-height
6087 so that window sizes remain consistent with them. */
6088 int min_width
, min_height
;
6091 /* This is saved as a Lisp_Vector */
6094 /* these first two must agree with struct Lisp_Vector in lisp.h */
6096 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6099 Lisp_Object buffer
, start
, pointm
, mark
;
6100 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
6101 Lisp_Object hscroll
, min_hscroll
;
6102 Lisp_Object parent
, prev
;
6103 Lisp_Object start_at_line_beg
;
6104 Lisp_Object display_table
;
6105 Lisp_Object orig_top_line
, orig_total_lines
;
6106 Lisp_Object left_margin_cols
, right_margin_cols
;
6107 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
6108 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
6109 Lisp_Object dedicated
;
6112 #define SAVED_WINDOW_N(swv,n) \
6113 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
6115 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
6116 doc
: /* Return t if OBJECT is a window-configuration object. */)
6120 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
6123 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
6124 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
6128 register struct save_window_data
*data
;
6129 struct Lisp_Vector
*saved_windows
;
6131 CHECK_WINDOW_CONFIGURATION (config
);
6133 data
= (struct save_window_data
*) XVECTOR (config
);
6134 saved_windows
= XVECTOR (data
->saved_windows
);
6135 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6138 DEFUN ("set-window-configuration", Fset_window_configuration
,
6139 Sset_window_configuration
, 1, 1, 0,
6140 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
6141 CONFIGURATION must be a value previously returned
6142 by `current-window-configuration' (which see).
6143 If CONFIGURATION was made from a frame that is now deleted,
6144 only frame-independent values can be restored. In this case,
6145 the return value is nil. Otherwise the value is t. */)
6147 Lisp_Object configuration
;
6149 register struct save_window_data
*data
;
6150 struct Lisp_Vector
*saved_windows
;
6151 Lisp_Object new_current_buffer
;
6156 CHECK_WINDOW_CONFIGURATION (configuration
);
6158 data
= (struct save_window_data
*) XVECTOR (configuration
);
6159 saved_windows
= XVECTOR (data
->saved_windows
);
6161 new_current_buffer
= data
->current_buffer
;
6162 if (NILP (XBUFFER (new_current_buffer
)->name
))
6163 new_current_buffer
= Qnil
;
6166 if (XBUFFER (new_current_buffer
) == current_buffer
)
6167 /* The code further down "preserves point" by saving here PT in
6168 old_point and then setting it later back into PT. When the
6169 current-selected-window and the final-selected-window both show
6170 the current buffer, this suffers from the problem that the
6171 current PT is the window-point of the current-selected-window,
6172 while the final PT is the point of the final-selected-window, so
6173 this copy from one PT to the other would end up moving the
6174 window-point of the final-selected-window to the window-point of
6175 the current-selected-window. So we have to be careful which
6176 point of the current-buffer we copy into old_point. */
6177 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6178 && WINDOWP (selected_window
)
6179 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
6180 && !EQ (selected_window
, data
->current_window
))
6181 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6185 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6186 point in new_current_buffer as of the last time this buffer was
6187 used. This can be non-deterministic since it can be changed by
6188 things like jit-lock by mere temporary selection of some random
6189 window that happens to show this buffer.
6190 So if possible we want this arbitrary choice of "which point" to
6191 be the one from the to-be-selected-window so as to prevent this
6192 window's cursor from being copied from another window. */
6193 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6194 /* If current_window = selected_window, its point is in BUF_PT. */
6195 && !EQ (selected_window
, data
->current_window
))
6196 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6198 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
6201 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6204 /* If f is a dead frame, don't bother rebuilding its window tree.
6205 However, there is other stuff we should still try to do below. */
6206 if (FRAME_LIVE_P (f
))
6208 register struct window
*w
;
6209 register struct saved_window
*p
;
6210 struct window
*root_window
;
6211 struct window
**leaf_windows
;
6215 /* If the frame has been resized since this window configuration was
6216 made, we change the frame to the size specified in the
6217 configuration, restore the configuration, and then resize it
6218 back. We keep track of the prevailing height in these variables. */
6219 int previous_frame_lines
= FRAME_LINES (f
);
6220 int previous_frame_cols
= FRAME_COLS (f
);
6221 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6222 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6224 /* The mouse highlighting code could get screwed up
6225 if it runs during this. */
6228 if (data
->frame_lines
!= previous_frame_lines
6229 || data
->frame_cols
!= previous_frame_cols
)
6230 change_frame_size (f
, data
->frame_lines
,
6231 data
->frame_cols
, 0, 0, 0);
6232 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6233 if (data
->frame_menu_bar_lines
6234 != previous_frame_menu_bar_lines
)
6235 x_set_menu_bar_lines (f
, make_number (data
->frame_menu_bar_lines
),
6237 #ifdef HAVE_WINDOW_SYSTEM
6238 if (data
->frame_tool_bar_lines
6239 != previous_frame_tool_bar_lines
)
6240 x_set_tool_bar_lines (f
, make_number (data
->frame_tool_bar_lines
),
6245 /* "Swap out" point from the selected window's buffer
6246 into the window itself. (Normally the pointm of the selected
6247 window holds garbage.) We do this now, before
6248 restoring the window contents, and prevent it from
6249 being done later on when we select a new window. */
6250 if (! NILP (XWINDOW (selected_window
)->buffer
))
6252 w
= XWINDOW (selected_window
);
6253 set_marker_both (w
->pointm
,
6255 BUF_PT (XBUFFER (w
->buffer
)),
6256 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6259 windows_or_buffers_changed
++;
6260 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6262 /* Problem: Freeing all matrices and later allocating them again
6263 is a serious redisplay flickering problem. What we would
6264 really like to do is to free only those matrices not reused
6266 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6268 = (struct window
**) alloca (count_windows (root_window
)
6269 * sizeof (struct window
*));
6270 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6272 /* Temporarily avoid any problems with windows that are smaller
6273 than they are supposed to be. */
6274 window_min_height
= 1;
6275 window_min_width
= 1;
6278 Mark all windows now on frame as "deleted".
6279 Restoring the new configuration "undeletes" any that are in it.
6281 Save their current buffers in their height fields, since we may
6282 need it later, if a buffer saved in the configuration is now
6284 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6286 for (k
= 0; k
< saved_windows
->size
; k
++)
6288 p
= SAVED_WINDOW_N (saved_windows
, k
);
6289 w
= XWINDOW (p
->window
);
6292 if (!NILP (p
->parent
))
6293 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6294 XFASTINT (p
->parent
))->window
;
6298 if (!NILP (p
->prev
))
6300 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6301 XFASTINT (p
->prev
))->window
;
6302 XWINDOW (w
->prev
)->next
= p
->window
;
6307 if (!NILP (w
->parent
))
6309 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6311 XWINDOW (w
->parent
)->vchild
= p
->window
;
6312 XWINDOW (w
->parent
)->hchild
= Qnil
;
6316 XWINDOW (w
->parent
)->hchild
= p
->window
;
6317 XWINDOW (w
->parent
)->vchild
= Qnil
;
6322 /* If we squirreled away the buffer in the window's height,
6324 if (BUFFERP (w
->total_lines
))
6325 w
->buffer
= w
->total_lines
;
6326 w
->left_col
= p
->left_col
;
6327 w
->top_line
= p
->top_line
;
6328 w
->total_cols
= p
->total_cols
;
6329 w
->total_lines
= p
->total_lines
;
6330 w
->hscroll
= p
->hscroll
;
6331 w
->min_hscroll
= p
->min_hscroll
;
6332 w
->display_table
= p
->display_table
;
6333 w
->orig_top_line
= p
->orig_top_line
;
6334 w
->orig_total_lines
= p
->orig_total_lines
;
6335 w
->left_margin_cols
= p
->left_margin_cols
;
6336 w
->right_margin_cols
= p
->right_margin_cols
;
6337 w
->left_fringe_width
= p
->left_fringe_width
;
6338 w
->right_fringe_width
= p
->right_fringe_width
;
6339 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6340 w
->scroll_bar_width
= p
->scroll_bar_width
;
6341 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6342 w
->dedicated
= p
->dedicated
;
6343 XSETFASTINT (w
->last_modified
, 0);
6344 XSETFASTINT (w
->last_overlay_modified
, 0);
6346 /* Reinstall the saved buffer and pointers into it. */
6347 if (NILP (p
->buffer
))
6348 w
->buffer
= p
->buffer
;
6351 if (!NILP (XBUFFER (p
->buffer
)->name
))
6352 /* If saved buffer is alive, install it. */
6354 w
->buffer
= p
->buffer
;
6355 w
->start_at_line_beg
= p
->start_at_line_beg
;
6356 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6357 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6358 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6359 p
->mark
, w
->buffer
);
6361 /* As documented in Fcurrent_window_configuration, don't
6362 restore the location of point in the buffer which was
6363 current when the window configuration was recorded. */
6364 if (!EQ (p
->buffer
, new_current_buffer
)
6365 && XBUFFER (p
->buffer
) == current_buffer
)
6366 Fgoto_char (w
->pointm
);
6368 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6369 /* Else unless window has a live buffer, get one. */
6371 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6372 /* This will set the markers to beginning of visible
6374 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6375 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6376 w
->start_at_line_beg
= Qt
;
6379 /* Keeping window's old buffer; make sure the markers
6382 /* Set window markers at start of visible range. */
6383 if (XMARKER (w
->start
)->buffer
== 0)
6384 set_marker_restricted (w
->start
, make_number (0),
6386 if (XMARKER (w
->pointm
)->buffer
== 0)
6387 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6388 BUF_PT (XBUFFER (w
->buffer
)),
6389 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6390 w
->start_at_line_beg
= Qt
;
6395 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6396 /* Prevent "swapping out point" in the old selected window
6397 using the buffer that has been restored into it.
6398 We already swapped out point that from that window's old buffer. */
6399 selected_window
= Qnil
;
6401 /* Arrange *not* to restore point in the buffer that was
6402 current when the window configuration was saved. */
6403 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6404 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6405 make_number (old_point
),
6406 XWINDOW (data
->current_window
)->buffer
);
6408 Fselect_window (data
->current_window
, Qnil
);
6409 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6412 if (NILP (data
->focus_frame
)
6413 || (FRAMEP (data
->focus_frame
)
6414 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6415 Fredirect_frame_focus (frame
, data
->focus_frame
);
6417 #if 0 /* I don't understand why this is needed, and it causes problems
6418 when the frame's old selected window has been deleted. */
6419 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6420 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6424 /* Set the screen height to the value it had before this function. */
6425 if (previous_frame_lines
!= FRAME_LINES (f
)
6426 || previous_frame_cols
!= FRAME_COLS (f
))
6427 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6429 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6430 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6431 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6433 #ifdef HAVE_WINDOW_SYSTEM
6434 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6435 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6440 /* Now, free glyph matrices in windows that were not reused. */
6441 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6443 if (NILP (leaf_windows
[i
]->buffer
))
6445 /* Assert it's not reused as a combination. */
6446 xassert (NILP (leaf_windows
[i
]->hchild
)
6447 && NILP (leaf_windows
[i
]->vchild
));
6448 free_window_matrices (leaf_windows
[i
]);
6450 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6458 /* Fselect_window will have made f the selected frame, so we
6459 reselect the proper frame here. Fhandle_switch_frame will change the
6460 selected window too, but that doesn't make the call to
6461 Fselect_window above totally superfluous; it still sets f's
6463 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6464 do_switch_frame (data
->selected_frame
, 0, 0);
6466 if (! NILP (Vwindow_configuration_change_hook
)
6467 && ! NILP (Vrun_hooks
))
6468 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6471 if (!NILP (new_current_buffer
))
6472 Fset_buffer (new_current_buffer
);
6474 /* Restore the minimum heights recorded in the configuration. */
6475 window_min_height
= data
->min_height
;
6476 window_min_width
= data
->min_width
;
6478 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6479 minibuf_selected_window
= data
->minibuf_selected_window
;
6481 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6484 /* Mark all windows now on frame as deleted
6485 by setting their buffers to nil. */
6488 delete_all_subwindows (w
)
6489 register struct window
*w
;
6491 if (!NILP (w
->next
))
6492 delete_all_subwindows (XWINDOW (w
->next
));
6493 if (!NILP (w
->vchild
))
6494 delete_all_subwindows (XWINDOW (w
->vchild
));
6495 if (!NILP (w
->hchild
))
6496 delete_all_subwindows (XWINDOW (w
->hchild
));
6498 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6500 if (!NILP (w
->buffer
))
6503 /* We set all three of these fields to nil, to make sure that we can
6504 distinguish this dead window from any live window. Live leaf
6505 windows will have buffer set, and combination windows will have
6506 vchild or hchild set. */
6511 Vwindow_list
= Qnil
;
6515 count_windows (window
)
6516 register struct window
*window
;
6518 register int count
= 1;
6519 if (!NILP (window
->next
))
6520 count
+= count_windows (XWINDOW (window
->next
));
6521 if (!NILP (window
->vchild
))
6522 count
+= count_windows (XWINDOW (window
->vchild
));
6523 if (!NILP (window
->hchild
))
6524 count
+= count_windows (XWINDOW (window
->hchild
));
6529 /* Fill vector FLAT with leaf windows under W, starting at index I.
6530 Value is last index + 1. */
6533 get_leaf_windows (w
, flat
, i
)
6535 struct window
**flat
;
6540 if (!NILP (w
->hchild
))
6541 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6542 else if (!NILP (w
->vchild
))
6543 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6547 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6554 /* Return a pointer to the glyph W's physical cursor is on. Value is
6555 null if W's current matrix is invalid, so that no meaningfull glyph
6559 get_phys_cursor_glyph (w
)
6562 struct glyph_row
*row
;
6563 struct glyph
*glyph
;
6565 if (w
->phys_cursor
.vpos
>= 0
6566 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6567 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6569 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6570 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6579 save_window_save (window
, vector
, i
)
6581 struct Lisp_Vector
*vector
;
6584 register struct saved_window
*p
;
6585 register struct window
*w
;
6586 register Lisp_Object tem
;
6588 for (;!NILP (window
); window
= w
->next
)
6590 p
= SAVED_WINDOW_N (vector
, i
);
6591 w
= XWINDOW (window
);
6593 XSETFASTINT (w
->temslot
, i
); i
++;
6595 p
->buffer
= w
->buffer
;
6596 p
->left_col
= w
->left_col
;
6597 p
->top_line
= w
->top_line
;
6598 p
->total_cols
= w
->total_cols
;
6599 p
->total_lines
= w
->total_lines
;
6600 p
->hscroll
= w
->hscroll
;
6601 p
->min_hscroll
= w
->min_hscroll
;
6602 p
->display_table
= w
->display_table
;
6603 p
->orig_top_line
= w
->orig_top_line
;
6604 p
->orig_total_lines
= w
->orig_total_lines
;
6605 p
->left_margin_cols
= w
->left_margin_cols
;
6606 p
->right_margin_cols
= w
->right_margin_cols
;
6607 p
->left_fringe_width
= w
->left_fringe_width
;
6608 p
->right_fringe_width
= w
->right_fringe_width
;
6609 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6610 p
->scroll_bar_width
= w
->scroll_bar_width
;
6611 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6612 p
->dedicated
= w
->dedicated
;
6613 if (!NILP (w
->buffer
))
6615 /* Save w's value of point in the window configuration.
6616 If w is the selected window, then get the value of point
6617 from the buffer; pointm is garbage in the selected window. */
6618 if (EQ (window
, selected_window
))
6620 p
->pointm
= Fmake_marker ();
6621 set_marker_both (p
->pointm
, w
->buffer
,
6622 BUF_PT (XBUFFER (w
->buffer
)),
6623 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6626 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6628 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6629 p
->start_at_line_beg
= w
->start_at_line_beg
;
6631 tem
= XBUFFER (w
->buffer
)->mark
;
6632 p
->mark
= Fcopy_marker (tem
, Qnil
);
6639 p
->start_at_line_beg
= Qnil
;
6642 if (NILP (w
->parent
))
6645 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6650 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6652 if (!NILP (w
->vchild
))
6653 i
= save_window_save (w
->vchild
, vector
, i
);
6654 if (!NILP (w
->hchild
))
6655 i
= save_window_save (w
->hchild
, vector
, i
);
6661 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6662 Scurrent_window_configuration
, 0, 1, 0,
6663 doc
: /* Return an object representing the current window configuration of FRAME.
6664 If FRAME is nil or omitted, use the selected frame.
6665 This describes the number of windows, their sizes and current buffers,
6666 and for each displayed buffer, where display starts, and the positions of
6667 point and mark. An exception is made for point in the current buffer:
6668 its value is -not- saved.
6669 This also records the currently selected frame, and FRAME's focus
6670 redirection (see `redirect-frame-focus'). */)
6674 register Lisp_Object tem
;
6675 register int n_windows
;
6676 register struct save_window_data
*data
;
6681 frame
= selected_frame
;
6682 CHECK_LIVE_FRAME (frame
);
6685 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6686 data
= ALLOCATE_PSEUDOVECTOR (struct save_window_data
, frame_cols
,
6687 PVEC_WINDOW_CONFIGURATION
);
6689 data
->frame_cols
= FRAME_COLS (f
);
6690 data
->frame_lines
= FRAME_LINES (f
);
6691 data
->frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6692 data
->frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6693 data
->selected_frame
= selected_frame
;
6694 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6695 XSETBUFFER (data
->current_buffer
, current_buffer
);
6696 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6697 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6698 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6699 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6700 data
->min_height
= window_min_height
;
6701 data
->min_width
= window_min_width
;
6702 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6703 data
->saved_windows
= tem
;
6704 for (i
= 0; i
< n_windows
; i
++)
6705 XVECTOR (tem
)->contents
[i
]
6706 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6707 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6708 XSETWINDOW_CONFIGURATION (tem
, data
);
6712 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6714 doc
: /* Execute BODY, preserving window sizes and contents.
6715 Return the value of the last form in BODY.
6716 Restore which buffer appears in which window, where display starts,
6717 and the value of point and mark for each window.
6718 Also restore the choice of selected window.
6719 Also restore which buffer is current.
6720 Does not restore the value of point in current buffer.
6721 usage: (save-window-excursion BODY...) */)
6725 register Lisp_Object val
;
6726 register int count
= SPECPDL_INDEX ();
6728 record_unwind_protect (Fset_window_configuration
,
6729 Fcurrent_window_configuration (Qnil
));
6730 val
= Fprogn (args
);
6731 return unbind_to (count
, val
);
6736 /***********************************************************************
6738 ***********************************************************************/
6744 Lisp_Object tail
= Qnil
;
6745 Lisp_Object result
= Qnil
;
6752 if (!NILP (w
->hchild
))
6753 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6754 window_tree (XWINDOW (w
->hchild
))));
6755 else if (!NILP (w
->vchild
))
6756 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6757 window_tree (XWINDOW (w
->vchild
))));
6761 result
= tail
= Fcons (wn
, Qnil
);
6765 XSETCDR (tail
, Fcons (wn
, Qnil
));
6769 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6777 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6779 doc
: /* Return the window tree for frame FRAME.
6781 The return value is a list of the form (ROOT MINI), where ROOT
6782 represents the window tree of the frame's root window, and MINI
6783 is the frame's minibuffer window.
6785 If the root window is not split, ROOT is the root window itself.
6786 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6787 horizontal split, and t for a vertical split, EDGES gives the combined
6788 size and position of the subwindows in the split, and the rest of the
6789 elements are the subwindows in the split. Each of the subwindows may
6790 again be a window or a list representing a window split, and so on.
6791 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6793 If FRAME is nil or omitted, return information on the currently
6801 frame
= selected_frame
;
6803 CHECK_FRAME (frame
);
6806 if (!FRAME_LIVE_P (f
))
6809 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6813 /***********************************************************************
6815 ***********************************************************************/
6817 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6819 doc
: /* Set width of marginal areas of window WINDOW.
6820 If WINDOW is nil, set margins of the currently selected window.
6821 Second arg LEFT-WIDTH specifies the number of character cells to
6822 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6823 does the same for the right marginal area. A nil width parameter
6824 means no margin. */)
6825 (window
, left_width
, right_width
)
6826 Lisp_Object window
, left_width
, right_width
;
6828 struct window
*w
= decode_window (window
);
6830 /* Translate negative or zero widths to nil.
6831 Margins that are too wide have to be checked elsewhere. */
6833 if (!NILP (left_width
))
6835 CHECK_NUMBER (left_width
);
6836 if (XINT (left_width
) <= 0)
6840 if (!NILP (right_width
))
6842 CHECK_NUMBER (right_width
);
6843 if (XINT (right_width
) <= 0)
6847 if (!EQ (w
->left_margin_cols
, left_width
)
6848 || !EQ (w
->right_margin_cols
, right_width
))
6850 w
->left_margin_cols
= left_width
;
6851 w
->right_margin_cols
= right_width
;
6853 adjust_window_margins (w
);
6855 ++windows_or_buffers_changed
;
6856 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6863 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6865 doc
: /* Get width of marginal areas of window WINDOW.
6866 If WINDOW is omitted or nil, use the currently selected window.
6867 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6868 If a marginal area does not exist, its width will be returned
6873 struct window
*w
= decode_window (window
);
6874 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6879 /***********************************************************************
6881 ***********************************************************************/
6883 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6885 doc
: /* Set the fringe widths of window WINDOW.
6886 If WINDOW is nil, set the fringe widths of the currently selected
6888 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6889 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6890 fringe width. If a fringe width arg is nil, that means to use the
6891 frame's default fringe width. Default fringe widths can be set with
6892 the command `set-fringe-style'.
6893 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6894 outside of the display margins. By default, fringes are drawn between
6895 display marginal areas and the text area. */)
6896 (window
, left_width
, right_width
, outside_margins
)
6897 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6899 struct window
*w
= decode_window (window
);
6901 if (!NILP (left_width
))
6902 CHECK_NATNUM (left_width
);
6903 if (!NILP (right_width
))
6904 CHECK_NATNUM (right_width
);
6906 /* Do nothing on a tty. */
6907 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6908 && (!EQ (w
->left_fringe_width
, left_width
)
6909 || !EQ (w
->right_fringe_width
, right_width
)
6910 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6912 w
->left_fringe_width
= left_width
;
6913 w
->right_fringe_width
= right_width
;
6914 w
->fringes_outside_margins
= outside_margins
;
6916 adjust_window_margins (w
);
6918 clear_glyph_matrix (w
->current_matrix
);
6919 w
->window_end_valid
= Qnil
;
6921 ++windows_or_buffers_changed
;
6922 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6929 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6931 doc
: /* Get width of fringes of window WINDOW.
6932 If WINDOW is omitted or nil, use the currently selected window.
6933 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6937 struct window
*w
= decode_window (window
);
6939 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6940 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6941 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6942 ? Qt
: Qnil
), Qnil
)));
6947 /***********************************************************************
6949 ***********************************************************************/
6951 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6953 doc
: /* Set width and type of scroll bars of window WINDOW.
6954 If window is nil, set scroll bars of the currently selected window.
6955 Second parameter WIDTH specifies the pixel width for the scroll bar;
6956 this is automatically adjusted to a multiple of the frame column width.
6957 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6958 bar: left, right, or nil.
6959 If WIDTH is nil, use the frame's scroll-bar width.
6960 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6961 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6962 (window
, width
, vertical_type
, horizontal_type
)
6963 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6965 struct window
*w
= decode_window (window
);
6969 CHECK_NATNUM (width
);
6971 if (XINT (width
) == 0)
6972 vertical_type
= Qnil
;
6975 if (!(NILP (vertical_type
)
6976 || EQ (vertical_type
, Qleft
)
6977 || EQ (vertical_type
, Qright
)
6978 || EQ (vertical_type
, Qt
)))
6979 error ("Invalid type of vertical scroll bar");
6981 if (!EQ (w
->scroll_bar_width
, width
)
6982 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6984 w
->scroll_bar_width
= width
;
6985 w
->vertical_scroll_bar_type
= vertical_type
;
6987 adjust_window_margins (w
);
6989 clear_glyph_matrix (w
->current_matrix
);
6990 w
->window_end_valid
= Qnil
;
6992 ++windows_or_buffers_changed
;
6993 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
7000 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
7002 doc
: /* Get width and type of scroll bars of window WINDOW.
7003 If WINDOW is omitted or nil, use the currently selected window.
7004 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
7005 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
7010 struct window
*w
= decode_window (window
);
7011 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
7012 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
7013 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
7014 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
7015 Fcons (w
->vertical_scroll_bar_type
,
7016 Fcons (Qnil
, Qnil
))));
7021 /***********************************************************************
7023 ***********************************************************************/
7025 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
7026 doc
: /* Return the amount by which WINDOW is scrolled vertically.
7027 Use the selected window if WINDOW is nil or omitted.
7028 Normally, value is a multiple of the canonical character height of WINDOW;
7029 optional second arg PIXELS-P means value is measured in pixels. */)
7031 Lisp_Object window
, pixels_p
;
7038 window
= selected_window
;
7040 CHECK_WINDOW (window
);
7041 w
= XWINDOW (window
);
7042 f
= XFRAME (w
->frame
);
7044 if (FRAME_WINDOW_P (f
))
7045 result
= (NILP (pixels_p
)
7046 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
7047 : make_number (-w
->vscroll
));
7049 result
= make_number (0);
7054 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
7056 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
7057 WINDOW nil means use the selected window. Normally, VSCROLL is a
7058 non-negative multiple of the canonical character height of WINDOW;
7059 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
7060 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
7061 corresponds to an integral number of pixels. The return value is the
7062 result of this rounding.
7063 If PIXELS-P is non-nil, the return value is VSCROLL. */)
7064 (window
, vscroll
, pixels_p
)
7065 Lisp_Object window
, vscroll
, pixels_p
;
7071 window
= selected_window
;
7073 CHECK_WINDOW (window
);
7074 CHECK_NUMBER_OR_FLOAT (vscroll
);
7076 w
= XWINDOW (window
);
7077 f
= XFRAME (w
->frame
);
7079 if (FRAME_WINDOW_P (f
))
7081 int old_dy
= w
->vscroll
;
7083 w
->vscroll
= - (NILP (pixels_p
)
7084 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
7085 : XFLOATINT (vscroll
));
7086 w
->vscroll
= min (w
->vscroll
, 0);
7088 if (w
->vscroll
!= old_dy
)
7090 /* Adjust glyph matrix of the frame if the virtual display
7091 area becomes larger than before. */
7092 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
7095 /* Prevent redisplay shortcuts. */
7096 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
7100 return Fwindow_vscroll (window
, pixels_p
);
7104 /* Call FN for all leaf windows on frame F. FN is called with the
7105 first argument being a pointer to the leaf window, and with
7106 additional argument USER_DATA. Stops when FN returns 0. */
7109 foreach_window (f
, fn
, user_data
)
7111 int (* fn
) P_ ((struct window
*, void *));
7114 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
7115 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
7116 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
7120 /* Helper function for foreach_window. Call FN for all leaf windows
7121 reachable from W. FN is called with the first argument being a
7122 pointer to the leaf window, and with additional argument USER_DATA.
7123 Stop when FN returns 0. Value is 0 if stopped by FN. */
7126 foreach_window_1 (w
, fn
, user_data
)
7128 int (* fn
) P_ ((struct window
*, void *));
7133 for (cont
= 1; w
&& cont
;)
7135 if (!NILP (w
->hchild
))
7136 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
7137 else if (!NILP (w
->vchild
))
7138 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
7140 cont
= fn (w
, user_data
);
7142 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
7149 /* Freeze or unfreeze the window start of W unless it is a
7150 mini-window or the selected window. FREEZE_P non-null means freeze
7151 the window start. */
7154 freeze_window_start (w
, freeze_p
)
7158 if (MINI_WINDOW_P (w
)
7159 || (WINDOWP (selected_window
) /* Can be nil in corner cases. */
7160 && (w
== XWINDOW (selected_window
)
7161 || (MINI_WINDOW_P (XWINDOW (selected_window
))
7162 && ! NILP (Vminibuf_scroll_window
)
7163 && w
== XWINDOW (Vminibuf_scroll_window
)))))
7166 w
->frozen_window_start_p
= freeze_p
!= NULL
;
7171 /* Freeze or unfreeze the window starts of all leaf windows on frame
7172 F, except the selected window and a mini-window. FREEZE_P non-zero
7173 means freeze the window start. */
7176 freeze_window_starts (f
, freeze_p
)
7180 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
7184 /***********************************************************************
7186 ***********************************************************************/
7188 /* Return 1 if window configurations C1 and C2
7189 describe the same state of affairs. This is used by Fequal. */
7192 compare_window_configurations (c1
, c2
, ignore_positions
)
7194 int ignore_positions
;
7196 register struct save_window_data
*d1
, *d2
;
7197 struct Lisp_Vector
*sw1
, *sw2
;
7200 CHECK_WINDOW_CONFIGURATION (c1
);
7201 CHECK_WINDOW_CONFIGURATION (c2
);
7203 d1
= (struct save_window_data
*) XVECTOR (c1
);
7204 d2
= (struct save_window_data
*) XVECTOR (c2
);
7205 sw1
= XVECTOR (d1
->saved_windows
);
7206 sw2
= XVECTOR (d2
->saved_windows
);
7208 if (d1
->frame_cols
!= d2
->frame_cols
)
7210 if (d1
->frame_lines
!= d2
->frame_lines
)
7212 if (d1
->frame_menu_bar_lines
!= d2
->frame_menu_bar_lines
)
7214 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
7216 /* Don't compare the current_window field directly.
7217 Instead see w1_is_current and w2_is_current, below. */
7218 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
7220 if (! ignore_positions
)
7222 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
7224 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
7227 /* Don't compare the root_window field.
7228 We don't require the two configurations
7229 to use the same window object,
7230 and the two root windows must be equivalent
7231 if everything else compares equal. */
7232 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
7234 if (d1
->min_width
!= d2
->min_width
)
7236 if (d1
->min_height
!= d2
->min_height
)
7239 /* Verify that the two confis have the same number of windows. */
7240 if (sw1
->size
!= sw2
->size
)
7243 for (i
= 0; i
< sw1
->size
; i
++)
7245 struct saved_window
*p1
, *p2
;
7246 int w1_is_current
, w2_is_current
;
7248 p1
= SAVED_WINDOW_N (sw1
, i
);
7249 p2
= SAVED_WINDOW_N (sw2
, i
);
7251 /* Verify that the current windows in the two
7252 configurations correspond to each other. */
7253 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7254 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7256 if (w1_is_current
!= w2_is_current
)
7259 /* Verify that the corresponding windows do match. */
7260 if (! EQ (p1
->buffer
, p2
->buffer
))
7262 if (! EQ (p1
->left_col
, p2
->left_col
))
7264 if (! EQ (p1
->top_line
, p2
->top_line
))
7266 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7268 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7270 if (! EQ (p1
->display_table
, p2
->display_table
))
7272 if (! EQ (p1
->parent
, p2
->parent
))
7274 if (! EQ (p1
->prev
, p2
->prev
))
7276 if (! ignore_positions
)
7278 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7280 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7282 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7284 if (NILP (Fequal (p1
->start
, p2
->start
)))
7286 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7288 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7291 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7293 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7295 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7297 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7299 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7301 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7303 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7310 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7311 Scompare_window_configurations
, 2, 2, 0,
7312 doc
: /* Compare two window configurations as regards the structure of windows.
7313 This function ignores details such as the values of point and mark
7314 and scrolling positions. */)
7318 if (compare_window_configurations (x
, y
, 1))
7326 struct frame
*f
= make_initial_frame ();
7327 XSETFRAME (selected_frame
, f
);
7328 Vterminal_frame
= selected_frame
;
7329 minibuf_window
= f
->minibuffer_window
;
7330 selected_window
= f
->selected_window
;
7331 last_nonminibuf_frame
= f
;
7333 window_initialized
= 1;
7339 Vwindow_list
= Qnil
;
7345 Qscroll_up
= intern ("scroll-up");
7346 staticpro (&Qscroll_up
);
7348 Qscroll_down
= intern ("scroll-down");
7349 staticpro (&Qscroll_down
);
7351 Qwindow_size_fixed
= intern ("window-size-fixed");
7352 staticpro (&Qwindow_size_fixed
);
7353 Fset (Qwindow_size_fixed
, Qnil
);
7355 staticpro (&Qwindow_configuration_change_hook
);
7356 Qwindow_configuration_change_hook
7357 = intern ("window-configuration-change-hook");
7359 Qwindowp
= intern ("windowp");
7360 staticpro (&Qwindowp
);
7362 Qwindow_configuration_p
= intern ("window-configuration-p");
7363 staticpro (&Qwindow_configuration_p
);
7365 Qwindow_live_p
= intern ("window-live-p");
7366 staticpro (&Qwindow_live_p
);
7368 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7369 staticpro (&Qtemp_buffer_show_hook
);
7371 staticpro (&Vwindow_list
);
7373 minibuf_selected_window
= Qnil
;
7374 staticpro (&minibuf_selected_window
);
7376 window_scroll_pixel_based_preserve_y
= -1;
7378 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7379 doc
: /* Non-nil means call as function to display a help buffer.
7380 The function is called with one argument, the buffer to be displayed.
7381 Used by `with-output-to-temp-buffer'.
7382 If this function is used, then it must do the entire job of showing
7383 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7384 Vtemp_buffer_show_function
= Qnil
;
7386 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7387 doc
: /* If non-nil, function to call to handle `display-buffer'.
7388 It will receive two args, the buffer and a flag which if non-nil means
7389 that the currently selected window is not acceptable.
7390 It should choose or create a window, display the specified buffer in it,
7391 and return the window.
7392 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7393 work using this function. */);
7394 Vdisplay_buffer_function
= Qnil
;
7396 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7397 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7398 If nil, `display-buffer' will leave the window configuration alone. */);
7399 Veven_window_heights
= Qt
;
7401 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7402 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7403 Vminibuf_scroll_window
= Qnil
;
7405 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7406 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7407 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7408 is displayed in the `mode-line' face. */);
7409 mode_line_in_non_selected_windows
= 1;
7411 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7412 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7413 Vother_window_scroll_buffer
= Qnil
;
7415 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7416 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7419 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7420 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7421 auto_window_vscroll_p
= 1;
7423 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7424 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7425 If the buffer in question is already displayed in a frame, raise that frame. */);
7426 display_buffer_reuse_frames
= 0;
7428 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7429 doc
: /* Function to call to handle automatic new frame creation.
7430 It is called with no arguments and should return a newly created frame.
7432 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7433 where `pop-up-frame-alist' would hold the default frame parameters. */);
7434 Vpop_up_frame_function
= Qnil
;
7436 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7437 doc
: /* *List of buffer names that should have their own special frames.
7438 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7439 if its name is in this list, makes a special frame for it
7440 using `special-display-function'. See also `special-display-regexps'.
7442 An element of the list can be a list instead of just a string.
7443 There are two ways to use a list as an element:
7444 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7445 In the first case, the FRAME-PARAMETERS are pairs of the form
7446 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7447 In the second case, FUNCTION is called with BUFFER as the first argument,
7448 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7449 All this is done by the function found in `special-display-function'.
7451 If the specified frame parameters include (same-buffer . t), the
7452 buffer is displayed in the currently selected window. Otherwise, if
7453 they include (same-frame . t), the buffer is displayed in a new window
7454 in the currently selected frame.
7456 If this variable appears \"not to work\", because you add a name to it
7457 but that buffer still appears in the selected window, look at the
7458 values of `same-window-buffer-names' and `same-window-regexps'.
7459 Those variables take precedence over this one. */);
7460 Vspecial_display_buffer_names
= Qnil
;
7462 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7463 doc
: /* *List of regexps saying which buffers should have their own special frames.
7464 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7465 if any regexp in this list matches the buffer name, it makes a
7466 special frame for the buffer by calling `special-display-function'.
7468 An element of the list can be a list instead of just a string.
7469 There are two ways to use a list as an element:
7470 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7471 In the first case, the FRAME-PARAMETERS are pairs of the form
7472 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7473 In the second case, FUNCTION is called with BUFFER as the first argument,
7474 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7475 All this is done by the function found in `special-display-function'.
7477 If the specified frame parameters include (same-buffer . t), the
7478 buffer is displayed in the currently selected window. Otherwise, if
7479 they include (same-frame . t), the buffer is displayed in a new window
7480 in the currently selected frame.
7482 If this variable appears \"not to work\", because you add a regexp to it
7483 but the matching buffers still appear in the selected window, look at the
7484 values of `same-window-buffer-names' and `same-window-regexps'.
7485 Those variables take precedence over this one. */);
7486 Vspecial_display_regexps
= Qnil
;
7488 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7489 doc
: /* Function to call to make a new frame for a special buffer.
7490 It is called with two arguments, the buffer and optional buffer specific
7491 data, and should return a window displaying that buffer.
7492 The default value normally makes a separate frame for the buffer,
7493 using `special-display-frame-alist' to specify the frame parameters.
7494 But if the buffer specific data includes (same-buffer . t) then the
7495 buffer is displayed in the current selected window.
7496 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7497 a new window in the currently selected frame.
7499 A buffer is special if it is listed in `special-display-buffer-names'
7500 or matches a regexp in `special-display-regexps'. */);
7501 Vspecial_display_function
= Qnil
;
7503 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7504 doc
: /* *List of buffer names that should appear in the selected window.
7505 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7506 switches to it in the selected window, rather than making it appear
7507 in some other window.
7509 An element of the list can be a cons cell instead of just a string.
7510 Then the car must be a string, which specifies the buffer name.
7511 This is for compatibility with `special-display-buffer-names';
7512 the cdr of the cons cell is ignored.
7514 See also `same-window-regexps'. */);
7515 Vsame_window_buffer_names
= Qnil
;
7517 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7518 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7519 If a buffer name matches one of these regexps, then displaying it
7520 using `display-buffer' or `pop-to-buffer' switches to it
7521 in the selected window, rather than making it appear in some other window.
7523 An element of the list can be a cons cell instead of just a string.
7524 Then the car must be a string, which specifies the buffer name.
7525 This is for compatibility with `special-display-buffer-names';
7526 the cdr of the cons cell is ignored.
7528 See also `same-window-buffer-names'. */);
7529 Vsame_window_regexps
= Qnil
;
7531 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7532 doc
: /* *Non-nil means display-buffer should make new windows. */);
7535 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7536 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7537 next_screen_context_lines
= 2;
7539 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7540 doc
: /* *A window must be at least this tall to be eligible for splitting
7541 by `display-buffer'. The value is in line units.
7542 If there is only one window, it is split regardless of this value. */);
7543 split_height_threshold
= 500;
7545 DEFVAR_LISP ("split-window-preferred-function",
7546 &Vsplit_window_preferred_function
,
7547 doc
: /* Function to use to split a window.
7548 This is used by `display-buffer' to allow the user to choose whether
7549 to split windows horizontally or vertically or some mix of the two.
7550 It is called with a window as single argument and should split it in two
7551 and return the new window. */);
7552 Vsplit_window_preferred_function
= intern ("split-window");
7554 DEFVAR_INT ("window-min-height", &window_min_height
,
7555 doc
: /* *Delete any window less than this tall (including its mode line).
7556 The value is in line units. */);
7557 window_min_height
= 4;
7559 DEFVAR_INT ("window-min-width", &window_min_width
,
7560 doc
: /* *Delete any window less than this wide (measured in characters). */);
7561 window_min_width
= 10;
7563 DEFVAR_LISP ("scroll-preserve-screen-position",
7564 &Vscroll_preserve_screen_position
,
7565 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7566 A value of nil means point does not keep its screen position except
7567 at the scroll margin or window boundary respectively.
7568 A value of t means point keeps its screen position if the scroll
7569 command moved it vertically out of the window, e.g. when scrolling
7571 Any other value means point always keeps its screen position. */);
7572 Vscroll_preserve_screen_position
= Qnil
;
7574 DEFVAR_LISP ("window-configuration-change-hook",
7575 &Vwindow_configuration_change_hook
,
7576 doc
: /* Functions to call when window configuration changes.
7577 The selected frame is the one whose configuration has changed. */);
7578 Vwindow_configuration_change_hook
= Qnil
;
7580 defsubr (&Sselected_window
);
7581 defsubr (&Sminibuffer_window
);
7582 defsubr (&Swindow_minibuffer_p
);
7583 defsubr (&Swindowp
);
7584 defsubr (&Swindow_live_p
);
7585 defsubr (&Spos_visible_in_window_p
);
7586 defsubr (&Swindow_line_height
);
7587 defsubr (&Swindow_buffer
);
7588 defsubr (&Swindow_height
);
7589 defsubr (&Swindow_width
);
7590 defsubr (&Swindow_full_width_p
);
7591 defsubr (&Swindow_hscroll
);
7592 defsubr (&Sset_window_hscroll
);
7593 defsubr (&Swindow_redisplay_end_trigger
);
7594 defsubr (&Sset_window_redisplay_end_trigger
);
7595 defsubr (&Swindow_edges
);
7596 defsubr (&Swindow_pixel_edges
);
7597 defsubr (&Swindow_inside_edges
);
7598 defsubr (&Swindow_inside_pixel_edges
);
7599 defsubr (&Scoordinates_in_window_p
);
7600 defsubr (&Swindow_at
);
7601 defsubr (&Swindow_point
);
7602 defsubr (&Swindow_start
);
7603 defsubr (&Swindow_end
);
7604 defsubr (&Sset_window_point
);
7605 defsubr (&Sset_window_start
);
7606 defsubr (&Swindow_dedicated_p
);
7607 defsubr (&Sset_window_dedicated_p
);
7608 defsubr (&Swindow_display_table
);
7609 defsubr (&Sset_window_display_table
);
7610 defsubr (&Snext_window
);
7611 defsubr (&Sprevious_window
);
7612 defsubr (&Sother_window
);
7613 defsubr (&Sget_lru_window
);
7614 defsubr (&Sget_largest_window
);
7615 defsubr (&Sget_buffer_window
);
7616 defsubr (&Sdelete_other_windows
);
7617 defsubr (&Sdelete_windows_on
);
7618 defsubr (&Sreplace_buffer_in_windows
);
7619 defsubr (&Sdelete_window
);
7620 defsubr (&Sset_window_buffer
);
7621 defsubr (&Sselect_window
);
7622 defsubr (&Sspecial_display_p
);
7623 defsubr (&Ssame_window_p
);
7624 defsubr (&Sdisplay_buffer
);
7625 defsubr (&Sforce_window_update
);
7626 defsubr (&Ssplit_window
);
7627 defsubr (&Senlarge_window
);
7628 defsubr (&Sshrink_window
);
7629 defsubr (&Sadjust_window_trailing_edge
);
7630 defsubr (&Sscroll_up
);
7631 defsubr (&Sscroll_down
);
7632 defsubr (&Sscroll_left
);
7633 defsubr (&Sscroll_right
);
7634 defsubr (&Sother_window_for_scrolling
);
7635 defsubr (&Sscroll_other_window
);
7636 defsubr (&Sminibuffer_selected_window
);
7637 defsubr (&Srecenter
);
7638 defsubr (&Swindow_text_height
);
7639 defsubr (&Smove_to_window_line
);
7640 defsubr (&Swindow_configuration_p
);
7641 defsubr (&Swindow_configuration_frame
);
7642 defsubr (&Sset_window_configuration
);
7643 defsubr (&Scurrent_window_configuration
);
7644 defsubr (&Ssave_window_excursion
);
7645 defsubr (&Swindow_tree
);
7646 defsubr (&Sset_window_margins
);
7647 defsubr (&Swindow_margins
);
7648 defsubr (&Sset_window_fringes
);
7649 defsubr (&Swindow_fringes
);
7650 defsubr (&Sset_window_scroll_bars
);
7651 defsubr (&Swindow_scroll_bars
);
7652 defsubr (&Swindow_vscroll
);
7653 defsubr (&Sset_window_vscroll
);
7654 defsubr (&Scompare_window_configurations
);
7655 defsubr (&Swindow_list
);
7661 initial_define_key (control_x_map
, '1', "delete-other-windows");
7662 initial_define_key (control_x_map
, '2', "split-window");
7663 initial_define_key (control_x_map
, '0', "delete-window");
7664 initial_define_key (control_x_map
, 'o', "other-window");
7665 initial_define_key (control_x_map
, '^', "enlarge-window");
7666 initial_define_key (control_x_map
, '<', "scroll-left");
7667 initial_define_key (control_x_map
, '>', "scroll-right");
7669 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7670 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7671 initial_define_key (meta_map
, 'v', "scroll-down");
7673 initial_define_key (global_map
, Ctl('L'), "recenter");
7674 initial_define_key (meta_map
, 'r', "move-to-window-line");
7677 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7678 (do not change this comment) */