1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
52 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
53 Lisp_Object Qscroll_up
, Qscroll_down
;
54 Lisp_Object Qwindow_size_fixed
;
55 extern Lisp_Object Qleft_margin
, Qright_margin
;
57 static int displayed_window_lines
P_ ((struct window
*));
58 static struct window
*decode_window
P_ ((Lisp_Object
));
59 static int count_windows
P_ ((struct window
*));
60 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
61 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
62 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
63 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
64 static int window_min_size_1
P_ ((struct window
*, int));
65 static int window_min_size
P_ ((struct window
*, int, int, int *));
66 static void size_window
P_ ((Lisp_Object
, int, int, int, int, int));
67 static int freeze_window_start
P_ ((struct window
*, void *));
68 static int window_fixed_size_p
P_ ((struct window
*, int, int));
69 static void enlarge_window
P_ ((Lisp_Object
, int, int));
70 static Lisp_Object window_list
P_ ((void));
71 static int add_window_to_list
P_ ((struct window
*, void *));
72 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
74 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
76 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
78 static int foreach_window_1
P_ ((struct window
*,
79 int (* fn
) (struct window
*, void *),
81 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
83 /* This is the window in which the terminal's cursor should
84 be left when nothing is being done with it. This must
85 always be a leaf window, and its buffer is selected by
86 the top level editing loop at the end of each command.
88 This value is always the same as
89 FRAME_SELECTED_WINDOW (selected_frame). */
91 Lisp_Object selected_window
;
93 /* A list of all windows for use by next_window and Fwindow_list.
94 Functions creating or deleting windows should invalidate this cache
95 by setting it to nil. */
97 Lisp_Object Vwindow_list
;
99 /* The mini-buffer window of the selected frame.
100 Note that you cannot test for mini-bufferness of an arbitrary window
101 by comparing against this; but you can test for mini-bufferness of
102 the selected window. */
104 Lisp_Object minibuf_window
;
106 /* Non-nil means it is the window whose mode line should be
107 shown as the selected window when the minibuffer is selected. */
109 Lisp_Object minibuf_selected_window
;
111 /* Non-nil means it is the window for C-M-v to scroll
112 when the mini-buffer is selected. */
114 Lisp_Object Vminibuf_scroll_window
;
116 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
118 Lisp_Object Vother_window_scroll_buffer
;
120 /* Non-nil means it's function to call to display temp buffers. */
122 Lisp_Object Vtemp_buffer_show_function
;
124 /* Non-zero means line and page scrolling on tall lines (with images)
125 does partial scrolling by modifying window-vscroll. */
127 int auto_window_vscroll_p
;
129 /* Non-zero means to use mode-line-inactive face in all windows but the
130 selected-window and the minibuffer-scroll-window when the
131 minibuffer is active. */
132 int mode_line_in_non_selected_windows
;
134 /* If a window gets smaller than either of these, it is removed. */
136 EMACS_INT window_min_height
;
137 EMACS_INT window_min_width
;
139 /* Nonzero implies Fdisplay_buffer should create windows. */
143 /* Nonzero implies make new frames for Fdisplay_buffer. */
147 /* Nonzero means reuse existing frames for displaying buffers. */
149 int display_buffer_reuse_frames
;
151 /* Non-nil means use this function instead of default */
153 Lisp_Object Vpop_up_frame_function
;
155 /* Function to call to handle Fdisplay_buffer. */
157 Lisp_Object Vdisplay_buffer_function
;
159 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
161 Lisp_Object Veven_window_heights
;
163 /* List of buffer *names* for buffers that should have their own frames. */
165 Lisp_Object Vspecial_display_buffer_names
;
167 /* List of regexps for buffer names that should have their own frames. */
169 Lisp_Object Vspecial_display_regexps
;
171 /* Function to pop up a special frame. */
173 Lisp_Object Vspecial_display_function
;
175 /* List of buffer *names* for buffers to appear in selected window. */
177 Lisp_Object Vsame_window_buffer_names
;
179 /* List of regexps for buffer names to appear in selected window. */
181 Lisp_Object Vsame_window_regexps
;
183 /* Hook run at end of temp_output_buffer_show. */
185 Lisp_Object Qtemp_buffer_show_hook
;
187 /* Fdisplay_buffer always splits the largest window
188 if that window is more than this high. */
190 EMACS_INT split_height_threshold
;
192 /* Number of lines of continuity in scrolling by screenfuls. */
194 EMACS_INT next_screen_context_lines
;
196 /* Incremented for each window created. */
198 static int sequence_number
;
200 /* Nonzero after init_window_once has finished. */
202 static int window_initialized
;
204 /* Hook to run when window config changes. */
206 Lisp_Object Qwindow_configuration_change_hook
;
207 Lisp_Object Vwindow_configuration_change_hook
;
209 /* Non-nil means scroll commands try to put point
210 at the same screen height as previously. */
212 Lisp_Object Vscroll_preserve_screen_position
;
214 /* Incremented by 1 whenever a window is deleted. */
216 int window_deletion_count
;
218 /* Used by the function window_scroll_pixel_based */
220 static int window_scroll_pixel_based_preserve_y
;
222 #if 0 /* This isn't used anywhere. */
223 /* Nonzero means we can split a frame even if it is "unsplittable". */
224 static int inhibit_frame_unsplittable
;
227 extern EMACS_INT scroll_margin
;
229 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
231 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
232 doc
: /* Returns t if OBJECT is a window. */)
236 return WINDOWP (object
) ? Qt
: Qnil
;
239 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
240 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
244 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
251 register struct window
*p
;
253 p
= allocate_window ();
255 XSETFASTINT (p
->sequence_number
, sequence_number
);
256 XSETFASTINT (p
->left_col
, 0);
257 XSETFASTINT (p
->top_line
, 0);
258 XSETFASTINT (p
->total_lines
, 0);
259 XSETFASTINT (p
->total_cols
, 0);
260 XSETFASTINT (p
->hscroll
, 0);
261 XSETFASTINT (p
->min_hscroll
, 0);
262 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
263 p
->start
= Fmake_marker ();
264 p
->pointm
= Fmake_marker ();
265 XSETFASTINT (p
->use_time
, 0);
267 p
->display_table
= Qnil
;
269 p
->pseudo_window_p
= 0;
270 bzero (&p
->cursor
, sizeof (p
->cursor
));
271 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
272 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
273 p
->desired_matrix
= p
->current_matrix
= 0;
274 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
275 p
->phys_cursor_type
= -1;
276 p
->phys_cursor_width
= -1;
277 p
->must_be_updated_p
= 0;
278 XSETFASTINT (p
->window_end_vpos
, 0);
279 XSETFASTINT (p
->window_end_pos
, 0);
280 p
->window_end_valid
= Qnil
;
283 XSETFASTINT (p
->last_point
, 0);
284 p
->frozen_window_start_p
= 0;
285 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
286 p
->left_margin_cols
= Qnil
;
287 p
->right_margin_cols
= Qnil
;
288 p
->left_fringe_width
= Qnil
;
289 p
->right_fringe_width
= Qnil
;
290 p
->fringes_outside_margins
= Qnil
;
291 p
->scroll_bar_width
= Qnil
;
292 p
->vertical_scroll_bar_type
= Qt
;
298 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
299 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
302 return selected_window
;
305 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
306 doc
: /* Return the window used now for minibuffers.
307 If the optional argument FRAME is specified, return the minibuffer window
308 used by that frame. */)
313 frame
= selected_frame
;
314 CHECK_LIVE_FRAME (frame
);
315 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
318 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
319 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
320 WINDOW defaults to the selected window. */)
324 struct window
*w
= decode_window (window
);
325 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
329 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
330 Spos_visible_in_window_p
, 0, 3, 0,
331 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
332 Return nil if that position is scrolled vertically out of view.
333 If a character is only partially visible, nil is returned, unless the
334 optional argument PARTIALLY is non-nil.
335 If POS is only out of view because of horizontal scrolling, return non-nil.
336 If POS is t, it specifies the position of the last visible glyph in WINDOW.
337 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
339 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
340 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
341 where X and Y are the pixel coordinates relative to the top left corner
342 of the window. The remaining elements are omitted if the character after
343 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
344 off-window at the top and bottom of the row, ROWH is the height of the
345 display row, and VPOS is the row number (0-based) containing POS. */)
346 (pos
, window
, partially
)
347 Lisp_Object pos
, window
, partially
;
349 register struct window
*w
;
351 register struct buffer
*buf
;
353 Lisp_Object in_window
= Qnil
;
354 int rtop
, rbot
, rowh
, vpos
, fully_p
= 1;
357 w
= decode_window (window
);
358 buf
= XBUFFER (w
->buffer
);
359 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
363 else if (!NILP (pos
))
365 CHECK_NUMBER_COERCE_MARKER (pos
);
368 else if (w
== XWINDOW (selected_window
))
371 posint
= XMARKER (w
->pointm
)->charpos
;
373 /* If position is above window start or outside buffer boundaries,
374 or if window start is out of range, position is not visible. */
376 || (posint
>= CHARPOS (top
) && posint
<= BUF_ZV (buf
)))
377 && CHARPOS (top
) >= BUF_BEGV (buf
)
378 && CHARPOS (top
) <= BUF_ZV (buf
)
379 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
)
380 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
383 if (!NILP (in_window
) && !NILP (partially
))
385 Lisp_Object part
= Qnil
;
387 part
= list4 (make_number (rtop
), make_number (rbot
),
388 make_number (rowh
), make_number (vpos
));
389 in_window
= Fcons (make_number (x
),
390 Fcons (make_number (y
), part
));
396 DEFUN ("window-line-height", Fwindow_line_height
,
397 Swindow_line_height
, 0, 2, 0,
398 doc
: /* Return height in pixels of text line LINE in window WINDOW.
399 If WINDOW is nil or omitted, use selected window.
401 Return height of current line if LINE is omitted or nil. Return height of
402 header or mode line if LINE is `header-line' and `mode-line'.
403 Otherwise, LINE is a text line number starting from 0. A negative number
404 counts from the end of the window.
406 Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height
407 in pixels of the visible part of the line, VPOS and YPOS are the
408 vertical position in lines and pixels of the line, relative to the top
409 of the first text line, and OFFBOT is the number of off-window pixels at
410 the bottom of the text line. If there are off-window pixels at the top
411 of the (first) text line, YPOS is negative.
413 Return nil if window display is not up-to-date. In that case, use
414 `pos-visible-in-window-p' to obtain the information. */)
416 Lisp_Object line
, window
;
418 register struct window
*w
;
419 register struct buffer
*b
;
420 struct glyph_row
*row
, *end_row
;
421 int max_y
, crop
, i
, n
;
423 w
= decode_window (window
);
426 || w
->pseudo_window_p
)
429 CHECK_BUFFER (w
->buffer
);
430 b
= XBUFFER (w
->buffer
);
432 /* Fail if current matrix is not up-to-date. */
433 if (NILP (w
->window_end_valid
)
434 || current_buffer
->clip_changed
435 || current_buffer
->prevent_redisplay_optimizations_p
436 || XFASTINT (w
->last_modified
) < BUF_MODIFF (b
)
437 || XFASTINT (w
->last_overlay_modified
) < BUF_OVERLAY_MODIFF (b
))
443 if (i
< 0 || i
>= w
->current_matrix
->nrows
444 || (row
= MATRIX_ROW (w
->current_matrix
, i
), !row
->enabled_p
))
446 max_y
= window_text_bottom_y (w
);
450 if (EQ (line
, Qheader_line
))
452 if (!WINDOW_WANTS_HEADER_LINE_P (w
))
454 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
457 return list4 (make_number (row
->height
),
458 make_number (0), make_number (0),
462 if (EQ (line
, Qmode_line
))
464 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
467 return list4 (make_number (row
->height
),
468 make_number (0), /* not accurate */
469 make_number (WINDOW_HEADER_LINE_HEIGHT (w
)
470 + window_text_bottom_y (w
)),
477 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
478 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
479 max_y
= window_text_bottom_y (w
);
482 while ((n
< 0 || i
< n
)
483 && row
<= end_row
&& row
->enabled_p
484 && row
->y
+ row
->height
< max_y
)
487 if (row
> end_row
|| !row
->enabled_p
)
499 crop
= max (0, (row
->y
+ row
->height
) - max_y
);
500 return list4 (make_number (row
->height
+ min (0, row
->y
) - crop
),
502 make_number (row
->y
),
508 static struct window
*
509 decode_window (window
)
510 register Lisp_Object window
;
513 return XWINDOW (selected_window
);
515 CHECK_LIVE_WINDOW (window
);
516 return XWINDOW (window
);
519 static struct window
*
520 decode_any_window (window
)
521 register Lisp_Object window
;
524 return XWINDOW (selected_window
);
526 CHECK_WINDOW (window
);
527 return XWINDOW (window
);
530 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
531 doc
: /* Return the buffer that WINDOW is displaying.
532 WINDOW defaults to the selected window. */)
536 return decode_window (window
)->buffer
;
539 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
540 doc
: /* Return the number of lines in WINDOW (including its mode line).
541 WINDOW defaults to the selected window. */)
545 return decode_any_window (window
)->total_lines
;
548 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
549 doc
: /* Return the number of display columns in WINDOW.
550 This is the width that is usable columns available for text in WINDOW.
551 If you want to find out how many columns WINDOW takes up,
552 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
556 return make_number (window_box_text_cols (decode_any_window (window
)));
559 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
560 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin.
561 WINDOW defaults to the selected window. */)
565 return decode_window (window
)->hscroll
;
568 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
569 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
570 Return NCOL. NCOL should be zero or positive.
572 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
573 window so that the location of point moves off-window. */)
575 Lisp_Object window
, ncol
;
577 struct window
*w
= decode_window (window
);
581 hscroll
= max (0, XINT (ncol
));
583 /* Prevent redisplay shortcuts when changing the hscroll. */
584 if (XINT (w
->hscroll
) != hscroll
)
585 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
587 w
->hscroll
= make_number (hscroll
);
591 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
592 Swindow_redisplay_end_trigger
, 0, 1, 0,
593 doc
: /* Return WINDOW's redisplay end trigger value.
594 WINDOW defaults to the selected window.
595 See `set-window-redisplay-end-trigger' for more information. */)
599 return decode_window (window
)->redisplay_end_trigger
;
602 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
603 Sset_window_redisplay_end_trigger
, 2, 2, 0,
604 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
605 VALUE should be a buffer position (typically a marker) or nil.
606 If it is a buffer position, then if redisplay in WINDOW reaches a position
607 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
608 with two arguments: WINDOW, and the end trigger value.
609 Afterwards the end-trigger value is reset to nil. */)
611 register Lisp_Object window
, value
;
613 register struct window
*w
;
615 w
= decode_window (window
);
616 w
->redisplay_end_trigger
= value
;
620 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
621 doc
: /* Return a list of the edge coordinates of WINDOW.
622 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
623 RIGHT is one more than the rightmost column occupied by WINDOW,
624 and BOTTOM is one more than the bottommost row occupied by WINDOW.
625 The edges include the space used by the window's scroll bar,
626 display margins, fringes, header line, and mode line, if it has them.
627 To get the edges of the actual text area, use `window-inside-edges'. */)
631 register struct window
*w
= decode_any_window (window
);
633 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
634 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
635 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
636 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
640 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
641 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
642 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
643 RIGHT is one more than the rightmost x position occupied by WINDOW,
644 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
645 The pixel edges include the space used by the window's scroll bar,
646 display margins, fringes, header line, and mode line, if it has them.
647 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
651 register struct window
*w
= decode_any_window (window
);
653 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
654 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
655 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
656 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
660 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
661 doc
: /* Return a list of the edge coordinates of WINDOW.
662 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
663 RIGHT is one more than the rightmost column used by text in WINDOW,
664 and BOTTOM is one more than the bottommost row used by text in WINDOW.
665 The inside edges do not include the space used by the window's scroll bar,
666 display margins, fringes, header line, and/or mode line. */)
670 register struct window
*w
= decode_any_window (window
);
672 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
673 + WINDOW_LEFT_MARGIN_COLS (w
)
674 + WINDOW_LEFT_FRINGE_COLS (w
)),
675 make_number (WINDOW_TOP_EDGE_LINE (w
)
676 + WINDOW_HEADER_LINE_LINES (w
)),
677 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
678 - WINDOW_RIGHT_MARGIN_COLS (w
)
679 - WINDOW_RIGHT_FRINGE_COLS (w
)),
680 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
681 - WINDOW_MODE_LINE_LINES (w
)));
684 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
685 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
686 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
687 RIGHT is one more than the rightmost x position used by text in WINDOW,
688 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
689 The inside edges do not include the space used by the window's scroll bar,
690 display margins, fringes, header line, and/or mode line. */)
694 register struct window
*w
= decode_any_window (window
);
696 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
697 + WINDOW_LEFT_MARGIN_WIDTH (w
)
698 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
699 make_number (WINDOW_TOP_EDGE_Y (w
)
700 + WINDOW_HEADER_LINE_HEIGHT (w
)),
701 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
702 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
703 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
704 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
705 - WINDOW_MODE_LINE_HEIGHT (w
)));
708 /* Test if the character at column *X, row *Y is within window W.
709 If it is not, return ON_NOTHING;
710 if it is in the window's text area,
711 set *x and *y to its location relative to the upper left corner
714 if it is on the window's modeline, return ON_MODE_LINE;
715 if it is on the border between the window and its right sibling,
716 return ON_VERTICAL_BORDER.
717 if it is on a scroll bar,
718 return ON_SCROLL_BAR.
719 if it is on the window's top line, return ON_HEADER_LINE;
720 if it is in left or right fringe of the window,
721 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
722 to window-relative coordinates;
723 if it is in the marginal area to the left/right of the window,
724 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
725 to window-relative coordinates.
727 X and Y are frame relative pixel coordinates. */
729 static enum window_part
730 coordinates_in_window (w
, x
, y
)
731 register struct window
*w
;
734 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
735 int left_x
, right_x
, top_y
, bottom_y
;
736 enum window_part part
;
737 int ux
= FRAME_COLUMN_WIDTH (f
);
738 int x0
= WINDOW_LEFT_EDGE_X (w
);
739 int x1
= WINDOW_RIGHT_EDGE_X (w
);
740 /* The width of the area where the vertical line can be dragged.
741 (Between mode lines for instance. */
742 int grabbable_width
= ux
;
743 int lmargin_width
, rmargin_width
, text_left
, text_right
;
745 /* In what's below, we subtract 1 when computing right_x because we
746 want the rightmost pixel, which is given by left_pixel+width-1. */
747 if (w
->pseudo_window_p
)
750 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
751 top_y
= WINDOW_TOP_EDGE_Y (w
);
752 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
756 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
757 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
758 top_y
= WINDOW_TOP_EDGE_Y (w
);
759 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
762 /* Outside any interesting row? */
763 if (*y
< top_y
|| *y
>= bottom_y
)
766 /* On the mode line or header line? If it's near the start of
767 the mode or header line of window that's has a horizontal
768 sibling, say it's on the vertical line. That's to be able
769 to resize windows horizontally in case we're using toolkit
772 if (WINDOW_WANTS_MODELINE_P (w
)
773 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
777 header_vertical_border_check
:
778 /* We're somewhere on the mode line. We consider the place
779 between mode lines of horizontally adjacent mode lines
780 as the vertical border. If scroll bars on the left,
781 return the right window. */
782 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
783 || WINDOW_RIGHTMOST_P (w
))
785 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
787 /* Convert X and Y to window relative coordinates.
788 Vertical border is at the left edge of window. */
789 *x
= max (0, *x
- x0
);
791 return ON_VERTICAL_BORDER
;
796 if (abs (*x
- x1
) < grabbable_width
)
798 /* Convert X and Y to window relative coordinates.
799 Vertical border is at the right edge of window. */
800 *x
= min (x1
, *x
) - x0
;
802 return ON_VERTICAL_BORDER
;
806 if (*x
< x0
|| *x
>= x1
)
809 /* Convert X and Y to window relative coordinates.
810 Mode line starts at left edge of window. */
816 if (WINDOW_WANTS_HEADER_LINE_P (w
)
817 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
819 part
= ON_HEADER_LINE
;
820 goto header_vertical_border_check
;
823 if (*x
< x0
|| *x
>= x1
)
826 /* Outside any interesting column? */
827 if (*x
< left_x
|| *x
> right_x
)
830 return ON_SCROLL_BAR
;
833 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
834 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
836 text_left
= window_box_left (w
, TEXT_AREA
);
837 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
839 if (FRAME_WINDOW_P (f
))
841 if (!w
->pseudo_window_p
842 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
843 && !WINDOW_RIGHTMOST_P (w
)
844 && (abs (*x
- right_x
) < grabbable_width
))
846 /* Convert X and Y to window relative coordinates.
847 Vertical border is at the right edge of window. */
848 *x
= min (right_x
, *x
) - left_x
;
850 return ON_VERTICAL_BORDER
;
855 /* Need to say "*x > right_x" rather than >=, since on character
856 terminals, the vertical line's x coordinate is right_x. */
857 if (!w
->pseudo_window_p
858 && !WINDOW_RIGHTMOST_P (w
)
859 && *x
> right_x
- ux
)
861 /* On the border on the right side of the window? Assume that
862 this area begins at RIGHT_X minus a canonical char width. */
863 *x
= min (right_x
, *x
) - left_x
;
865 return ON_VERTICAL_BORDER
;
871 if (lmargin_width
> 0
872 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
873 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
874 : (*x
< left_x
+ lmargin_width
)))
877 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
878 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
880 return ON_LEFT_MARGIN
;
883 /* Convert X and Y to window-relative pixel coordinates. */
886 return ON_LEFT_FRINGE
;
889 if (*x
>= text_right
)
891 if (rmargin_width
> 0
892 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
893 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
894 : (*x
>= right_x
- rmargin_width
)))
896 *x
-= right_x
- rmargin_width
;
897 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
898 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
900 return ON_RIGHT_MARGIN
;
903 /* Convert X and Y to window-relative pixel coordinates. */
904 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
906 return ON_RIGHT_FRINGE
;
909 /* Everything special ruled out - must be on text area */
916 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
917 Scoordinates_in_window_p
, 2, 2, 0,
918 doc
: /* Return non-nil if COORDINATES are in WINDOW.
919 COORDINATES is a cons of the form (X . Y), X and Y being distances
920 measured in characters from the upper-left corner of the frame.
921 \(0 . 0) denotes the character in the upper left corner of the
923 If COORDINATES are in the text portion of WINDOW,
924 the coordinates relative to the window are returned.
925 If they are in the mode line of WINDOW, `mode-line' is returned.
926 If they are in the top mode line of WINDOW, `header-line' is returned.
927 If they are in the left fringe of WINDOW, `left-fringe' is returned.
928 If they are in the right fringe of WINDOW, `right-fringe' is returned.
929 If they are on the border between WINDOW and its right sibling,
930 `vertical-line' is returned.
931 If they are in the windows's left or right marginal areas, `left-margin'\n\
932 or `right-margin' is returned. */)
933 (coordinates
, window
)
934 register Lisp_Object coordinates
, window
;
941 CHECK_WINDOW (window
);
942 w
= XWINDOW (window
);
943 f
= XFRAME (w
->frame
);
944 CHECK_CONS (coordinates
);
945 lx
= Fcar (coordinates
);
946 ly
= Fcdr (coordinates
);
947 CHECK_NUMBER_OR_FLOAT (lx
);
948 CHECK_NUMBER_OR_FLOAT (ly
);
949 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
950 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
952 switch (coordinates_in_window (w
, &x
, &y
))
958 /* X and Y are now window relative pixel coordinates. Convert
959 them to canonical char units before returning them. */
960 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
961 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
966 case ON_VERTICAL_BORDER
:
967 return Qvertical_line
;
975 case ON_RIGHT_FRINGE
:
976 return Qright_fringe
;
981 case ON_RIGHT_MARGIN
:
982 return Qright_margin
;
985 /* Historically we are supposed to return nil in this case. */
994 /* Callback for foreach_window, used in window_from_coordinates.
995 Check if window W contains coordinates specified by USER_DATA which
996 is actually a pointer to a struct check_window_data CW.
998 Check if window W contains coordinates *CW->x and *CW->y. If it
999 does, return W in *CW->window, as Lisp_Object, and return in
1000 *CW->part the part of the window under coordinates *X,*Y. Return
1001 zero from this function to stop iterating over windows. */
1003 struct check_window_data
1005 Lisp_Object
*window
;
1007 enum window_part
*part
;
1011 check_window_containing (w
, user_data
)
1015 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
1016 enum window_part found
;
1019 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
1020 if (found
!= ON_NOTHING
)
1023 XSETWINDOW (*cw
->window
, w
);
1031 /* Find the window containing frame-relative pixel position X/Y and
1032 return it as a Lisp_Object.
1034 If X, Y is on one of the window's special `window_part' elements,
1035 set *PART to the id of that element, and return X and Y converted
1036 to window relative coordinates in WX and WY.
1038 If there is no window under X, Y return nil and leave *PART
1039 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
1041 This function was previously implemented with a loop cycling over
1042 windows with Fnext_window, and starting with the frame's selected
1043 window. It turned out that this doesn't work with an
1044 implementation of next_window using Vwindow_list, because
1045 FRAME_SELECTED_WINDOW (F) is not always contained in the window
1046 tree of F when this function is called asynchronously from
1047 note_mouse_highlight. The original loop didn't terminate in this
1051 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
1054 enum window_part
*part
;
1059 struct check_window_data cw
;
1060 enum window_part dummy
;
1066 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
1067 foreach_window (f
, check_window_containing
, &cw
);
1069 /* If not found above, see if it's in the tool bar window, if a tool
1073 && WINDOWP (f
->tool_bar_window
)
1074 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
1075 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
1079 window
= f
->tool_bar_window
;
1088 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
1089 doc
: /* Return window containing coordinates X and Y on FRAME.
1090 If omitted, FRAME defaults to the currently selected frame.
1091 The top left corner of the frame is considered to be row 0,
1094 Lisp_Object x
, y
, frame
;
1099 frame
= selected_frame
;
1100 CHECK_LIVE_FRAME (frame
);
1103 /* Check that arguments are integers or floats. */
1104 CHECK_NUMBER_OR_FLOAT (x
);
1105 CHECK_NUMBER_OR_FLOAT (y
);
1107 return window_from_coordinates (f
,
1108 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
1109 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1110 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
1111 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
1115 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
1116 doc
: /* Return current value of point in WINDOW.
1117 WINDOW defaults to the selected window.
1119 For a nonselected window, this is the value point would have
1120 if that window were selected.
1122 Note that, when WINDOW is the selected window and its buffer
1123 is also currently selected, the value returned is the same as (point).
1124 It would be more strictly correct to return the `top-level' value
1125 of point, outside of any save-excursion forms.
1126 But that is hard to define. */)
1130 register struct window
*w
= decode_window (window
);
1132 if (w
== XWINDOW (selected_window
)
1133 && current_buffer
== XBUFFER (w
->buffer
))
1135 return Fmarker_position (w
->pointm
);
1138 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1139 doc
: /* Return position at which display currently starts in WINDOW.
1140 WINDOW defaults to the selected window.
1141 This is updated by redisplay or by calling `set-window-start'. */)
1145 return Fmarker_position (decode_window (window
)->start
);
1148 /* This is text temporarily removed from the doc string below.
1150 This function returns nil if the position is not currently known.
1151 That happens when redisplay is preempted and doesn't finish.
1152 If in that case you want to compute where the end of the window would
1153 have been if redisplay had finished, do this:
1155 (goto-char (window-start window))
1156 (vertical-motion (1- (window-height window)) window)
1159 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1160 doc
: /* Return position at which display currently ends in WINDOW.
1161 WINDOW defaults to the selected window.
1162 This is updated by redisplay, when it runs to completion.
1163 Simply changing the buffer text or setting `window-start'
1164 does not update this value.
1165 Return nil if there is no recorded value. \(This can happen if the
1166 last redisplay of WINDOW was preempted, and did not finish.)
1167 If UPDATE is non-nil, compute the up-to-date position
1168 if it isn't already recorded. */)
1170 Lisp_Object window
, update
;
1173 struct window
*w
= decode_window (window
);
1181 #if 0 /* This change broke some things. We should make it later. */
1182 /* If we don't know the end position, return nil.
1183 The user can compute it with vertical-motion if he wants to.
1184 It would be nicer to do it automatically,
1185 but that's so slow that it would probably bother people. */
1186 if (NILP (w
->window_end_valid
))
1191 && ! (! NILP (w
->window_end_valid
)
1192 && XFASTINT (w
->last_modified
) >= BUF_MODIFF (b
)
1193 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (b
))
1196 struct text_pos startp
;
1198 struct buffer
*old_buffer
= NULL
;
1200 /* Cannot use Fvertical_motion because that function doesn't
1201 cope with variable-height lines. */
1202 if (b
!= current_buffer
)
1204 old_buffer
= current_buffer
;
1205 set_buffer_internal (b
);
1208 /* In case W->start is out of the range, use something
1209 reasonable. This situation occurred when loading a file with
1210 `-l' containing a call to `rmail' with subsequent other
1211 commands. At the end, W->start happened to be BEG, while
1212 rmail had already narrowed the buffer. */
1213 if (XMARKER (w
->start
)->charpos
< BEGV
)
1214 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1215 else if (XMARKER (w
->start
)->charpos
> ZV
)
1216 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1218 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1220 start_display (&it
, w
, startp
);
1221 move_it_vertically (&it
, window_box_height (w
));
1222 if (it
.current_y
< it
.last_visible_y
)
1223 move_it_past_eol (&it
);
1224 value
= make_number (IT_CHARPOS (it
));
1227 set_buffer_internal (old_buffer
);
1230 XSETINT (value
, BUF_Z (b
) - XFASTINT (w
->window_end_pos
));
1235 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1236 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1239 Lisp_Object window
, pos
;
1241 register struct window
*w
= decode_window (window
);
1243 CHECK_NUMBER_COERCE_MARKER (pos
);
1244 if (w
== XWINDOW (selected_window
)
1245 && XBUFFER (w
->buffer
) == current_buffer
)
1248 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1250 /* We have to make sure that redisplay updates the window to show
1251 the new value of point. */
1252 if (!EQ (window
, selected_window
))
1253 ++windows_or_buffers_changed
;
1258 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1259 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1261 Optional third arg NOFORCE non-nil inhibits next redisplay
1262 from overriding motion of point in order to display at this exact start. */)
1263 (window
, pos
, noforce
)
1264 Lisp_Object window
, pos
, noforce
;
1266 register struct window
*w
= decode_window (window
);
1268 CHECK_NUMBER_COERCE_MARKER (pos
);
1269 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1270 /* this is not right, but much easier than doing what is right. */
1271 w
->start_at_line_beg
= Qnil
;
1273 w
->force_start
= Qt
;
1274 w
->update_mode_line
= Qt
;
1275 XSETFASTINT (w
->last_modified
, 0);
1276 XSETFASTINT (w
->last_overlay_modified
, 0);
1277 if (!EQ (window
, selected_window
))
1278 windows_or_buffers_changed
++;
1283 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1285 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1286 See also `set-window-dedicated-p'. */)
1290 return decode_window (window
)->dedicated
;
1293 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1294 Sset_window_dedicated_p
, 2, 2, 0,
1295 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1296 If it is dedicated, Emacs will not automatically change
1297 which buffer appears in it.
1298 The second argument is the new value for the dedication flag;
1299 non-nil means yes. */)
1301 Lisp_Object window
, arg
;
1303 register struct window
*w
= decode_window (window
);
1307 return w
->dedicated
;
1310 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1312 doc
: /* Return the display-table that WINDOW is using.
1313 WINDOW defaults to the selected window. */)
1317 return decode_window (window
)->display_table
;
1320 /* Get the display table for use on window W. This is either W's
1321 display table or W's buffer's display table. Ignore the specified
1322 tables if they are not valid; if no valid table is specified,
1325 struct Lisp_Char_Table
*
1326 window_display_table (w
)
1329 struct Lisp_Char_Table
*dp
= NULL
;
1331 if (DISP_TABLE_P (w
->display_table
))
1332 dp
= XCHAR_TABLE (w
->display_table
);
1333 else if (BUFFERP (w
->buffer
))
1335 struct buffer
*b
= XBUFFER (w
->buffer
);
1337 if (DISP_TABLE_P (b
->display_table
))
1338 dp
= XCHAR_TABLE (b
->display_table
);
1339 else if (DISP_TABLE_P (Vstandard_display_table
))
1340 dp
= XCHAR_TABLE (Vstandard_display_table
);
1346 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1347 doc
: /* Set WINDOW's display-table to TABLE. */)
1349 register Lisp_Object window
, table
;
1351 register struct window
*w
;
1353 w
= decode_window (window
);
1354 w
->display_table
= table
;
1358 /* Record info on buffer window w is displaying
1359 when it is about to cease to display that buffer. */
1362 register struct window
*w
;
1369 if (b
!= XMARKER (w
->pointm
)->buffer
)
1373 if (w
== XWINDOW (selected_window
)
1374 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1375 /* Do this except when the selected window's buffer
1376 is being removed from some other window. */
1378 /* last_window_start records the start position that this buffer
1379 had in the last window to be disconnected from it.
1380 Now that this statement is unconditional,
1381 it is possible for the buffer to be displayed in the
1382 selected window, while last_window_start reflects another
1383 window which was recently showing the same buffer.
1384 Some people might say that might be a good thing. Let's see. */
1385 b
->last_window_start
= marker_position (w
->start
);
1387 /* Point in the selected window's buffer
1388 is actually stored in that buffer, and the window's pointm isn't used.
1389 So don't clobber point in that buffer. */
1390 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1391 /* This line helps to fix Horsley's testbug.el bug. */
1392 && !(WINDOWP (b
->last_selected_window
)
1393 && w
!= XWINDOW (b
->last_selected_window
)
1394 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1395 temp_set_point_both (b
,
1396 clip_to_bounds (BUF_BEGV (b
),
1397 XMARKER (w
->pointm
)->charpos
,
1399 clip_to_bounds (BUF_BEGV_BYTE (b
),
1400 marker_byte_position (w
->pointm
),
1403 if (WINDOWP (b
->last_selected_window
)
1404 && w
== XWINDOW (b
->last_selected_window
))
1405 b
->last_selected_window
= Qnil
;
1408 /* Put replacement into the window structure in place of old. */
1410 replace_window (old
, replacement
)
1411 Lisp_Object old
, replacement
;
1413 register Lisp_Object tem
;
1414 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1416 /* If OLD is its frame's root_window, then replacement is the new
1417 root_window for that frame. */
1419 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1420 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1422 p
->left_col
= o
->left_col
;
1423 p
->top_line
= o
->top_line
;
1424 p
->total_cols
= o
->total_cols
;
1425 p
->total_lines
= o
->total_lines
;
1426 p
->desired_matrix
= p
->current_matrix
= 0;
1428 bzero (&p
->cursor
, sizeof (p
->cursor
));
1429 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1430 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1431 p
->phys_cursor_type
= -1;
1432 p
->phys_cursor_width
= -1;
1433 p
->must_be_updated_p
= 0;
1434 p
->pseudo_window_p
= 0;
1435 XSETFASTINT (p
->window_end_vpos
, 0);
1436 XSETFASTINT (p
->window_end_pos
, 0);
1437 p
->window_end_valid
= Qnil
;
1438 p
->frozen_window_start_p
= 0;
1439 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1441 p
->next
= tem
= o
->next
;
1443 XWINDOW (tem
)->prev
= replacement
;
1445 p
->prev
= tem
= o
->prev
;
1447 XWINDOW (tem
)->next
= replacement
;
1449 p
->parent
= tem
= o
->parent
;
1452 if (EQ (XWINDOW (tem
)->vchild
, old
))
1453 XWINDOW (tem
)->vchild
= replacement
;
1454 if (EQ (XWINDOW (tem
)->hchild
, old
))
1455 XWINDOW (tem
)->hchild
= replacement
;
1458 /*** Here, if replacement is a vertical combination
1459 and so is its new parent, we should make replacement's
1460 children be children of that parent instead. ***/
1463 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1464 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1466 register Lisp_Object window
;
1468 delete_window (window
);
1470 if (! NILP (Vwindow_configuration_change_hook
)
1471 && ! NILP (Vrun_hooks
))
1472 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1478 delete_window (window
)
1479 register Lisp_Object window
;
1481 register Lisp_Object tem
, parent
, sib
;
1482 register struct window
*p
;
1483 register struct window
*par
;
1486 /* Because this function is called by other C code on non-leaf
1487 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1488 so we can't decode_window here. */
1490 window
= selected_window
;
1492 CHECK_WINDOW (window
);
1493 p
= XWINDOW (window
);
1495 /* It's a no-op to delete an already-deleted window. */
1496 if (NILP (p
->buffer
)
1498 && NILP (p
->vchild
))
1503 error ("Attempt to delete minibuffer or sole ordinary window");
1504 par
= XWINDOW (parent
);
1506 windows_or_buffers_changed
++;
1507 Vwindow_list
= Qnil
;
1508 f
= XFRAME (WINDOW_FRAME (p
));
1509 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1511 /* Are we trying to delete any frame's selected window? */
1513 Lisp_Object swindow
, pwindow
;
1515 /* See if the frame's selected window is either WINDOW
1516 or any subwindow of it, by finding all that window's parents
1517 and comparing each one with WINDOW. */
1518 swindow
= FRAME_SELECTED_WINDOW (f
);
1523 while (!NILP (pwindow
))
1525 if (EQ (window
, pwindow
))
1527 pwindow
= XWINDOW (pwindow
)->parent
;
1530 /* If the window being deleted is not a parent of SWINDOW,
1531 then SWINDOW is ok as the new selected window. */
1532 if (!EQ (window
, pwindow
))
1534 /* Otherwise, try another window for SWINDOW. */
1535 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1537 /* If we get back to the frame's selected window,
1538 it means there was no acceptable alternative,
1539 so we cannot delete. */
1540 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1541 error ("Cannot delete window");
1544 /* If we need to change SWINDOW, do it. */
1545 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1547 /* If we're about to delete the selected window on the
1548 selected frame, then we should use Fselect_window to select
1549 the new window. On the other hand, if we're about to
1550 delete the selected window on any other frame, we shouldn't do
1551 anything but set the frame's selected_window slot. */
1552 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1553 Fselect_window (swindow
, Qnil
);
1555 FRAME_SELECTED_WINDOW (f
) = swindow
;
1559 /* Now we know we can delete this one. */
1560 window_deletion_count
++;
1563 /* tem is null for dummy parent windows
1564 (which have inferiors but not any contents themselves) */
1568 unchain_marker (XMARKER (p
->pointm
));
1569 unchain_marker (XMARKER (p
->start
));
1572 /* Free window glyph matrices. It is sure that they are allocated
1573 again when ADJUST_GLYPHS is called. Block input so that expose
1574 events and other events that access glyph matrices are not
1575 processed while we are changing them. */
1577 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1581 XWINDOW (tem
)->prev
= p
->prev
;
1585 XWINDOW (tem
)->next
= p
->next
;
1587 if (EQ (window
, par
->hchild
))
1588 par
->hchild
= p
->next
;
1589 if (EQ (window
, par
->vchild
))
1590 par
->vchild
= p
->next
;
1592 /* Find one of our siblings to give our space to. */
1596 /* If p gives its space to its next sibling, that sibling needs
1597 to have its top/left side pulled back to where p's is.
1598 set_window_{height,width} will re-position the sibling's
1601 XWINDOW (sib
)->top_line
= p
->top_line
;
1602 XWINDOW (sib
)->left_col
= p
->left_col
;
1605 /* Stretch that sibling. */
1606 if (!NILP (par
->vchild
))
1607 set_window_height (sib
,
1608 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1610 if (!NILP (par
->hchild
))
1611 set_window_width (sib
,
1612 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1615 /* If parent now has only one child,
1616 put the child into the parent's place. */
1620 if (NILP (XWINDOW (tem
)->next
)) {
1621 replace_window (parent
, tem
);
1622 par
= XWINDOW (tem
);
1625 /* Since we may be deleting combination windows, we must make sure that
1626 not only p but all its children have been marked as deleted. */
1627 if (! NILP (p
->hchild
))
1628 delete_all_subwindows (XWINDOW (p
->hchild
));
1629 else if (! NILP (p
->vchild
))
1630 delete_all_subwindows (XWINDOW (p
->vchild
));
1632 /* Mark this window as deleted. */
1633 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1635 if (! NILP (par
->parent
))
1636 par
= XWINDOW (par
->parent
);
1638 /* Check if we have a v/hchild with a v/hchild. In that case remove
1641 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1643 p
= XWINDOW (par
->vchild
);
1644 par
->vchild
= p
->vchild
;
1647 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1649 p
= XWINDOW (par
->hchild
);
1650 par
->hchild
= p
->hchild
;
1658 while (! NILP (tem
)) {
1659 XWINDOW (tem
)->parent
= p
->parent
;
1660 if (NILP (XWINDOW (tem
)->next
))
1662 tem
= XWINDOW (tem
)->next
;
1665 /* The next of the v/hchild we are removing is now the next of the
1666 last child for the v/hchild:
1667 Before v/hchild -> v/hchild -> next1 -> next2
1670 After: v/hchild -> next1 -> next2 -> next3
1672 XWINDOW (tem
)->next
= p
->next
;
1673 if (! NILP (p
->next
))
1674 XWINDOW (p
->next
)->prev
= tem
;
1676 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1680 /* Adjust glyph matrices. */
1687 /***********************************************************************
1689 ***********************************************************************/
1691 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1692 pointer. This is a callback function for foreach_window, used in
1693 function window_list. */
1696 add_window_to_list (w
, user_data
)
1700 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1702 XSETWINDOW (window
, w
);
1703 *list
= Fcons (window
, *list
);
1708 /* Return a list of all windows, for use by next_window. If
1709 Vwindow_list is a list, return that list. Otherwise, build a new
1710 list, cache it in Vwindow_list, and return that. */
1715 if (!CONSP (Vwindow_list
))
1719 Vwindow_list
= Qnil
;
1720 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1722 Lisp_Object args
[2];
1724 /* We are visiting windows in canonical order, and add
1725 new windows at the front of args[1], which means we
1726 have to reverse this list at the end. */
1728 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1729 args
[0] = Vwindow_list
;
1730 args
[1] = Fnreverse (args
[1]);
1731 Vwindow_list
= Fnconc (2, args
);
1735 return Vwindow_list
;
1739 /* Value is non-zero if WINDOW satisfies the constraints given by
1740 OWINDOW, MINIBUF and ALL_FRAMES.
1742 MINIBUF t means WINDOW may be minibuffer windows.
1743 `lambda' means WINDOW may not be a minibuffer window.
1744 a window means a specific minibuffer window
1746 ALL_FRAMES t means search all frames,
1747 nil means search just current frame,
1748 `visible' means search just visible frames,
1749 0 means search visible and iconified frames,
1750 a window means search the frame that window belongs to,
1751 a frame means consider windows on that frame, only. */
1754 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1755 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1757 struct window
*w
= XWINDOW (window
);
1758 struct frame
*f
= XFRAME (w
->frame
);
1759 int candidate_p
= 1;
1761 if (!BUFFERP (w
->buffer
))
1763 else if (MINI_WINDOW_P (w
)
1764 && (EQ (minibuf
, Qlambda
)
1765 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1767 /* If MINIBUF is `lambda' don't consider any mini-windows.
1768 If it is a window, consider only that one. */
1771 else if (EQ (all_frames
, Qt
))
1773 else if (NILP (all_frames
))
1775 xassert (WINDOWP (owindow
));
1776 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1778 else if (EQ (all_frames
, Qvisible
))
1780 FRAME_SAMPLE_VISIBILITY (f
);
1781 candidate_p
= FRAME_VISIBLE_P (f
);
1783 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1785 FRAME_SAMPLE_VISIBILITY (f
);
1786 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1788 else if (WINDOWP (all_frames
))
1789 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1790 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1791 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1792 else if (FRAMEP (all_frames
))
1793 candidate_p
= EQ (all_frames
, w
->frame
);
1799 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1800 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1804 decode_next_window_args (window
, minibuf
, all_frames
)
1805 Lisp_Object
*window
, *minibuf
, *all_frames
;
1808 *window
= selected_window
;
1810 CHECK_LIVE_WINDOW (*window
);
1812 /* MINIBUF nil may or may not include minibuffers. Decide if it
1814 if (NILP (*minibuf
))
1815 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1816 else if (!EQ (*minibuf
, Qt
))
1819 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1820 => count none of them, or a specific minibuffer window (the
1821 active one) to count. */
1823 /* ALL_FRAMES nil doesn't specify which frames to include. */
1824 if (NILP (*all_frames
))
1825 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1826 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1828 else if (EQ (*all_frames
, Qvisible
))
1830 else if (EQ (*all_frames
, make_number (0)))
1832 else if (FRAMEP (*all_frames
))
1834 else if (!EQ (*all_frames
, Qt
))
1837 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1838 search just current frame, `visible' meaning search just visible
1839 frames, 0 meaning search visible and iconified frames, or a
1840 window, meaning search the frame that window belongs to, or a
1841 frame, meaning consider windows on that frame, only. */
1845 /* Return the next or previous window of WINDOW in canonical ordering
1846 of windows. NEXT_P non-zero means return the next window. See the
1847 documentation string of next-window for the meaning of MINIBUF and
1851 next_window (window
, minibuf
, all_frames
, next_p
)
1852 Lisp_Object window
, minibuf
, all_frames
;
1855 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1857 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1858 return the first window on the frame. */
1859 if (FRAMEP (all_frames
)
1860 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1861 return Fframe_first_window (all_frames
);
1867 /* Find WINDOW in the list of all windows. */
1868 list
= Fmemq (window
, window_list ());
1870 /* Scan forward from WINDOW to the end of the window list. */
1872 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1873 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1876 /* Scan from the start of the window list up to WINDOW. */
1878 for (list
= Vwindow_list
;
1879 CONSP (list
) && !EQ (XCAR (list
), window
);
1881 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1885 window
= XCAR (list
);
1889 Lisp_Object candidate
, list
;
1891 /* Scan through the list of windows for candidates. If there are
1892 candidate windows in front of WINDOW, the last one of these
1893 is the one we want. If there are candidates following WINDOW
1894 in the list, again the last one of these is the one we want. */
1896 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1898 if (EQ (XCAR (list
), window
))
1900 if (WINDOWP (candidate
))
1903 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1905 candidate
= XCAR (list
);
1908 if (WINDOWP (candidate
))
1916 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1917 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1918 If omitted, WINDOW defaults to the selected window.
1920 Optional second arg MINIBUF t means count the minibuffer window even
1921 if not active. MINIBUF nil or omitted means count the minibuffer iff
1922 it is active. MINIBUF neither t nor nil means not to count the
1923 minibuffer even if it is active.
1925 Several frames may share a single minibuffer; if the minibuffer
1926 counts, all windows on all frames that share that minibuffer count
1927 too. Therefore, `next-window' can be used to iterate through the
1928 set of windows even when the minibuffer is on another frame. If the
1929 minibuffer does not count, only windows from WINDOW's frame count.
1931 Optional third arg ALL-FRAMES t means include windows on all frames.
1932 ALL-FRAMES nil or omitted means cycle within the frames as specified
1933 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1934 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1935 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1936 Anything else means restrict to WINDOW's frame.
1938 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1939 `next-window' to iterate through the entire cycle of acceptable
1940 windows, eventually ending up back at the window you started with.
1941 `previous-window' traverses the same cycle, in the reverse order. */)
1942 (window
, minibuf
, all_frames
)
1943 Lisp_Object window
, minibuf
, all_frames
;
1945 return next_window (window
, minibuf
, all_frames
, 1);
1949 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1950 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1951 If omitted, WINDOW defaults to the selected window.
1953 Optional second arg MINIBUF t means count the minibuffer window even
1954 if not active. MINIBUF nil or omitted means count the minibuffer iff
1955 it is active. MINIBUF neither t nor nil means not to count the
1956 minibuffer even if it is active.
1958 Several frames may share a single minibuffer; if the minibuffer
1959 counts, all windows on all frames that share that minibuffer count
1960 too. Therefore, `previous-window' can be used to iterate through
1961 the set of windows even when the minibuffer is on another frame. If
1962 the minibuffer does not count, only windows from WINDOW's frame count
1964 Optional third arg ALL-FRAMES t means include windows on all frames.
1965 ALL-FRAMES nil or omitted means cycle within the frames as specified
1966 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1967 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1968 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1969 Anything else means restrict to WINDOW's frame.
1971 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1972 `previous-window' to iterate through the entire cycle of acceptable
1973 windows, eventually ending up back at the window you started with.
1974 `next-window' traverses the same cycle, in the reverse order. */)
1975 (window
, minibuf
, all_frames
)
1976 Lisp_Object window
, minibuf
, all_frames
;
1978 return next_window (window
, minibuf
, all_frames
, 0);
1982 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1983 doc
: /* Select the ARG'th different window on this frame.
1984 All windows on current frame are arranged in a cyclic order.
1985 This command selects the window ARG steps away in that order.
1986 A negative ARG moves in the opposite order. The optional second
1987 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1989 Lisp_Object arg
, all_frames
;
1995 window
= selected_window
;
1997 for (i
= XINT (arg
); i
> 0; --i
)
1998 window
= Fnext_window (window
, Qnil
, all_frames
);
2000 window
= Fprevious_window (window
, Qnil
, all_frames
);
2002 Fselect_window (window
, Qnil
);
2007 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
2008 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
2009 FRAME nil or omitted means use the selected frame.
2010 WINDOW nil or omitted means use the selected window.
2011 MINIBUF t means include the minibuffer window, even if it isn't active.
2012 MINIBUF nil or omitted means include the minibuffer window only
2014 MINIBUF neither nil nor t means never include the minibuffer window. */)
2015 (frame
, minibuf
, window
)
2016 Lisp_Object frame
, minibuf
, window
;
2019 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
2020 CHECK_WINDOW (window
);
2022 frame
= selected_frame
;
2024 if (!EQ (frame
, XWINDOW (window
)->frame
))
2025 error ("Window is on a different frame");
2027 return window_list_1 (window
, minibuf
, frame
);
2031 /* Return a list of windows in canonical ordering. Arguments are like
2032 for `next-window'. */
2035 window_list_1 (window
, minibuf
, all_frames
)
2036 Lisp_Object window
, minibuf
, all_frames
;
2038 Lisp_Object tail
, list
, rest
;
2040 decode_next_window_args (&window
, &minibuf
, &all_frames
);
2043 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
2044 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
2045 list
= Fcons (XCAR (tail
), list
);
2047 /* Rotate the list to start with WINDOW. */
2048 list
= Fnreverse (list
);
2049 rest
= Fmemq (window
, list
);
2050 if (!NILP (rest
) && !EQ (rest
, list
))
2052 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
2054 XSETCDR (tail
, Qnil
);
2055 list
= nconc2 (rest
, list
);
2062 /* Look at all windows, performing an operation specified by TYPE
2064 If FRAMES is Qt, look at all frames;
2065 Qnil, look at just the selected frame;
2066 Qvisible, look at visible frames;
2067 a frame, just look at windows on that frame.
2068 If MINI is non-zero, perform the operation on minibuffer windows too. */
2073 GET_BUFFER_WINDOW
, /* Arg is buffer */
2074 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
2075 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
2076 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
2078 UNSHOW_BUFFER
, /* Arg is buffer */
2079 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
2084 window_loop (type
, obj
, mini
, frames
)
2085 enum window_loop type
;
2086 Lisp_Object obj
, frames
;
2089 Lisp_Object window
, windows
, best_window
, frame_arg
;
2091 struct gcpro gcpro1
;
2093 /* If we're only looping through windows on a particular frame,
2094 frame points to that frame. If we're looping through windows
2095 on all frames, frame is 0. */
2096 if (FRAMEP (frames
))
2097 f
= XFRAME (frames
);
2098 else if (NILP (frames
))
2099 f
= SELECTED_FRAME ();
2104 frame_arg
= Qlambda
;
2105 else if (EQ (frames
, make_number (0)))
2107 else if (EQ (frames
, Qvisible
))
2112 /* frame_arg is Qlambda to stick to one frame,
2113 Qvisible to consider all visible frames,
2116 /* Pick a window to start with. */
2120 window
= FRAME_SELECTED_WINDOW (f
);
2122 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
2124 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2128 for (; CONSP (windows
); windows
= XCDR (windows
))
2132 window
= XCAR (windows
);
2133 w
= XWINDOW (window
);
2135 /* Note that we do not pay attention here to whether the frame
2136 is visible, since Fwindow_list skips non-visible frames if
2137 that is desired, under the control of frame_arg. */
2138 if (!MINI_WINDOW_P (w
)
2139 /* For UNSHOW_BUFFER, we must always consider all windows. */
2140 || type
== UNSHOW_BUFFER
2141 || (mini
&& minibuf_level
> 0))
2144 case GET_BUFFER_WINDOW
:
2145 if (EQ (w
->buffer
, obj
)
2146 /* Don't find any minibuffer window
2147 except the one that is currently in use. */
2148 && (MINI_WINDOW_P (w
)
2149 ? EQ (window
, minibuf_window
)
2152 if (NILP (best_window
))
2153 best_window
= window
;
2154 else if (EQ (window
, selected_window
))
2155 /* For compatibility with 20.x, prefer to return
2157 best_window
= window
;
2161 case GET_LRU_WINDOW
:
2162 /* `obj' is an integer encoding a bitvector.
2163 `obj & 1' means consider only full-width windows.
2164 `obj & 2' means consider also dedicated windows. */
2165 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2166 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2167 /* Minibuffer windows are always ignored. */
2168 || MINI_WINDOW_P (w
))
2170 if (NILP (best_window
)
2171 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2172 > XFASTINT (w
->use_time
)))
2173 best_window
= window
;
2176 case DELETE_OTHER_WINDOWS
:
2177 if (!EQ (window
, obj
))
2178 Fdelete_window (window
);
2181 case DELETE_BUFFER_WINDOWS
:
2182 if (EQ (w
->buffer
, obj
))
2184 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2186 /* If this window is dedicated, and in a frame of its own,
2188 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2189 && !NILP (w
->dedicated
)
2190 && other_visible_frames (f
))
2192 /* Skip the other windows on this frame.
2193 There might be one, the minibuffer! */
2194 while (CONSP (XCDR (windows
))
2195 && EQ (XWINDOW (XCAR (windows
))->frame
,
2196 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2197 windows
= XCDR (windows
);
2199 /* Now we can safely delete the frame. */
2200 Fdelete_frame (w
->frame
, Qnil
);
2202 else if (NILP (w
->parent
))
2204 /* If we're deleting the buffer displayed in the
2205 only window on the frame, find a new buffer to
2208 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2209 Fset_window_buffer (window
, buffer
, Qnil
);
2210 if (EQ (window
, selected_window
))
2211 Fset_buffer (w
->buffer
);
2214 Fdelete_window (window
);
2218 case GET_LARGEST_WINDOW
:
2219 { /* nil `obj' means to ignore dedicated windows. */
2220 /* Ignore dedicated windows and minibuffers. */
2221 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2224 if (NILP (best_window
))
2225 best_window
= window
;
2228 struct window
*b
= XWINDOW (best_window
);
2229 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2230 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2231 best_window
= window
;
2237 if (EQ (w
->buffer
, obj
))
2240 struct frame
*f
= XFRAME (w
->frame
);
2242 /* Find another buffer to show in this window. */
2243 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2245 /* If this window is dedicated, and in a frame of its own,
2247 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2248 && !NILP (w
->dedicated
)
2249 && other_visible_frames (f
))
2251 /* Skip the other windows on this frame.
2252 There might be one, the minibuffer! */
2253 while (CONSP (XCDR (windows
))
2254 && EQ (XWINDOW (XCAR (windows
))->frame
,
2255 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2256 windows
= XCDR (windows
);
2258 /* Now we can safely delete the frame. */
2259 Fdelete_frame (w
->frame
, Qnil
);
2261 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2264 XSETWINDOW (window
, w
);
2265 /* If this window is dedicated and not the only window
2266 in its frame, then kill it. */
2267 Fdelete_window (window
);
2271 /* Otherwise show a different buffer in the window. */
2272 w
->dedicated
= Qnil
;
2273 Fset_window_buffer (window
, buffer
, Qnil
);
2274 if (EQ (window
, selected_window
))
2275 Fset_buffer (w
->buffer
);
2280 case REDISPLAY_BUFFER_WINDOWS
:
2281 if (EQ (w
->buffer
, obj
))
2283 mark_window_display_accurate (window
, 0);
2284 w
->update_mode_line
= Qt
;
2285 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2286 ++update_mode_lines
;
2287 best_window
= window
;
2291 /* Check for a window that has a killed buffer. */
2292 case CHECK_ALL_WINDOWS
:
2293 if (! NILP (w
->buffer
)
2294 && NILP (XBUFFER (w
->buffer
)->name
))
2298 case WINDOW_LOOP_UNUSED
:
2307 /* Used for debugging. Abort if any window has a dead buffer. */
2310 check_all_windows ()
2312 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2315 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2316 doc
: /* Return the window least recently selected or used for display.
2317 Return a full-width window if possible.
2318 A minibuffer window is never a candidate.
2319 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2320 so if all windows are dedicated, the value is nil.
2321 If optional argument FRAME is `visible', search all visible frames.
2322 If FRAME is 0, search all visible and iconified frames.
2323 If FRAME is t, search all frames.
2324 If FRAME is nil, search only the selected frame.
2325 If FRAME is a frame, search only that frame. */)
2327 Lisp_Object frame
, dedicated
;
2329 register Lisp_Object w
;
2330 /* First try for a window that is full-width */
2331 w
= window_loop (GET_LRU_WINDOW
,
2332 NILP (dedicated
) ? make_number (1) : make_number (3),
2334 if (!NILP (w
) && !EQ (w
, selected_window
))
2336 /* If none of them, try the rest */
2337 return window_loop (GET_LRU_WINDOW
,
2338 NILP (dedicated
) ? make_number (0) : make_number (2),
2342 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2343 doc
: /* Return the largest window in area.
2344 A minibuffer window is never a candidate.
2345 A dedicated window is never a candidate unless DEDICATED is non-nil,
2346 so if all windows are dedicated, the value is nil.
2347 If optional argument FRAME is `visible', search all visible frames.
2348 If FRAME is 0, search all visible and iconified frames.
2349 If FRAME is t, search all frames.
2350 If FRAME is nil, search only the selected frame.
2351 If FRAME is a frame, search only that frame. */)
2353 Lisp_Object frame
, dedicated
;
2355 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2359 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2360 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2361 BUFFER can be a buffer or a buffer name.
2362 If optional argument FRAME is `visible', search all visible frames.
2363 If optional argument FRAME is 0, search all visible and iconified frames.
2364 If FRAME is t, search all frames.
2365 If FRAME is nil, search only the selected frame.
2366 If FRAME is a frame, search only that frame. */)
2368 Lisp_Object buffer
, frame
;
2370 buffer
= Fget_buffer (buffer
);
2371 if (BUFFERP (buffer
))
2372 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2377 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2379 doc
: /* Make WINDOW (or the selected window) fill its frame.
2380 Only the frame WINDOW is on is affected.
2381 This function tries to reduce display jumps
2382 by keeping the text previously visible in WINDOW
2383 in the same place on the frame. Doing this depends on
2384 the value of (window-start WINDOW), so if calling this function
2385 in a program gives strange scrolling, make sure the window-start
2386 value is reasonable when this function is called. */)
2395 window
= selected_window
;
2397 CHECK_LIVE_WINDOW (window
);
2398 w
= XWINDOW (window
);
2400 startpos
= marker_position (w
->start
);
2401 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2403 if (MINI_WINDOW_P (w
) && top
> 0)
2404 error ("Can't expand minibuffer to full frame");
2406 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2408 /* Try to minimize scrolling, by setting the window start to the point
2409 will cause the text at the old window start to be at the same place
2410 on the frame. But don't try to do this if the window start is
2411 outside the visible portion (as might happen when the display is
2412 not current, due to typeahead). */
2413 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2415 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2416 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2418 struct position pos
;
2419 struct buffer
*obuf
= current_buffer
;
2421 Fset_buffer (w
->buffer
);
2422 /* This computation used to temporarily move point, but that can
2423 have unwanted side effects due to text properties. */
2424 pos
= *vmotion (startpos
, -top
, w
);
2426 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2427 w
->window_end_valid
= Qnil
;
2428 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2429 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2431 /* We need to do this, so that the window-scroll-functions
2433 w
->optional_new_start
= Qt
;
2435 set_buffer_internal (obuf
);
2441 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2442 1, 2, "bDelete windows on (buffer): ",
2443 doc
: /* Delete all windows showing BUFFER.
2444 BUFFER must be a buffer or the name of an existing buffer.
2445 Optional second argument FRAME controls which frames are affected.
2446 If optional argument FRAME is `visible', search all visible frames.
2447 If FRAME is 0, search all visible and iconified frames.
2448 If FRAME is nil, search all frames.
2449 If FRAME is t, search only the selected frame.
2450 If FRAME is a frame, search only that frame. */)
2452 Lisp_Object buffer
, frame
;
2454 /* FRAME uses t and nil to mean the opposite of what window_loop
2458 else if (EQ (frame
, Qt
))
2463 buffer
= Fget_buffer (buffer
);
2464 CHECK_BUFFER (buffer
);
2465 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2471 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2472 Sreplace_buffer_in_windows
,
2473 1, 1, "bReplace buffer in windows: ",
2474 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2475 BUFFER may be a buffer or the name of an existing buffer. */)
2481 buffer
= Fget_buffer (buffer
);
2482 CHECK_BUFFER (buffer
);
2483 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2488 /* Replace BUFFER with some other buffer in all windows
2489 of all frames, even those on other keyboards. */
2492 replace_buffer_in_all_windows (buffer
)
2496 Lisp_Object tail
, frame
;
2498 /* A single call to window_loop won't do the job
2499 because it only considers frames on the current keyboard.
2500 So loop manually over frames, and handle each one. */
2501 FOR_EACH_FRAME (tail
, frame
)
2502 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2504 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2508 /* Set the height of WINDOW and all its inferiors. */
2510 /* The smallest acceptable dimensions for a window. Anything smaller
2511 might crash Emacs. */
2513 #define MIN_SAFE_WINDOW_WIDTH (2)
2514 #define MIN_SAFE_WINDOW_HEIGHT (1)
2516 /* Make sure that window_min_height and window_min_width are
2517 not too small; if they are, set them to safe minima. */
2520 check_min_window_sizes ()
2522 /* Smaller values might permit a crash. */
2523 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2524 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2525 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2526 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2529 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2530 minimum allowable size. */
2533 check_frame_size (frame
, rows
, cols
)
2537 /* For height, we have to see:
2538 how many windows the frame has at minimum (one or two),
2539 and whether it has a menu bar or other special stuff at the top. */
2541 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2542 ? MIN_SAFE_WINDOW_HEIGHT
2543 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2545 if (FRAME_TOP_MARGIN (frame
) > 0)
2546 min_height
+= FRAME_TOP_MARGIN (frame
);
2548 if (*rows
< min_height
)
2550 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2551 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2555 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2556 check if W's width can be changed, otherwise check W's height.
2557 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2558 siblings, too. If none of the siblings is resizable, WINDOW isn't
2562 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2564 int width_p
, check_siblings_p
;
2569 if (!NILP (w
->hchild
))
2571 c
= XWINDOW (w
->hchild
);
2575 /* A horiz. combination is fixed-width if all of if its
2577 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2578 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2579 fixed_p
= c
== NULL
;
2583 /* A horiz. combination is fixed-height if one of if its
2585 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2586 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2587 fixed_p
= c
!= NULL
;
2590 else if (!NILP (w
->vchild
))
2592 c
= XWINDOW (w
->vchild
);
2596 /* A vert. combination is fixed-width if one of if its
2598 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2599 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2600 fixed_p
= c
!= NULL
;
2604 /* A vert. combination is fixed-height if all of if its
2606 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2607 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2608 fixed_p
= c
== NULL
;
2611 else if (BUFFERP (w
->buffer
))
2613 struct buffer
*old
= current_buffer
;
2616 current_buffer
= XBUFFER (w
->buffer
);
2617 val
= find_symbol_value (Qwindow_size_fixed
);
2618 current_buffer
= old
;
2621 if (!EQ (val
, Qunbound
))
2623 fixed_p
= !NILP (val
);
2626 && ((EQ (val
, Qheight
) && width_p
)
2627 || (EQ (val
, Qwidth
) && !width_p
)))
2631 /* Can't tell if this one is resizable without looking at
2632 siblings. If all siblings are fixed-size this one is too. */
2633 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2637 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2638 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2642 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2643 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2657 /* Return the minimum size of window W, not taking fixed-width windows
2658 into account. WIDTH_P non-zero means return the minimum width,
2659 otherwise return the minimum height. If W is a combination window,
2660 compute the minimum size from the minimum sizes of W's children. */
2663 window_min_size_1 (w
, width_p
)
2670 if (!NILP (w
->hchild
))
2672 c
= XWINDOW (w
->hchild
);
2677 /* The min width of a horizontal combination is
2678 the sum of the min widths of its children. */
2681 size
+= window_min_size_1 (c
, width_p
);
2682 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2687 /* The min height a horizontal combination equals
2688 the maximum of all min height of its children. */
2691 int min_size
= window_min_size_1 (c
, width_p
);
2692 size
= max (min_size
, size
);
2693 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2697 else if (!NILP (w
->vchild
))
2699 c
= XWINDOW (w
->vchild
);
2704 /* The min width of a vertical combination is
2705 the maximum of the min widths of its children. */
2708 int min_size
= window_min_size_1 (c
, width_p
);
2709 size
= max (min_size
, size
);
2710 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2715 /* The min height of a vertical combination equals
2716 the sum of the min height of its children. */
2719 size
+= window_min_size_1 (c
, width_p
);
2720 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2727 size
= max (window_min_width
,
2728 (MIN_SAFE_WINDOW_WIDTH
2729 + WINDOW_FRINGE_COLS (w
)
2730 + WINDOW_SCROLL_BAR_COLS (w
)));
2733 if (MINI_WINDOW_P (w
)
2734 || (!WINDOW_WANTS_MODELINE_P (w
)
2735 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2738 size
= window_min_height
;
2746 /* Return the minimum size of window W, taking fixed-size windows into
2747 account. WIDTH_P non-zero means return the minimum width,
2748 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2749 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2750 unless FIXED is null. */
2753 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2755 int width_p
, ignore_fixed_p
, *fixed
;
2762 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2768 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2770 size
= window_min_size_1 (w
, width_p
);
2776 /* Adjust the margins of window W if text area is too small.
2777 Return 1 if window width is ok after adjustment; 0 if window
2778 is still too narrow. */
2781 adjust_window_margins (w
)
2784 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2785 - WINDOW_FRINGE_COLS (w
)
2786 - WINDOW_SCROLL_BAR_COLS (w
));
2787 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2788 + WINDOW_RIGHT_MARGIN_COLS (w
));
2790 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2793 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2796 /* Window's text area is too narrow, but reducing the window
2797 margins will fix that. */
2798 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2799 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2801 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2802 w
->left_margin_cols
= w
->right_margin_cols
2803 = make_number (margin_cols
/2);
2805 w
->right_margin_cols
= make_number (margin_cols
);
2808 w
->left_margin_cols
= make_number (margin_cols
);
2812 /* Calculate new sizes for windows in the list FORWARD when the window size
2813 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2814 The number of windows in FORWARD is NCHILDREN, and the number that
2815 can shrink is SHRINKABLE.
2816 The minimum size a window can have is MIN_SIZE.
2817 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2818 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2821 This function returns an allocated array of new sizes that the caller
2822 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2823 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2824 the second, and so on.
2826 This function tries to keep windows at least at the minimum size
2827 and resize other windows before it resizes any window to zero (i.e.
2828 delete that window).
2830 Windows are resized proportional to their size, so bigger windows
2831 shrink more than smaller windows. */
2833 shrink_windows (total
, size
, nchildren
, shrinkable
,
2834 min_size
, resize_fixed_p
, forward
, width_p
)
2835 int total
, size
, nchildren
, shrinkable
, min_size
;
2836 int resize_fixed_p
, width_p
;
2837 Lisp_Object forward
;
2839 int available_resize
= 0;
2843 int smallest
= total
;
2844 int total_removed
= 0;
2845 int total_shrink
= total
- size
;
2848 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2850 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2854 c
= XWINDOW (child
);
2855 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2857 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2861 new_sizes
[i
] = child_size
;
2862 if (child_size
> min_size
)
2863 available_resize
+= child_size
- min_size
;
2866 /* We might need to shrink some windows to zero. Find the smallest
2867 windows and set them to 0 until we can fulfil the new size. */
2869 while (shrinkable
> 1 && size
+ available_resize
< total
)
2871 for (i
= 0; i
< nchildren
; ++i
)
2872 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2873 smallest
= new_sizes
[i
];
2875 for (i
= 0; i
< nchildren
; ++i
)
2876 if (new_sizes
[i
] == smallest
)
2878 /* Resize this window down to zero. */
2880 if (smallest
> min_size
)
2881 available_resize
-= smallest
- min_size
;
2882 available_resize
+= smallest
;
2884 total_removed
+= smallest
;
2886 /* We don't know what the smallest is now. */
2889 /* Out of for, just remove one window at the time and
2890 check again if we have enough space. */
2895 /* Now, calculate the new sizes. Try to shrink each window
2896 proportional to its size. */
2897 for (i
= 0; i
< nchildren
; ++i
)
2899 if (new_sizes
[i
] > min_size
)
2901 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2902 if (new_sizes
[i
] - to_shrink
< min_size
)
2903 to_shrink
= new_sizes
[i
] - min_size
;
2904 new_sizes
[i
] -= to_shrink
;
2905 total_removed
+= to_shrink
;
2909 /* Any reminder due to rounding, we just subtract from windows
2910 that are left and still can be shrunk. */
2911 while (total_shrink
> total_removed
)
2913 int nonzero_sizes
= 0;
2914 int nonzero_idx
= -1;
2916 for (i
= 0; i
< nchildren
; ++i
)
2917 if (new_sizes
[i
] > 0)
2923 for (i
= 0; i
< nchildren
; ++i
)
2924 if (new_sizes
[i
] > min_size
)
2929 /* Out of for, just shrink one window at the time and
2930 check again if we have enough space. */
2935 /* Special case, only one window left. */
2936 if (nonzero_sizes
== 1)
2940 /* Any surplus due to rounding, we add to windows that are left. */
2941 while (total_shrink
< total_removed
)
2943 for (i
= 0; i
< nchildren
; ++i
)
2945 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2957 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2958 WINDOW's width. Resize WINDOW's children, if any, so that they
2959 keep their proportionate size relative to WINDOW.
2961 If FIRST_ONLY is 1, change only the first of WINDOW's children when
2962 they are in series. If LAST_ONLY is 1, change only the last of
2963 WINDOW's children when they are in series.
2965 Propagate WINDOW's top or left edge position to children. Delete
2966 windows that become too small unless NODELETE_P is non-zero.
2968 If NODELETE_P is 2, that means we do delete windows that are
2969 too small, even if they were too small before! */
2972 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
2974 int size
, width_p
, nodelete_p
;
2975 int first_only
, last_only
;
2977 struct window
*w
= XWINDOW (window
);
2979 Lisp_Object child
, *forward
, *sideward
;
2980 int old_size
, min_size
, safe_min_size
;
2982 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2983 seems like it's too soon to do this here. ++KFS. */
2984 if (nodelete_p
== 2)
2987 check_min_window_sizes ();
2988 size
= max (0, size
);
2990 /* If the window has been "too small" at one point,
2991 don't delete it for being "too small" in the future.
2992 Preserve it as long as that is at all possible. */
2995 old_size
= WINDOW_TOTAL_COLS (w
);
2996 min_size
= window_min_width
;
2997 /* Ensure that there is room for the scroll bar and fringes!
2998 We may reduce display margins though. */
2999 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
3000 + WINDOW_FRINGE_COLS (w
)
3001 + WINDOW_SCROLL_BAR_COLS (w
));
3005 old_size
= XINT (w
->total_lines
);
3006 min_size
= window_min_height
;
3007 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
3010 if (old_size
< min_size
&& nodelete_p
!= 2)
3011 w
->too_small_ok
= Qt
;
3013 /* Maybe delete WINDOW if it's too small. */
3014 if (nodelete_p
!= 1 && !NILP (w
->parent
))
3016 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
3017 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
3018 if (min_size
< safe_min_size
)
3019 min_size
= safe_min_size
;
3020 if (size
< min_size
)
3022 delete_window (window
);
3027 /* Set redisplay hints. */
3028 w
->last_modified
= make_number (0);
3029 w
->last_overlay_modified
= make_number (0);
3030 windows_or_buffers_changed
++;
3031 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
3035 sideward
= &w
->vchild
;
3036 forward
= &w
->hchild
;
3037 w
->total_cols
= make_number (size
);
3038 adjust_window_margins (w
);
3042 sideward
= &w
->hchild
;
3043 forward
= &w
->vchild
;
3044 w
->total_lines
= make_number (size
);
3045 w
->orig_total_lines
= Qnil
;
3048 if (!NILP (*sideward
))
3050 /* We have a chain of parallel siblings whose size should all change. */
3051 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
3053 c
= XWINDOW (child
);
3055 c
->left_col
= w
->left_col
;
3057 c
->top_line
= w
->top_line
;
3058 size_window (child
, size
, width_p
, nodelete_p
,
3059 first_only
, last_only
);
3062 else if (!NILP (*forward
) && last_only
)
3064 /* Change the last in a series of siblings. */
3065 Lisp_Object last_child
;
3068 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3070 c
= XWINDOW (child
);
3074 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3075 size_window (last_child
,
3076 size
- old_size
+ child_size
,
3077 width_p
, nodelete_p
, first_only
, last_only
);
3079 else if (!NILP (*forward
) && first_only
)
3081 /* Change the first in a series of siblings. */
3085 c
= XWINDOW (child
);
3088 c
->left_col
= w
->left_col
;
3090 c
->top_line
= w
->top_line
;
3092 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
3094 size
- old_size
+ child_size
,
3095 width_p
, nodelete_p
, first_only
, last_only
);
3097 else if (!NILP (*forward
))
3099 int fixed_size
, each
, extra
, n
;
3100 int resize_fixed_p
, nfixed
;
3101 int last_pos
, first_pos
, nchildren
, total
;
3102 int *new_sizes
= NULL
;
3104 /* Determine the fixed-size portion of this window, and the
3105 number of child windows. */
3106 fixed_size
= nchildren
= nfixed
= total
= 0;
3107 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
3111 c
= XWINDOW (child
);
3112 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3113 total
+= child_size
;
3115 if (window_fixed_size_p (c
, width_p
, 0))
3117 fixed_size
+= child_size
;
3122 /* If the new size is smaller than fixed_size, or if there
3123 aren't any resizable windows, allow resizing fixed-size
3125 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
3127 /* Compute how many lines/columns to add/remove to each child. The
3128 value of extra takes care of rounding errors. */
3129 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3130 if (size
< total
&& n
> 1)
3131 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
3132 resize_fixed_p
, *forward
, width_p
);
3135 each
= (size
- total
) / n
;
3136 extra
= (size
- total
) - n
* each
;
3139 /* Compute new children heights and edge positions. */
3140 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3141 last_pos
= first_pos
;
3142 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3144 int new_size
, old_size
;
3146 c
= XWINDOW (child
);
3147 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
3148 new_size
= old_size
;
3150 /* The top or left edge position of this child equals the
3151 bottom or right edge of its predecessor. */
3153 c
->left_col
= make_number (last_pos
);
3155 c
->top_line
= make_number (last_pos
);
3157 /* If this child can be resized, do it. */
3158 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3160 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3164 /* Set new height. Note that size_window also propagates
3165 edge positions to children, so it's not a no-op if we
3166 didn't change the child's size. */
3167 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3169 /* Remember the bottom/right edge position of this child; it
3170 will be used to set the top/left edge of the next child. */
3171 last_pos
+= new_size
;
3174 if (new_sizes
) xfree (new_sizes
);
3176 /* We should have covered the parent exactly with child windows. */
3177 xassert (size
== last_pos
- first_pos
);
3179 /* Now delete any children that became too small. */
3181 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3184 c
= XWINDOW (child
);
3185 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3186 size_window (child
, child_size
, width_p
, 2, first_only
, last_only
);
3191 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3192 WINDOW's children. NODELETE non-zero means don't delete windows
3193 that become too small in the process. (The caller should check
3194 later and do so if appropriate.) */
3197 set_window_height (window
, height
, nodelete
)
3202 size_window (window
, height
, 0, nodelete
, 0, 0);
3206 /* Set WINDOW's width to WIDTH, and recursively change the width of
3207 WINDOW's children. NODELETE non-zero means don't delete windows
3208 that become too small in the process. (The caller should check
3209 later and do so if appropriate.) */
3212 set_window_width (window
, width
, nodelete
)
3217 size_window (window
, width
, 1, nodelete
, 0, 0);
3220 /* Change window heights in windows rooted in WINDOW by N lines. */
3223 change_window_heights (window
, n
)
3227 struct window
*w
= XWINDOW (window
);
3229 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3230 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3232 if (INTEGERP (w
->orig_top_line
))
3233 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3234 if (INTEGERP (w
->orig_total_lines
))
3235 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3237 /* Handle just the top child in a vertical split. */
3238 if (!NILP (w
->vchild
))
3239 change_window_heights (w
->vchild
, n
);
3241 /* Adjust all children in a horizontal split. */
3242 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3244 w
= XWINDOW (window
);
3245 change_window_heights (window
, n
);
3250 int window_select_count
;
3253 Fset_window_buffer_unwind (obuf
)
3260 EXFUN (Fset_window_fringes
, 4);
3261 EXFUN (Fset_window_scroll_bars
, 4);
3263 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3264 means it's allowed to run hooks. See make_frame for a case where
3265 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3266 margins, fringes, and scroll-bar settings of the window are not
3267 reset from the buffer's local settings. */
3270 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3271 Lisp_Object window
, buffer
;
3272 int run_hooks_p
, keep_margins_p
;
3274 struct window
*w
= XWINDOW (window
);
3275 struct buffer
*b
= XBUFFER (buffer
);
3276 int count
= SPECPDL_INDEX ();
3280 if (EQ (window
, selected_window
))
3281 b
->last_selected_window
= window
;
3283 /* Let redisplay errors through. */
3284 b
->display_error_modiff
= 0;
3286 /* Update time stamps of buffer display. */
3287 if (INTEGERP (b
->display_count
))
3288 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3289 b
->display_time
= Fcurrent_time ();
3291 XSETFASTINT (w
->window_end_pos
, 0);
3292 XSETFASTINT (w
->window_end_vpos
, 0);
3293 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3294 w
->window_end_valid
= Qnil
;
3295 w
->hscroll
= w
->min_hscroll
= make_number (0);
3297 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3298 set_marker_restricted (w
->start
,
3299 make_number (b
->last_window_start
),
3301 w
->start_at_line_beg
= Qnil
;
3302 w
->force_start
= Qnil
;
3303 XSETFASTINT (w
->last_modified
, 0);
3304 XSETFASTINT (w
->last_overlay_modified
, 0);
3305 windows_or_buffers_changed
++;
3307 /* We must select BUFFER for running the window-scroll-functions.
3308 If WINDOW is selected, switch permanently.
3309 Otherwise, switch but go back to the ambient buffer afterward. */
3310 if (EQ (window
, selected_window
))
3311 Fset_buffer (buffer
);
3312 /* We can't check ! NILP (Vwindow_scroll_functions) here
3313 because that might itself be a local variable. */
3314 else if (window_initialized
)
3316 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3317 Fset_buffer (buffer
);
3320 if (!keep_margins_p
)
3322 /* Set left and right marginal area width etc. from buffer. */
3324 /* This may call adjust_window_margins three times, so
3325 temporarily disable window margins. */
3326 Lisp_Object save_left
= w
->left_margin_cols
;
3327 Lisp_Object save_right
= w
->right_margin_cols
;
3329 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3331 Fset_window_fringes (window
,
3332 b
->left_fringe_width
, b
->right_fringe_width
,
3333 b
->fringes_outside_margins
);
3335 Fset_window_scroll_bars (window
,
3336 b
->scroll_bar_width
,
3337 b
->vertical_scroll_bar_type
, Qnil
);
3339 w
->left_margin_cols
= save_left
;
3340 w
->right_margin_cols
= save_right
;
3342 Fset_window_margins (window
,
3343 b
->left_margin_cols
, b
->right_margin_cols
);
3348 if (! NILP (Vwindow_scroll_functions
))
3349 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3350 Fmarker_position (w
->start
));
3352 if (! NILP (Vwindow_configuration_change_hook
)
3353 && ! NILP (Vrun_hooks
))
3354 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3357 unbind_to (count
, Qnil
);
3361 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3362 doc
: /* Make WINDOW display BUFFER as its contents.
3363 BUFFER can be a buffer or the name of an existing buffer.
3364 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3365 display margins, fringe widths, and scroll bar settings are maintained;
3366 the default is to reset these from BUFFER's local settings or the frame
3369 This function runs the hook `window-scroll-functions'. */)
3370 (window
, buffer
, keep_margins
)
3371 register Lisp_Object window
, buffer
, keep_margins
;
3373 register Lisp_Object tem
;
3374 register struct window
*w
= decode_window (window
);
3376 XSETWINDOW (window
, w
);
3377 buffer
= Fget_buffer (buffer
);
3378 CHECK_BUFFER (buffer
);
3380 if (NILP (XBUFFER (buffer
)->name
))
3381 error ("Attempt to display deleted buffer");
3385 error ("Window is deleted");
3386 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3387 is first being set up. */
3389 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3390 error ("Window is dedicated to `%s'",
3391 SDATA (XBUFFER (tem
)->name
));
3396 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3400 /* Note that selected_window can be nil
3401 when this is called from Fset_window_configuration. */
3403 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3404 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3405 If WINDOW is not already selected, make WINDOW's buffer current
3406 and make WINDOW the frame's selected window. Return WINDOW.
3407 Optional second arg NORECORD non-nil means
3408 do not put this buffer at the front of the list of recently selected ones.
3410 Note that the main editor command loop
3411 selects the buffer of the selected window before each command. */)
3413 register Lisp_Object window
, norecord
;
3415 register struct window
*w
;
3416 register struct window
*ow
;
3419 CHECK_LIVE_WINDOW (window
);
3421 w
= XWINDOW (window
);
3422 w
->frozen_window_start_p
= 0;
3424 ++window_select_count
;
3425 XSETFASTINT (w
->use_time
, window_select_count
);
3426 if (EQ (window
, selected_window
))
3429 /* Store the current buffer's actual point into the
3430 old selected window. It belongs to that window,
3431 and when the window is not selected, must be in the window. */
3432 if (!NILP (selected_window
))
3434 ow
= XWINDOW (selected_window
);
3435 if (! NILP (ow
->buffer
))
3436 set_marker_both (ow
->pointm
, ow
->buffer
,
3437 BUF_PT (XBUFFER (ow
->buffer
)),
3438 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3441 selected_window
= window
;
3442 sf
= SELECTED_FRAME ();
3443 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3445 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3446 /* Use this rather than Fhandle_switch_frame
3447 so that FRAME_FOCUS_FRAME is moved appropriately as we
3448 move around in the state where a minibuffer in a separate
3450 Fselect_frame (WINDOW_FRAME (w
));
3453 sf
->selected_window
= window
;
3455 if (NILP (norecord
))
3456 record_buffer (w
->buffer
);
3457 Fset_buffer (w
->buffer
);
3459 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3461 /* Go to the point recorded in the window.
3462 This is important when the buffer is in more
3463 than one window. It also matters when
3464 redisplay_window has altered point after scrolling,
3465 because it makes the change only in the window. */
3467 register int new_point
= marker_position (w
->pointm
);
3468 if (new_point
< BEGV
)
3470 else if (new_point
> ZV
)
3476 windows_or_buffers_changed
++;
3481 select_window_norecord (window
)
3484 return Fselect_window (window
, Qt
);
3487 /* Deiconify the frame containing the window WINDOW,
3488 unless it is the selected frame;
3491 The reason for the exception for the selected frame
3492 is that it seems better not to change the selected frames visibility
3493 merely because of displaying a different buffer in it.
3494 The deiconification is useful when a buffer gets shown in
3495 another frame that you were not using lately. */
3498 display_buffer_1 (window
)
3501 Lisp_Object frame
= XWINDOW (window
)->frame
;
3502 FRAME_PTR f
= XFRAME (frame
);
3504 FRAME_SAMPLE_VISIBILITY (f
);
3506 if (EQ (frame
, selected_frame
))
3507 ; /* Assume the selected frame is already visible enough. */
3508 else if (minibuf_level
> 0
3509 && MINI_WINDOW_P (XWINDOW (selected_window
))
3510 && WINDOW_LIVE_P (minibuf_selected_window
)
3511 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3512 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3515 if (FRAME_ICONIFIED_P (f
))
3516 Fmake_frame_visible (frame
);
3517 else if (FRAME_VISIBLE_P (f
))
3518 Fraise_frame (frame
);
3524 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3525 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3526 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3527 special frame for that buffer using the default frame parameters.
3529 If the value is a list, it is a list of frame parameters that would be used
3530 to make a frame for that buffer.
3531 The variables `special-display-buffer-names'
3532 and `special-display-regexps' control this. */)
3534 Lisp_Object buffer_name
;
3538 CHECK_STRING (buffer_name
);
3540 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3544 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3548 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3550 Lisp_Object car
= XCAR (tem
);
3552 && fast_string_match (car
, buffer_name
) >= 0)
3554 else if (CONSP (car
)
3555 && STRINGP (XCAR (car
))
3556 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3562 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3563 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3564 More precisely, if `display-buffer' or `pop-to-buffer' would display
3565 that buffer in the selected window rather than (as usual) in some other window.
3566 See `same-window-buffer-names' and `same-window-regexps'. */)
3568 Lisp_Object buffer_name
;
3572 CHECK_STRING (buffer_name
);
3574 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3578 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3582 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3584 Lisp_Object car
= XCAR (tem
);
3586 && fast_string_match (car
, buffer_name
) >= 0)
3588 else if (CONSP (car
)
3589 && STRINGP (XCAR (car
))
3590 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3596 /* Use B so the default is (other-buffer). */
3597 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3598 "BDisplay buffer: \nP",
3599 doc
: /* Make BUFFER appear in some window but don't select it.
3600 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3602 If BUFFER is shown already in some window, just use that one,
3603 unless the window is the selected window and the optional second
3604 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3605 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3606 Returns the window displaying BUFFER.
3607 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3608 displaying BUFFER, then simply raise that frame.
3610 The variables `special-display-buffer-names',
3611 `special-display-regexps', `same-window-buffer-names', and
3612 `same-window-regexps' customize how certain buffer names are handled.
3613 The latter two take effect only if NOT-THIS-WINDOW is nil.
3615 If optional argument FRAME is `visible', check all visible frames
3616 for a window to use.
3617 If FRAME is 0, check all visible and iconified frames.
3618 If FRAME is t, check all frames.
3619 If FRAME is a frame, check only that frame.
3620 If FRAME is nil, check only the selected frame
3621 (actually the last nonminibuffer frame),
3622 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3623 which means search visible and iconified frames.
3625 If a full-width window on a splittable frame is available to display
3626 the buffer, it may be split, subject to the value of the variable
3627 `split-height-threshold'.
3629 If `even-window-heights' is non-nil, window heights will be evened out
3630 if displaying the buffer causes two vertically adjacent windows to be
3632 (buffer
, not_this_window
, frame
)
3633 register Lisp_Object buffer
, not_this_window
, frame
;
3635 register Lisp_Object window
, tem
, swp
;
3639 buffer
= Fget_buffer (buffer
);
3640 CHECK_BUFFER (buffer
);
3642 if (!NILP (Vdisplay_buffer_function
))
3643 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3645 if (NILP (not_this_window
)
3646 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3647 return display_buffer_1 (selected_window
);
3649 /* See if the user has specified this buffer should appear
3650 in the selected window. */
3651 if (NILP (not_this_window
))
3653 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3654 if (!NILP (swp
) && !no_switch_window (selected_window
))
3656 Fswitch_to_buffer (buffer
, Qnil
);
3657 return display_buffer_1 (selected_window
);
3661 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3662 look for a window showing BUFFER on any visible or iconified frame.
3663 Otherwise search only the current frame. */
3666 else if (pop_up_frames
3667 || display_buffer_reuse_frames
3668 || last_nonminibuf_frame
== 0)
3669 XSETFASTINT (tem
, 0);
3671 XSETFRAME (tem
, last_nonminibuf_frame
);
3673 window
= Fget_buffer_window (buffer
, tem
);
3675 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3676 return display_buffer_1 (window
);
3678 /* Certain buffer names get special handling. */
3679 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3681 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3683 return call1 (Vspecial_display_function
, buffer
);
3685 return call2 (Vspecial_display_function
, buffer
, tem
);
3688 /* If there are no frames open that have more than a minibuffer,
3689 we need to create a new frame. */
3690 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3692 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3693 Fset_window_buffer (window
, buffer
, Qnil
);
3694 return display_buffer_1 (window
);
3697 f
= SELECTED_FRAME ();
3699 || FRAME_MINIBUF_ONLY_P (f
)
3700 /* If the current frame is a special display frame,
3701 don't try to reuse its windows. */
3702 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3707 if (FRAME_MINIBUF_ONLY_P (f
))
3708 XSETFRAME (frames
, last_nonminibuf_frame
);
3709 /* Don't try to create a window if we would get an error. */
3710 if (split_height_threshold
< window_min_height
<< 1)
3711 split_height_threshold
= window_min_height
<< 1;
3713 /* Note that both Fget_largest_window and Fget_lru_window
3714 ignore minibuffers and dedicated windows.
3715 This means they can return nil. */
3717 /* If the frame we would try to split cannot be split,
3718 try other frames. */
3719 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3721 /* Try visible frames first. */
3722 window
= Fget_largest_window (Qvisible
, Qt
);
3723 /* If that didn't work, try iconified frames. */
3725 window
= Fget_largest_window (make_number (0), Qt
);
3726 #if 0 /* Don't try windows on other displays. */
3728 window
= Fget_largest_window (Qt
, Qt
);
3732 window
= Fget_largest_window (frames
, Qt
);
3734 /* If we got a tall enough full-width window that can be split,
3737 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3738 && window_height (window
) >= split_height_threshold
3739 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3740 window
= Fsplit_window (window
, Qnil
, Qnil
);
3743 Lisp_Object upper
, lower
, other
;
3745 window
= Fget_lru_window (frames
, Qt
);
3746 /* If the LRU window is selected, and big enough,
3747 and can be split, split it. */
3749 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3750 && (EQ (window
, selected_window
)
3751 || EQ (XWINDOW (window
)->parent
, Qnil
))
3752 && window_height (window
) >= window_min_height
<< 1)
3753 window
= Fsplit_window (window
, Qnil
, Qnil
);
3755 window
= Fget_lru_window (frames
, Qnil
);
3756 /* If Fget_lru_window returned nil, try other approaches. */
3758 /* Try visible frames first. */
3760 window
= Fget_buffer_window (buffer
, Qvisible
);
3762 window
= Fget_largest_window (Qvisible
, Qnil
);
3763 /* If that didn't work, try iconified frames. */
3765 window
= Fget_buffer_window (buffer
, make_number (0));
3767 window
= Fget_largest_window (make_number (0), Qnil
);
3769 #if 0 /* Don't try frames on other displays. */
3771 window
= Fget_buffer_window (buffer
, Qt
);
3773 window
= Fget_largest_window (Qt
, Qnil
);
3775 /* As a last resort, make a new frame. */
3777 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3778 /* If window appears above or below another,
3779 even out their heights. */
3780 other
= upper
= lower
= Qnil
;
3781 if (!NILP (XWINDOW (window
)->prev
))
3782 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3783 if (!NILP (XWINDOW (window
)->next
))
3784 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3786 && !NILP (Veven_window_heights
)
3787 /* Check that OTHER and WINDOW are vertically arrayed. */
3788 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3789 && (XFASTINT (XWINDOW (other
)->total_lines
)
3790 > XFASTINT (XWINDOW (window
)->total_lines
)))
3792 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3793 + XFASTINT (XWINDOW (window
)->total_lines
));
3794 enlarge_window (upper
,
3795 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3801 window
= Fget_lru_window (Qnil
, Qnil
);
3803 Fset_window_buffer (window
, buffer
, Qnil
);
3804 return display_buffer_1 (window
);
3808 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3810 doc
: /* Force all windows to be updated on next redisplay.
3811 If optional arg OBJECT is a window, force redisplay of that window only.
3812 If OBJECT is a buffer or buffer name, force redisplay of all windows
3813 displaying that buffer. */)
3819 windows_or_buffers_changed
++;
3820 update_mode_lines
++;
3824 if (WINDOWP (object
))
3826 struct window
*w
= XWINDOW (object
);
3827 mark_window_display_accurate (object
, 0);
3828 w
->update_mode_line
= Qt
;
3829 if (BUFFERP (w
->buffer
))
3830 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3831 ++update_mode_lines
;
3835 if (STRINGP (object
))
3836 object
= Fget_buffer (object
);
3837 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3839 /* Walk all windows looking for buffer, and force update
3840 of each of those windows. */
3842 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3843 return NILP (object
) ? Qnil
: Qt
;
3846 /* If nothing suitable was found, just return.
3847 We could signal an error, but this feature will typically be used
3848 asynchronously in timers or process sentinels, so we don't. */
3854 temp_output_buffer_show (buf
)
3855 register Lisp_Object buf
;
3857 register struct buffer
*old
= current_buffer
;
3858 register Lisp_Object window
;
3859 register struct window
*w
;
3861 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3864 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3868 #if 0 /* rms: there should be no reason for this. */
3869 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3871 set_buffer_internal (old
);
3873 if (!NILP (Vtemp_buffer_show_function
))
3874 call1 (Vtemp_buffer_show_function
, buf
);
3877 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3879 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3880 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3881 Vminibuf_scroll_window
= window
;
3882 w
= XWINDOW (window
);
3883 XSETFASTINT (w
->hscroll
, 0);
3884 XSETFASTINT (w
->min_hscroll
, 0);
3885 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3886 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3888 /* Run temp-buffer-show-hook, with the chosen window selected
3889 and its buffer current. */
3891 if (!NILP (Vrun_hooks
)
3892 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3893 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3895 int count
= SPECPDL_INDEX ();
3896 Lisp_Object prev_window
, prev_buffer
;
3897 prev_window
= selected_window
;
3898 XSETBUFFER (prev_buffer
, old
);
3900 /* Select the window that was chosen, for running the hook.
3901 Note: Both Fselect_window and select_window_norecord may
3902 set-buffer to the buffer displayed in the window,
3903 so we need to save the current buffer. --stef */
3904 record_unwind_protect (Fset_buffer
, prev_buffer
);
3905 record_unwind_protect (select_window_norecord
, prev_window
);
3906 Fselect_window (window
, Qt
);
3907 Fset_buffer (w
->buffer
);
3908 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3909 unbind_to (count
, Qnil
);
3915 make_dummy_parent (window
)
3919 register struct window
*o
, *p
;
3922 o
= XWINDOW (window
);
3923 p
= allocate_window ();
3924 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3925 ((struct Lisp_Vector
*) p
)->contents
[i
]
3926 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3927 XSETWINDOW (new, p
);
3930 XSETFASTINT (p
->sequence_number
, sequence_number
);
3932 /* Put new into window structure in place of window */
3933 replace_window (window
, new);
3946 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3947 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3948 WINDOW defaults to selected one and SIZE to half its size.
3949 If optional third arg HORFLAG is non-nil, split side by side
3950 and put SIZE columns in the first of the pair. In that case,
3951 SIZE includes that window's scroll bar, or the divider column to its right.
3952 Interactively, all arguments are nil.
3954 Returns the newly created window (which is the lower or rightmost one).
3955 The upper or leftmost window is the original one, and remains selected
3956 if it was selected before.
3958 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3959 (window
, size
, horflag
)
3960 Lisp_Object window
, size
, horflag
;
3962 register Lisp_Object
new;
3963 register struct window
*o
, *p
;
3965 register int size_int
;
3968 window
= selected_window
;
3970 CHECK_LIVE_WINDOW (window
);
3972 o
= XWINDOW (window
);
3973 fo
= XFRAME (WINDOW_FRAME (o
));
3977 if (!NILP (horflag
))
3978 /* Calculate the size of the left-hand window, by dividing
3979 the usable space in columns by two.
3980 We round up, since the left-hand window may include
3981 a dividing line, while the right-hand may not. */
3982 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3984 size_int
= XFASTINT (o
->total_lines
) >> 1;
3988 CHECK_NUMBER (size
);
3989 size_int
= XINT (size
);
3992 if (MINI_WINDOW_P (o
))
3993 error ("Attempt to split minibuffer window");
3994 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3995 error ("Attempt to split fixed-size window");
3997 check_min_window_sizes ();
4001 if (size_int
< window_min_height
)
4002 error ("Window height %d too small (after splitting)", size_int
);
4003 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
4004 error ("Window height %d too small (after splitting)",
4005 XFASTINT (o
->total_lines
) - size_int
);
4006 if (NILP (o
->parent
)
4007 || NILP (XWINDOW (o
->parent
)->vchild
))
4009 make_dummy_parent (window
);
4011 XWINDOW (new)->vchild
= window
;
4016 if (size_int
< window_min_width
)
4017 error ("Window width %d too small (after splitting)", size_int
);
4019 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
4020 error ("Window width %d too small (after splitting)",
4021 XFASTINT (o
->total_cols
) - size_int
);
4022 if (NILP (o
->parent
)
4023 || NILP (XWINDOW (o
->parent
)->hchild
))
4025 make_dummy_parent (window
);
4027 XWINDOW (new)->hchild
= window
;
4031 /* Now we know that window's parent is a vertical combination
4032 if we are dividing vertically, or a horizontal combination
4033 if we are making side-by-side windows */
4035 windows_or_buffers_changed
++;
4036 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
4037 new = make_window ();
4040 p
->frame
= o
->frame
;
4042 if (!NILP (p
->next
))
4043 XWINDOW (p
->next
)->prev
= new;
4046 p
->parent
= o
->parent
;
4048 p
->window_end_valid
= Qnil
;
4049 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
4051 /* Duplicate special geometry settings. */
4053 p
->left_margin_cols
= o
->left_margin_cols
;
4054 p
->right_margin_cols
= o
->right_margin_cols
;
4055 p
->left_fringe_width
= o
->left_fringe_width
;
4056 p
->right_fringe_width
= o
->right_fringe_width
;
4057 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
4058 p
->scroll_bar_width
= o
->scroll_bar_width
;
4059 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
4061 /* Apportion the available frame space among the two new windows */
4063 if (!NILP (horflag
))
4065 p
->total_lines
= o
->total_lines
;
4066 p
->top_line
= o
->top_line
;
4067 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
4068 XSETFASTINT (o
->total_cols
, size_int
);
4069 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
4070 adjust_window_margins (p
);
4071 adjust_window_margins (o
);
4075 p
->left_col
= o
->left_col
;
4076 p
->total_cols
= o
->total_cols
;
4077 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
4078 XSETFASTINT (o
->total_lines
, size_int
);
4079 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
4082 /* Adjust glyph matrices. */
4085 Fset_window_buffer (new, o
->buffer
, Qt
);
4089 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
4090 doc
: /* Make current window ARG lines bigger.
4091 From program, optional second arg non-nil means grow sideways ARG columns.
4092 Interactively, if an argument is not given, make the window one line bigger.
4093 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
4094 This function can delete windows, even the second window, if they get
4097 Lisp_Object arg
, horizontal
;
4100 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
4102 if (! NILP (Vwindow_configuration_change_hook
))
4103 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4108 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
4109 doc
: /* Make current window ARG lines smaller.
4110 From program, optional second arg non-nil means shrink sideways arg columns.
4111 Interactively, if an argument is not given, make the window one line smaller. Only
4112 siblings to the right or below are changed. */)
4114 Lisp_Object arg
, side
;
4117 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
4119 if (! NILP (Vwindow_configuration_change_hook
))
4120 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4126 window_height (window
)
4129 register struct window
*p
= XWINDOW (window
);
4130 return WINDOW_TOTAL_LINES (p
);
4134 window_width (window
)
4137 register struct window
*p
= XWINDOW (window
);
4138 return WINDOW_TOTAL_COLS (p
);
4143 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4145 #define CURSIZE(w) \
4146 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4149 /* Enlarge WINDOW by DELTA.
4150 HORIZ_FLAG nonzero means enlarge it horizontally;
4151 zero means do it vertically.
4153 Siblings of the selected window are resized to fulfill the size
4154 request. If they become too small in the process, they will be
4158 enlarge_window (window
, delta
, horiz_flag
)
4160 int delta
, horiz_flag
;
4162 Lisp_Object parent
, next
, prev
;
4166 int (*sizefun
) P_ ((Lisp_Object
))
4167 = horiz_flag
? window_width
: window_height
;
4168 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
4169 = (horiz_flag
? set_window_width
: set_window_height
);
4171 /* Check values of window_min_width and window_min_height for
4173 check_min_window_sizes ();
4175 /* Give up if this window cannot be resized. */
4176 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4177 error ("Window is not resizable");
4179 /* Find the parent of the selected window. */
4182 p
= XWINDOW (window
);
4188 error ("No other window to side of this one");
4193 ? !NILP (XWINDOW (parent
)->hchild
)
4194 : !NILP (XWINDOW (parent
)->vchild
))
4200 sizep
= &CURSIZE (window
);
4203 register int maxdelta
;
4205 /* Compute the maximum size increment this window can have. */
4207 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4208 /* This is a main window followed by a minibuffer. */
4209 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4210 - window_min_size (XWINDOW (p
->next
),
4212 /* This is a minibuffer following a main window. */
4213 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4214 - window_min_size (XWINDOW (p
->prev
),
4216 /* This is a frame with only one window, a minibuffer-only
4217 or a minibufferless frame. */
4220 if (delta
> maxdelta
)
4221 /* This case traps trying to make the minibuffer
4222 the full frame, or make the only window aside from the
4223 minibuffer the full frame. */
4227 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4229 delete_window (window
);
4236 /* Find the total we can get from other siblings without deleting them. */
4238 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4239 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4241 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4242 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4245 /* If we can get it all from them without deleting them, do so. */
4246 if (delta
<= maximum
)
4248 Lisp_Object first_unaffected
;
4249 Lisp_Object first_affected
;
4254 first_affected
= window
;
4255 /* Look at one sibling at a time,
4256 moving away from this window in both directions alternately,
4257 and take as much as we can get without deleting that sibling. */
4259 && (!NILP (next
) || !NILP (prev
)))
4263 int this_one
= ((*sizefun
) (next
)
4264 - window_min_size (XWINDOW (next
),
4265 horiz_flag
, 0, &fixed_p
));
4268 if (this_one
> delta
)
4271 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4272 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4277 next
= XWINDOW (next
)->next
;
4285 int this_one
= ((*sizefun
) (prev
)
4286 - window_min_size (XWINDOW (prev
),
4287 horiz_flag
, 0, &fixed_p
));
4290 if (this_one
> delta
)
4293 first_affected
= prev
;
4295 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4296 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4301 prev
= XWINDOW (prev
)->prev
;
4305 xassert (delta
== 0);
4307 /* Now recalculate the edge positions of all the windows affected,
4308 based on the new sizes. */
4309 first_unaffected
= next
;
4310 prev
= first_affected
;
4311 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4312 prev
= next
, next
= XWINDOW (next
)->next
)
4314 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4315 /* This does not change size of NEXT,
4316 but it propagates the new top edge to its children */
4317 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4322 register int delta1
;
4323 register int opht
= (*sizefun
) (parent
);
4325 if (opht
<= XINT (*sizep
) + delta
)
4327 /* If trying to grow this window to or beyond size of the parent,
4328 just delete all the sibling windows. */
4329 Lisp_Object start
, tem
, next
;
4331 start
= XWINDOW (parent
)->vchild
;
4333 start
= XWINDOW (parent
)->hchild
;
4335 /* Delete any siblings that come after WINDOW. */
4336 tem
= XWINDOW (window
)->next
;
4337 while (! NILP (tem
))
4339 next
= XWINDOW (tem
)->next
;
4340 delete_window (tem
);
4344 /* Delete any siblings that come after WINDOW.
4345 Note that if START is not WINDOW, then WINDOW still
4346 Fhas siblings, so WINDOW has not yet replaced its parent. */
4348 while (! EQ (tem
, window
))
4350 next
= XWINDOW (tem
)->next
;
4351 delete_window (tem
);
4357 /* Otherwise, make delta1 just right so that if we add
4358 delta1 lines to this window and to the parent, and then
4359 shrink the parent back to its original size, the new
4360 proportional size of this window will increase by delta.
4362 The function size_window will compute the new height h'
4363 of the window from delta1 as:
4366 x = delta1 - delta1/n * n for the 1st resizable child
4369 where n is the number of children that can be resized.
4370 We can ignore x by choosing a delta1 that is a multiple of
4371 n. We want the height of this window to come out as
4381 The number of children n equals the number of resizable
4382 children of this window + 1 because we know window itself
4383 is resizable (otherwise we would have signalled an error). */
4385 struct window
*w
= XWINDOW (window
);
4389 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4390 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4392 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4393 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4398 /* Add delta1 lines or columns to this window, and to the parent,
4399 keeping things consistent while not affecting siblings. */
4400 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4401 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4403 /* Squeeze out delta1 lines or columns from our parent,
4404 shriking this window and siblings proportionately.
4405 This brings parent back to correct size.
4406 Delta1 was calculated so this makes this window the desired size,
4407 taking it all out of the siblings. */
4408 (*setsizefun
) (parent
, opht
, 0);
4413 XSETFASTINT (p
->last_modified
, 0);
4414 XSETFASTINT (p
->last_overlay_modified
, 0);
4416 /* Adjust glyph matrices. */
4417 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4421 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4422 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4423 zero means adjust the height, moving the bottom edge.
4425 Following siblings of the selected window are resized to fulfill
4426 the size request. If they become too small in the process, they
4427 are not deleted; instead, we signal an error. */
4430 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4432 int delta
, horiz_flag
;
4434 Lisp_Object parent
, child
;
4436 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4437 int delcount
= window_deletion_count
;
4439 /* Check values of window_min_width and window_min_height for
4441 check_min_window_sizes ();
4444 window
= Fselected_window ();
4446 CHECK_WINDOW (window
);
4448 /* Give up if this window cannot be resized. */
4449 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4450 error ("Window is not resizable");
4454 Lisp_Object first_parallel
= Qnil
;
4458 /* This happens if WINDOW on the previous iteration was
4459 at top level of the window tree. */
4460 Fset_window_configuration (old_config
);
4461 error ("Specified window edge is fixed");
4464 p
= XWINDOW (window
);
4467 /* See if this level has windows in parallel in the specified
4468 direction. If so, set FIRST_PARALLEL to the first one. */
4471 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4472 first_parallel
= XWINDOW (parent
)->vchild
;
4473 else if (NILP (parent
) && !NILP (p
->next
))
4475 /* Handle the vertical chain of main window and minibuffer
4476 which has no parent. */
4477 first_parallel
= window
;
4478 while (! NILP (XWINDOW (first_parallel
)->prev
))
4479 first_parallel
= XWINDOW (first_parallel
)->prev
;
4484 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4485 first_parallel
= XWINDOW (parent
)->hchild
;
4488 /* If this level's succession is in the desired dimension,
4489 and this window is the last one, and there is no higher level,
4490 its trailing edge is fixed. */
4491 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4494 Fset_window_configuration (old_config
);
4495 error ("Specified window edge is fixed");
4498 /* Don't make this window too small. */
4499 if (XINT (CURSIZE (window
)) + delta
4500 < (horiz_flag
? window_min_width
: window_min_height
))
4502 Fset_window_configuration (old_config
);
4503 error ("Cannot adjust window size as specified");
4506 /* Clear out some redisplay caches. */
4507 XSETFASTINT (p
->last_modified
, 0);
4508 XSETFASTINT (p
->last_overlay_modified
, 0);
4510 /* Adjust this window's edge. */
4511 XSETINT (CURSIZE (window
),
4512 XINT (CURSIZE (window
)) + delta
);
4514 /* If this window has following siblings in the desired dimension,
4515 make them smaller, and exit the loop.
4517 (If we reach the top of the tree and can never do this,
4518 we will fail and report an error, above.) */
4519 if (NILP (first_parallel
))
4521 if (!NILP (p
->next
))
4523 /* This may happen for the minibuffer. In that case
4524 the window_deletion_count check below does not work. */
4525 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4527 Fset_window_configuration (old_config
);
4528 error ("Cannot adjust window size as specified");
4531 XSETINT (CURBEG (p
->next
),
4532 XINT (CURBEG (p
->next
)) + delta
);
4533 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4534 horiz_flag
, 0, 1, 0);
4539 /* Here we have a chain of parallel siblings, in the other dimension.
4540 Change the size of the other siblings. */
4541 for (child
= first_parallel
;
4543 child
= XWINDOW (child
)->next
)
4544 if (! EQ (child
, window
))
4545 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4546 horiz_flag
, 0, 0, 1);
4551 /* If we made a window so small it got deleted,
4552 we failed. Report failure. */
4553 if (delcount
!= window_deletion_count
)
4555 Fset_window_configuration (old_config
);
4556 error ("Cannot adjust window size as specified");
4559 /* Adjust glyph matrices. */
4560 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4566 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4567 Sadjust_window_trailing_edge
, 3, 3, 0,
4568 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4569 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4570 Otherwise, adjust the height, moving the bottom edge.
4572 Following siblings of the selected window are resized to fulfill
4573 the size request. If they become too small in the process, they
4574 are not deleted; instead, we signal an error. */)
4575 (window
, delta
, horizontal
)
4576 Lisp_Object window
, delta
, horizontal
;
4578 CHECK_NUMBER (delta
);
4579 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4581 if (! NILP (Vwindow_configuration_change_hook
))
4582 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4589 /***********************************************************************
4590 Resizing Mini-Windows
4591 ***********************************************************************/
4593 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4595 enum save_restore_action
4602 static int save_restore_orig_size
P_ ((struct window
*,
4603 enum save_restore_action
));
4605 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4606 from lowest windows first. */
4609 shrink_window_lowest_first (w
, height
)
4617 xassert (!MINI_WINDOW_P (w
));
4619 /* Set redisplay hints. */
4620 XSETFASTINT (w
->last_modified
, 0);
4621 XSETFASTINT (w
->last_overlay_modified
, 0);
4622 windows_or_buffers_changed
++;
4623 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4625 old_height
= XFASTINT (w
->total_lines
);
4626 XSETFASTINT (w
->total_lines
, height
);
4628 if (!NILP (w
->hchild
))
4630 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4632 c
= XWINDOW (child
);
4633 c
->top_line
= w
->top_line
;
4634 shrink_window_lowest_first (c
, height
);
4637 else if (!NILP (w
->vchild
))
4639 Lisp_Object last_child
;
4640 int delta
= old_height
- height
;
4645 /* Find the last child. We are taking space from lowest windows
4646 first, so we iterate over children from the last child
4648 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4651 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4652 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4656 c
= XWINDOW (child
);
4657 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4659 if (this_one
> delta
)
4662 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4666 /* Compute new positions. */
4667 last_top
= XINT (w
->top_line
);
4668 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4670 c
= XWINDOW (child
);
4671 c
->top_line
= make_number (last_top
);
4672 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4673 last_top
+= XFASTINT (c
->total_lines
);
4679 /* Save, restore, or check positions and sizes in the window tree
4680 rooted at W. ACTION says what to do.
4682 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4683 orig_total_lines members are valid for all windows in the window
4684 tree. Value is non-zero if they are valid.
4686 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4687 orig_top_line and orig_total_lines for all windows in the tree.
4689 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4690 stored in orig_top_line and orig_total_lines for all windows. */
4693 save_restore_orig_size (w
, action
)
4695 enum save_restore_action action
;
4701 if (!NILP (w
->hchild
))
4703 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4706 else if (!NILP (w
->vchild
))
4708 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4714 case CHECK_ORIG_SIZES
:
4715 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4719 case SAVE_ORIG_SIZES
:
4720 w
->orig_top_line
= w
->top_line
;
4721 w
->orig_total_lines
= w
->total_lines
;
4722 XSETFASTINT (w
->last_modified
, 0);
4723 XSETFASTINT (w
->last_overlay_modified
, 0);
4726 case RESTORE_ORIG_SIZES
:
4727 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4728 w
->top_line
= w
->orig_top_line
;
4729 w
->total_lines
= w
->orig_total_lines
;
4730 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4731 XSETFASTINT (w
->last_modified
, 0);
4732 XSETFASTINT (w
->last_overlay_modified
, 0);
4739 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4746 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4747 without deleting other windows. */
4750 grow_mini_window (w
, delta
)
4754 struct frame
*f
= XFRAME (w
->frame
);
4755 struct window
*root
;
4757 xassert (MINI_WINDOW_P (w
));
4758 xassert (delta
>= 0);
4760 /* Check values of window_min_width and window_min_height for
4762 check_min_window_sizes ();
4764 /* Compute how much we can enlarge the mini-window without deleting
4766 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4769 int min_height
= window_min_size (root
, 0, 0, 0);
4770 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4771 /* Note that the root window may already be smaller than
4773 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4778 /* Save original window sizes and positions, if not already done. */
4779 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4780 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4782 /* Shrink other windows. */
4783 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4785 /* Grow the mini-window. */
4786 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4787 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4788 XSETFASTINT (w
->last_modified
, 0);
4789 XSETFASTINT (w
->last_overlay_modified
, 0);
4796 /* Shrink mini-window W. If there is recorded info about window sizes
4797 before a call to grow_mini_window, restore recorded window sizes.
4798 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4802 shrink_mini_window (w
)
4805 struct frame
*f
= XFRAME (w
->frame
);
4806 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4808 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4810 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4812 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4813 windows_or_buffers_changed
= 1;
4815 else if (XFASTINT (w
->total_lines
) > 1)
4817 /* Distribute the additional lines of the mini-window
4818 among the other windows. */
4820 XSETWINDOW (window
, w
);
4821 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4827 /* Mark window cursors off for all windows in the window tree rooted
4828 at W by setting their phys_cursor_on_p flag to zero. Called from
4829 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4830 the frame are cleared. */
4833 mark_window_cursors_off (w
)
4838 if (!NILP (w
->hchild
))
4839 mark_window_cursors_off (XWINDOW (w
->hchild
));
4840 else if (!NILP (w
->vchild
))
4841 mark_window_cursors_off (XWINDOW (w
->vchild
));
4843 w
->phys_cursor_on_p
= 0;
4845 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4850 /* Return number of lines of text (not counting mode lines) in W. */
4853 window_internal_height (w
)
4856 int ht
= XFASTINT (w
->total_lines
);
4858 if (!MINI_WINDOW_P (w
))
4860 if (!NILP (w
->parent
)
4861 || !NILP (w
->vchild
)
4862 || !NILP (w
->hchild
)
4865 || WINDOW_WANTS_MODELINE_P (w
))
4868 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4876 /* Return the number of columns in W.
4877 Don't count columns occupied by scroll bars or the vertical bar
4878 separating W from the sibling to its right. */
4881 window_box_text_cols (w
)
4884 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4885 int width
= XINT (w
->total_cols
);
4887 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4888 /* Scroll bars occupy a few columns. */
4889 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4890 else if (!FRAME_WINDOW_P (f
)
4891 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4892 /* The column of `|' characters separating side-by-side windows
4893 occupies one column only. */
4896 if (FRAME_WINDOW_P (f
))
4897 /* On window-systems, fringes and display margins cannot be
4898 used for normal text. */
4899 width
-= (WINDOW_FRINGE_COLS (w
)
4900 + WINDOW_LEFT_MARGIN_COLS (w
)
4901 + WINDOW_RIGHT_MARGIN_COLS (w
));
4907 /************************************************************************
4909 ***********************************************************************/
4911 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4912 N screen-fulls, which is defined as the height of the window minus
4913 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4914 instead. Negative values of N mean scroll down. NOERROR non-zero
4915 means don't signal an error if we try to move over BEGV or ZV,
4919 window_scroll (window
, n
, whole
, noerror
)
4927 /* If we must, use the pixel-based version which is much slower than
4928 the line-based one but can handle varying line heights. */
4929 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4930 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4932 window_scroll_line_based (window
, n
, whole
, noerror
);
4938 /* Implementation of window_scroll that works based on pixel line
4939 heights. See the comment of window_scroll for parameter
4943 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4950 struct window
*w
= XWINDOW (window
);
4951 struct text_pos start
;
4952 int this_scroll_margin
;
4953 /* True if we fiddled the window vscroll field without really scrolling. */
4955 int x
, y
, rtop
, rbot
, rowh
, vpos
;
4957 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4959 /* If PT is not visible in WINDOW, move back one half of
4960 the screen. Allow PT to be partially visible, otherwise
4961 something like (scroll-down 1) with PT in the line before
4962 the partially visible one would recenter. */
4964 if (!pos_visible_p (w
, PT
, &x
, &y
, &rtop
, &rbot
, &rowh
, &vpos
))
4966 /* Move backward half the height of the window. Performance note:
4967 vmotion used here is about 10% faster, but would give wrong
4968 results for variable height lines. */
4969 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4970 it
.current_y
= it
.last_visible_y
;
4971 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4973 /* The function move_iterator_vertically may move over more than
4974 the specified y-distance. If it->w is small, e.g. a
4975 mini-buffer window, we may end up in front of the window's
4976 display area. This is the case when Start displaying at the
4977 start of the line containing PT in this case. */
4978 if (it
.current_y
<= 0)
4980 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4981 move_it_vertically_backward (&it
, 0);
4985 start
= it
.current
.pos
;
4987 else if (auto_window_vscroll_p
)
4989 if (rtop
|| rbot
) /* partially visible */
4992 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4994 dy
= max ((window_box_height (w
)
4995 - next_screen_context_lines
* dy
),
5001 /* Only vscroll backwards if already vscrolled forwards. */
5002 if (w
->vscroll
< 0 && rtop
> 0)
5004 px
= max (0, -w
->vscroll
- min (rtop
, -dy
));
5005 Fset_window_vscroll (window
, make_number (px
), Qt
);
5011 /* Do vscroll if already vscrolled or only display line. */
5012 if (rbot
> 0 && (w
->vscroll
< 0 || vpos
== 0))
5014 px
= max (0, -w
->vscroll
+ min (rbot
, dy
));
5015 Fset_window_vscroll (window
, make_number (px
), Qt
);
5019 /* Maybe modify window start instead of scrolling. */
5020 if (rbot
> 0 || w
->vscroll
< 0)
5024 Fset_window_vscroll (window
, make_number (0), Qt
);
5025 /* If there are other text lines above the current row,
5026 move window start to current row. Else to next row. */
5028 spos
= XINT (Fline_beginning_position (Qnil
));
5030 spos
= min (XINT (Fline_end_position (Qnil
)) + 1, ZV
);
5031 set_marker_restricted (w
->start
, make_number (spos
),
5033 w
->start_at_line_beg
= Qt
;
5034 w
->update_mode_line
= Qt
;
5035 XSETFASTINT (w
->last_modified
, 0);
5036 XSETFASTINT (w
->last_overlay_modified
, 0);
5037 /* Set force_start so that redisplay_window will run the
5038 window-scroll-functions. */
5039 w
->force_start
= Qt
;
5044 /* Cancel previous vscroll. */
5045 Fset_window_vscroll (window
, make_number (0), Qt
);
5048 /* If scroll_preserve_screen_position is non-nil, we try to set
5049 point in the same window line as it is now, so get that line. */
5050 if (!NILP (Vscroll_preserve_screen_position
))
5052 /* We preserve the goal pixel coordinate across consecutive
5053 calls to scroll-up or scroll-down. This avoids the
5054 possibility of point becoming "stuck" on a tall line when
5055 scrolling by one line. */
5056 if (window_scroll_pixel_based_preserve_y
< 0
5057 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
5058 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
5060 start_display (&it
, w
, start
);
5061 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5062 window_scroll_pixel_based_preserve_y
= it
.current_y
;
5066 window_scroll_pixel_based_preserve_y
= -1;
5068 /* Move iterator it from start the specified distance forward or
5069 backward. The result is the new window start. */
5070 start_display (&it
, w
, start
);
5073 int start_pos
= IT_CHARPOS (it
);
5074 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
5075 dy
= max ((window_box_height (w
)
5076 - next_screen_context_lines
* dy
),
5079 /* Note that move_it_vertically always moves the iterator to the
5080 start of a line. So, if the last line doesn't have a newline,
5081 we would end up at the start of the line ending at ZV. */
5084 move_it_vertically_backward (&it
, -dy
);
5085 /* Ensure we actually do move, e.g. in case we are currently
5086 looking at an image that is taller that the window height. */
5087 while (start_pos
== IT_CHARPOS (it
)
5088 && start_pos
> BEGV
)
5089 move_it_by_lines (&it
, -1, 1);
5093 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
5094 MOVE_TO_POS
| MOVE_TO_Y
);
5095 /* Ensure we actually do move, e.g. in case we are currently
5096 looking at an image that is taller that the window height. */
5097 while (start_pos
== IT_CHARPOS (it
)
5099 move_it_by_lines (&it
, 1, 1);
5103 move_it_by_lines (&it
, n
, 1);
5105 /* We failed if we find ZV is already on the screen (scrolling up,
5106 means there's nothing past the end), or if we can't start any
5107 earlier (scrolling down, means there's nothing past the top). */
5108 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
5109 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
5111 if (IT_CHARPOS (it
) == ZV
)
5113 if (it
.current_y
< it
.last_visible_y
5114 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
5115 > it
.last_visible_y
))
5117 /* The last line was only partially visible, make it fully
5119 w
->vscroll
= (it
.last_visible_y
5120 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
5121 adjust_glyphs (it
.f
);
5125 else if (n
< 0) /* could happen with empty buffers */
5126 xsignal0 (Qbeginning_of_buffer
);
5128 xsignal0 (Qend_of_buffer
);
5132 if (w
->vscroll
!= 0)
5133 /* The first line was only partially visible, make it fully
5139 xsignal0 (Qbeginning_of_buffer
);
5142 /* If control gets here, then we vscrolled. */
5144 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5146 /* Don't try to change the window start below. */
5152 int pos
= IT_CHARPOS (it
);
5155 /* If in the middle of a multi-glyph character move forward to
5156 the next character. */
5157 if (in_display_vector_p (&it
))
5160 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5163 /* Set the window start, and set up the window for redisplay. */
5164 set_marker_restricted (w
->start
, make_number (pos
),
5166 bytepos
= XMARKER (w
->start
)->bytepos
;
5167 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5169 w
->update_mode_line
= Qt
;
5170 XSETFASTINT (w
->last_modified
, 0);
5171 XSETFASTINT (w
->last_overlay_modified
, 0);
5172 /* Set force_start so that redisplay_window will run the
5173 window-scroll-functions. */
5174 w
->force_start
= Qt
;
5177 /* The rest of this function uses current_y in a nonstandard way,
5178 not including the height of the header line if any. */
5179 it
.current_y
= it
.vpos
= 0;
5181 /* Move PT out of scroll margins.
5182 This code wants current_y to be zero at the window start position
5183 even if there is a header line. */
5184 this_scroll_margin
= max (0, scroll_margin
);
5185 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5186 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5190 /* We moved the window start towards ZV, so PT may be now
5191 in the scroll margin at the top. */
5192 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5193 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5194 && (NILP (Vscroll_preserve_screen_position
)
5195 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5196 /* We found PT at a legitimate height. Leave it alone. */
5198 else if (window_scroll_pixel_based_preserve_y
>= 0)
5200 /* If we have a header line, take account of it.
5201 This is necessary because we set it.current_y to 0, above. */
5202 move_it_to (&it
, -1, -1,
5203 window_scroll_pixel_based_preserve_y
5204 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5206 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5210 while (it
.current_y
< this_scroll_margin
)
5212 int prev
= it
.current_y
;
5213 move_it_by_lines (&it
, 1, 1);
5214 if (prev
== it
.current_y
)
5217 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5222 int charpos
, bytepos
;
5225 /* Save our position, for the
5226 window_scroll_pixel_based_preserve_y case. */
5227 charpos
= IT_CHARPOS (it
);
5228 bytepos
= IT_BYTEPOS (it
);
5230 /* We moved the window start towards BEGV, so PT may be now
5231 in the scroll margin at the bottom. */
5232 move_it_to (&it
, PT
, -1,
5233 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5234 - this_scroll_margin
- 1),
5236 MOVE_TO_POS
| MOVE_TO_Y
);
5238 /* Save our position, in case it's correct. */
5239 charpos
= IT_CHARPOS (it
);
5240 bytepos
= IT_BYTEPOS (it
);
5242 /* See if point is on a partially visible line at the end. */
5243 if (it
.what
== IT_EOB
)
5244 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5247 move_it_by_lines (&it
, 1, 1);
5248 partial_p
= it
.current_y
> it
.last_visible_y
;
5251 if (charpos
== PT
&& !partial_p
5252 && (NILP (Vscroll_preserve_screen_position
)
5253 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5254 /* We found PT before we found the display margin, so PT is ok. */
5256 else if (window_scroll_pixel_based_preserve_y
>= 0)
5258 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5259 start_display (&it
, w
, start
);
5260 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5261 here because we called start_display again and did not
5262 alter it.current_y this time. */
5263 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5265 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5270 /* The last line was only partially visible, so back up two
5271 lines to make sure we're on a fully visible line. */
5273 move_it_by_lines (&it
, -2, 0);
5274 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5277 /* No, the position we saved is OK, so use it. */
5278 SET_PT_BOTH (charpos
, bytepos
);
5284 /* Implementation of window_scroll that works based on screen lines.
5285 See the comment of window_scroll for parameter descriptions. */
5288 window_scroll_line_based (window
, n
, whole
, noerror
)
5294 register struct window
*w
= XWINDOW (window
);
5295 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5296 register int pos
, pos_byte
;
5297 register int ht
= window_internal_height (w
);
5298 register Lisp_Object tem
;
5302 struct position posit
;
5305 /* If scrolling screen-fulls, compute the number of lines to
5306 scroll from the window's height. */
5308 n
*= max (1, ht
- next_screen_context_lines
);
5310 startpos
= marker_position (w
->start
);
5312 posit
= *compute_motion (startpos
, 0, 0, 0,
5314 -1, XINT (w
->hscroll
),
5316 original_vpos
= posit
.vpos
;
5318 XSETFASTINT (tem
, PT
);
5319 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5323 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5328 lose
= n
< 0 && PT
== BEGV
;
5329 Fvertical_motion (make_number (n
), window
);
5333 SET_PT_BOTH (opoint
, opoint_byte
);
5340 xsignal0 (Qbeginning_of_buffer
);
5345 int this_scroll_margin
= scroll_margin
;
5347 /* Don't use a scroll margin that is negative or too large. */
5348 if (this_scroll_margin
< 0)
5349 this_scroll_margin
= 0;
5351 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5352 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5354 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5355 w
->start_at_line_beg
= bolp
;
5356 w
->update_mode_line
= Qt
;
5357 XSETFASTINT (w
->last_modified
, 0);
5358 XSETFASTINT (w
->last_overlay_modified
, 0);
5359 /* Set force_start so that redisplay_window will run
5360 the window-scroll-functions. */
5361 w
->force_start
= Qt
;
5363 if (!NILP (Vscroll_preserve_screen_position
)
5364 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5366 SET_PT_BOTH (pos
, pos_byte
);
5367 Fvertical_motion (make_number (original_vpos
), window
);
5369 /* If we scrolled forward, put point enough lines down
5370 that it is outside the scroll margin. */
5375 if (this_scroll_margin
> 0)
5377 SET_PT_BOTH (pos
, pos_byte
);
5378 Fvertical_motion (make_number (this_scroll_margin
), window
);
5384 if (top_margin
<= opoint
)
5385 SET_PT_BOTH (opoint
, opoint_byte
);
5386 else if (!NILP (Vscroll_preserve_screen_position
))
5388 SET_PT_BOTH (pos
, pos_byte
);
5389 Fvertical_motion (make_number (original_vpos
), window
);
5392 SET_PT (top_margin
);
5398 /* If we scrolled backward, put point near the end of the window
5399 but not within the scroll margin. */
5400 SET_PT_BOTH (pos
, pos_byte
);
5401 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5402 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5405 bottom_margin
= PT
+ 1;
5407 if (bottom_margin
> opoint
)
5408 SET_PT_BOTH (opoint
, opoint_byte
);
5411 if (!NILP (Vscroll_preserve_screen_position
))
5413 SET_PT_BOTH (pos
, pos_byte
);
5414 Fvertical_motion (make_number (original_vpos
), window
);
5417 Fvertical_motion (make_number (-1), window
);
5426 xsignal0 (Qend_of_buffer
);
5431 /* Scroll selected_window up or down. If N is nil, scroll a
5432 screen-full which is defined as the height of the window minus
5433 next_screen_context_lines. If N is the symbol `-', scroll.
5434 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5435 up. This is the guts of Fscroll_up and Fscroll_down. */
5438 scroll_command (n
, direction
)
5442 int count
= SPECPDL_INDEX ();
5444 xassert (abs (direction
) == 1);
5446 /* If selected window's buffer isn't current, make it current for
5447 the moment. But don't screw up if window_scroll gets an error. */
5448 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5450 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5451 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5453 /* Make redisplay consider other windows than just selected_window. */
5454 ++windows_or_buffers_changed
;
5458 window_scroll (selected_window
, direction
, 1, 0);
5459 else if (EQ (n
, Qminus
))
5460 window_scroll (selected_window
, -direction
, 1, 0);
5463 n
= Fprefix_numeric_value (n
);
5464 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5467 unbind_to (count
, Qnil
);
5470 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5471 doc
: /* Scroll text of current window upward ARG lines.
5472 If ARG is omitted or nil, scroll upward by a near full screen.
5473 A near full screen is `next-screen-context-lines' less than a full screen.
5474 Negative ARG means scroll downward.
5475 If ARG is the atom `-', scroll downward by nearly full screen.
5476 When calling from a program, supply as argument a number, nil, or `-'. */)
5480 scroll_command (arg
, 1);
5484 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5485 doc
: /* Scroll text of current window down ARG lines.
5486 If ARG is omitted or nil, scroll down by a near full screen.
5487 A near full screen is `next-screen-context-lines' less than a full screen.
5488 Negative ARG means scroll upward.
5489 If ARG is the atom `-', scroll upward by nearly full screen.
5490 When calling from a program, supply as argument a number, nil, or `-'. */)
5494 scroll_command (arg
, -1);
5498 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5499 doc
: /* Return the other window for \"other window scroll\" commands.
5500 If `other-window-scroll-buffer' is non-nil, a window
5501 showing that buffer is used.
5502 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5503 specifies the window. This takes precedence over
5504 `other-window-scroll-buffer'. */)
5509 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5510 && !NILP (Vminibuf_scroll_window
))
5511 window
= Vminibuf_scroll_window
;
5512 /* If buffer is specified, scroll that buffer. */
5513 else if (!NILP (Vother_window_scroll_buffer
))
5515 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5517 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5521 /* Nothing specified; look for a neighboring window on the same
5523 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5525 if (EQ (window
, selected_window
))
5526 /* That didn't get us anywhere; look for a window on another
5529 window
= Fnext_window (window
, Qnil
, Qt
);
5530 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5531 && ! EQ (window
, selected_window
));
5534 CHECK_LIVE_WINDOW (window
);
5536 if (EQ (window
, selected_window
))
5537 error ("There is no other window");
5542 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5543 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5544 A near full screen is `next-screen-context-lines' less than a full screen.
5545 The next window is the one below the current one; or the one at the top
5546 if the current one is at the bottom. 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 `-'.
5550 If `other-window-scroll-buffer' is non-nil, scroll the window
5551 showing that buffer, popping the buffer up if necessary.
5552 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5553 specifies the window to scroll. This takes precedence over
5554 `other-window-scroll-buffer'. */)
5560 int count
= SPECPDL_INDEX ();
5562 window
= Fother_window_for_scrolling ();
5563 w
= XWINDOW (window
);
5565 /* Don't screw up if window_scroll gets an error. */
5566 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5567 ++windows_or_buffers_changed
;
5569 Fset_buffer (w
->buffer
);
5570 SET_PT (marker_position (w
->pointm
));
5573 window_scroll (window
, 1, 1, 1);
5574 else if (EQ (arg
, Qminus
))
5575 window_scroll (window
, -1, 1, 1);
5581 window_scroll (window
, XINT (arg
), 0, 1);
5584 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5585 unbind_to (count
, Qnil
);
5590 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5591 doc
: /* Scroll selected window display ARG columns left.
5592 Default for ARG is window width minus 2.
5593 Value is the total amount of leftward horizontal scrolling in
5594 effect after the change.
5595 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5596 lower bound for automatic scrolling, i.e. automatic scrolling
5597 will not scroll a window to a column less than the value returned
5598 by this function. This happens in an interactive call. */)
5600 register Lisp_Object arg
, set_minimum
;
5604 struct window
*w
= XWINDOW (selected_window
);
5607 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5609 arg
= Fprefix_numeric_value (arg
);
5611 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5612 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5614 if (!NILP (set_minimum
))
5615 w
->min_hscroll
= w
->hscroll
;
5620 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5621 doc
: /* Scroll selected window display ARG columns right.
5622 Default for ARG is window width minus 2.
5623 Value is the total amount of leftward horizontal scrolling in
5624 effect after the change.
5625 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5626 lower bound for automatic scrolling, i.e. automatic scrolling
5627 will not scroll a window to a column less than the value returned
5628 by this function. This happens in an interactive call. */)
5630 register Lisp_Object arg
, set_minimum
;
5634 struct window
*w
= XWINDOW (selected_window
);
5637 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5639 arg
= Fprefix_numeric_value (arg
);
5641 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5642 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5644 if (!NILP (set_minimum
))
5645 w
->min_hscroll
= w
->hscroll
;
5650 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5651 doc
: /* Return the window which was selected when entering the minibuffer.
5652 Returns nil, if current window is not a minibuffer window. */)
5655 if (minibuf_level
> 0
5656 && MINI_WINDOW_P (XWINDOW (selected_window
))
5657 && WINDOW_LIVE_P (minibuf_selected_window
))
5658 return minibuf_selected_window
;
5663 /* Value is the number of lines actually displayed in window W,
5664 as opposed to its height. */
5667 displayed_window_lines (w
)
5671 struct text_pos start
;
5672 int height
= window_box_height (w
);
5673 struct buffer
*old_buffer
;
5676 if (XBUFFER (w
->buffer
) != current_buffer
)
5678 old_buffer
= current_buffer
;
5679 set_buffer_internal (XBUFFER (w
->buffer
));
5684 /* In case W->start is out of the accessible range, do something
5685 reasonable. This happens in Info mode when Info-scroll-down
5686 calls (recenter -1) while W->start is 1. */
5687 if (XMARKER (w
->start
)->charpos
< BEGV
)
5688 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5689 else if (XMARKER (w
->start
)->charpos
> ZV
)
5690 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5692 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5694 start_display (&it
, w
, start
);
5695 move_it_vertically (&it
, height
);
5696 bottom_y
= line_bottom_y (&it
);
5698 /* rms: On a non-window display,
5699 the value of it.vpos at the bottom of the screen
5700 seems to be 1 larger than window_box_height (w).
5701 This kludge fixes a bug whereby (move-to-window-line -1)
5702 when ZV is on the last screen line
5703 moves to the previous screen line instead of the last one. */
5704 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5707 /* Add in empty lines at the bottom of the window. */
5708 if (bottom_y
< height
)
5710 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5711 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5715 set_buffer_internal (old_buffer
);
5721 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5722 doc
: /* Center point in window and redisplay frame.
5723 With prefix argument ARG, recenter putting point on screen line ARG
5724 relative to the current window. If ARG is negative, it counts up from the
5725 bottom of the window. (ARG should be less than the height of the window.)
5727 If ARG is omitted or nil, erase the entire frame and then redraw with point
5728 in the center of the current window. If `auto-resize-tool-bars' is set to
5729 `grow-only', this resets the tool-bar's height to the minimum height needed.
5731 Just C-u as prefix means put point in the center of the window
5732 and redisplay normally--don't erase and redraw the frame. */)
5734 register Lisp_Object arg
;
5736 struct window
*w
= XWINDOW (selected_window
);
5737 struct buffer
*buf
= XBUFFER (w
->buffer
);
5738 struct buffer
*obuf
= current_buffer
;
5740 int charpos
, bytepos
;
5742 int this_scroll_margin
;
5744 /* If redisplay is suppressed due to an error, try again. */
5745 obuf
->display_error_modiff
= 0;
5751 /* Invalidate pixel data calculated for all compositions. */
5752 for (i
= 0; i
< n_compositions
; i
++)
5753 composition_table
[i
]->font
= NULL
;
5755 WINDOW_XFRAME (w
)->minimize_tool_bar_window_p
= 1;
5757 Fredraw_frame (WINDOW_FRAME (w
));
5758 SET_FRAME_GARBAGED (WINDOW_XFRAME (w
));
5761 else if (CONSP (arg
)) /* Just C-u. */
5765 arg
= Fprefix_numeric_value (arg
);
5770 set_buffer_internal (buf
);
5772 /* Do this after making BUF current
5773 in case scroll_margin is buffer-local. */
5774 this_scroll_margin
= max (0, scroll_margin
);
5775 this_scroll_margin
= min (this_scroll_margin
,
5776 XFASTINT (w
->total_lines
) / 4);
5778 /* Handle centering on a graphical frame specially. Such frames can
5779 have variable-height lines and centering point on the basis of
5780 line counts would lead to strange effects. */
5781 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5788 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5789 start_display (&it
, w
, pt
);
5790 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5791 charpos
= IT_CHARPOS (it
);
5792 bytepos
= IT_BYTEPOS (it
);
5799 int extra_line_spacing
;
5800 int h
= window_box_height (w
);
5802 iarg
= - max (-iarg
, this_scroll_margin
);
5804 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5805 start_display (&it
, w
, pt
);
5807 /* Be sure we have the exact height of the full line containing PT. */
5808 move_it_by_lines (&it
, 0, 1);
5810 /* The amount of pixels we have to move back is the window
5811 height minus what's displayed in the line containing PT,
5812 and the lines below. */
5815 move_it_by_lines (&it
, nlines
, 1);
5817 if (it
.vpos
== nlines
)
5821 /* Last line has no newline */
5822 h
-= line_bottom_y (&it
);
5826 /* Don't reserve space for extra line spacing of last line. */
5827 extra_line_spacing
= it
.max_extra_line_spacing
;
5829 /* If we can't move down NLINES lines because we hit
5830 the end of the buffer, count in some empty lines. */
5831 if (it
.vpos
< nlines
)
5834 extra_line_spacing
= it
.extra_line_spacing
;
5835 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5840 /* Now find the new top line (starting position) of the window. */
5841 start_display (&it
, w
, pt
);
5843 move_it_vertically_backward (&it
, h
);
5845 /* If extra line spacing is present, we may move too far
5846 back. This causes the last line to be only partially
5847 visible (which triggers redisplay to recenter that line
5848 in the middle), so move forward.
5849 But ignore extra line spacing on last line, as it is not
5850 considered to be part of the visible height of the line.
5852 h
+= extra_line_spacing
;
5853 while (-it
.current_y
> h
)
5854 move_it_by_lines (&it
, 1, 1);
5856 charpos
= IT_CHARPOS (it
);
5857 bytepos
= IT_BYTEPOS (it
);
5861 struct position pos
;
5863 iarg
= max (iarg
, this_scroll_margin
);
5865 pos
= *vmotion (PT
, -iarg
, w
);
5866 charpos
= pos
.bufpos
;
5867 bytepos
= pos
.bytepos
;
5872 struct position pos
;
5873 int ht
= window_internal_height (w
);
5880 /* Don't let it get into the margin at either top or bottom. */
5881 iarg
= max (iarg
, this_scroll_margin
);
5882 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5884 pos
= *vmotion (PT
, - iarg
, w
);
5885 charpos
= pos
.bufpos
;
5886 bytepos
= pos
.bytepos
;
5889 /* Set the new window start. */
5890 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5891 w
->window_end_valid
= Qnil
;
5893 w
->optional_new_start
= Qt
;
5895 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5896 w
->start_at_line_beg
= Qt
;
5898 w
->start_at_line_beg
= Qnil
;
5900 set_buffer_internal (obuf
);
5905 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5907 doc
: /* Return the height in lines of the text display area of WINDOW.
5908 WINDOW defaults to the selected window.
5909 This doesn't include the mode-line (or header-line if any) or any
5910 partial-height lines in the text display area. */)
5914 struct window
*w
= decode_window (window
);
5915 int pixel_height
= window_box_height (w
);
5916 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5917 return make_number (line_height
);
5922 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5924 doc
: /* Position point relative to window.
5925 With no argument, position point at center of window.
5926 An argument specifies vertical position within the window;
5927 zero means top of window, negative means relative to bottom of window. */)
5931 struct window
*w
= XWINDOW (selected_window
);
5935 int this_scroll_margin
;
5938 window
= selected_window
;
5939 start
= marker_position (w
->start
);
5940 if (start
< BEGV
|| start
> ZV
)
5942 int height
= window_internal_height (w
);
5943 Fvertical_motion (make_number (- (height
/ 2)), window
);
5944 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5945 w
->start_at_line_beg
= Fbolp ();
5946 w
->force_start
= Qt
;
5949 Fgoto_char (w
->start
);
5951 lines
= displayed_window_lines (w
);
5954 this_scroll_margin
= max (0, scroll_margin
);
5955 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5959 XSETFASTINT (arg
, lines
/ 2);
5962 int iarg
= XINT (Fprefix_numeric_value (arg
));
5965 iarg
= iarg
+ lines
;
5967 #if 0 /* This code would prevent move-to-window-line from moving point
5968 to a place inside the scroll margins (which would cause the
5969 next redisplay to scroll). I wrote this code, but then concluded
5970 it is probably better not to install it. However, it is here
5971 inside #if 0 so as not to lose it. -- rms. */
5973 /* Don't let it get into the margin at either top or bottom. */
5974 iarg
= max (iarg
, this_scroll_margin
);
5975 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5978 arg
= make_number (iarg
);
5981 /* Skip past a partially visible first line. */
5983 XSETINT (arg
, XINT (arg
) + 1);
5985 return Fvertical_motion (arg
, window
);
5990 /***********************************************************************
5991 Window Configuration
5992 ***********************************************************************/
5994 struct save_window_data
5996 EMACS_INT size_from_Lisp_Vector_struct
;
5997 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5998 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5999 Lisp_Object frame_tool_bar_lines
;
6000 Lisp_Object selected_frame
;
6001 Lisp_Object current_window
;
6002 Lisp_Object current_buffer
;
6003 Lisp_Object minibuf_scroll_window
;
6004 Lisp_Object minibuf_selected_window
;
6005 Lisp_Object root_window
;
6006 Lisp_Object focus_frame
;
6007 /* Record the values of window-min-width and window-min-height
6008 so that window sizes remain consistent with them. */
6009 Lisp_Object min_width
, min_height
;
6010 /* A vector, each of whose elements is a struct saved_window
6012 Lisp_Object saved_windows
;
6015 /* This is saved as a Lisp_Vector */
6018 /* these first two must agree with struct Lisp_Vector in lisp.h */
6019 EMACS_INT size_from_Lisp_Vector_struct
;
6020 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
6023 Lisp_Object buffer
, start
, pointm
, mark
;
6024 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
6025 Lisp_Object hscroll
, min_hscroll
;
6026 Lisp_Object parent
, prev
;
6027 Lisp_Object start_at_line_beg
;
6028 Lisp_Object display_table
;
6029 Lisp_Object orig_top_line
, orig_total_lines
;
6030 Lisp_Object left_margin_cols
, right_margin_cols
;
6031 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
6032 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
6033 Lisp_Object dedicated
;
6036 #define SAVED_WINDOW_N(swv,n) \
6037 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
6039 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
6040 doc
: /* Return t if OBJECT is a window-configuration object. */)
6044 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
6047 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
6048 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
6052 register struct save_window_data
*data
;
6053 struct Lisp_Vector
*saved_windows
;
6055 CHECK_WINDOW_CONFIGURATION (config
);
6057 data
= (struct save_window_data
*) XVECTOR (config
);
6058 saved_windows
= XVECTOR (data
->saved_windows
);
6059 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6062 DEFUN ("set-window-configuration", Fset_window_configuration
,
6063 Sset_window_configuration
, 1, 1, 0,
6064 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
6065 CONFIGURATION must be a value previously returned
6066 by `current-window-configuration' (which see).
6067 If CONFIGURATION was made from a frame that is now deleted,
6068 only frame-independent values can be restored. In this case,
6069 the return value is nil. Otherwise the value is t. */)
6071 Lisp_Object configuration
;
6073 register struct save_window_data
*data
;
6074 struct Lisp_Vector
*saved_windows
;
6075 Lisp_Object new_current_buffer
;
6080 CHECK_WINDOW_CONFIGURATION (configuration
);
6082 data
= (struct save_window_data
*) XVECTOR (configuration
);
6083 saved_windows
= XVECTOR (data
->saved_windows
);
6085 new_current_buffer
= data
->current_buffer
;
6086 if (NILP (XBUFFER (new_current_buffer
)->name
))
6087 new_current_buffer
= Qnil
;
6090 if (XBUFFER (new_current_buffer
) == current_buffer
)
6091 /* The code further down "preserves point" by saving here PT in
6092 old_point and then setting it later back into PT. When the
6093 current-selected-window and the final-selected-window both show
6094 the current buffer, this suffers from the problem that the
6095 current PT is the window-point of the current-selected-window,
6096 while the final PT is the point of the final-selected-window, so
6097 this copy from one PT to the other would end up moving the
6098 window-point of the final-selected-window to the window-point of
6099 the current-selected-window. So we have to be careful which
6100 point of the current-buffer we copy into old_point. */
6101 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6102 && WINDOWP (selected_window
)
6103 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
6104 && !EQ (selected_window
, data
->current_window
))
6105 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6109 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
6110 point in new_current_buffer as of the last time this buffer was
6111 used. This can be non-deterministic since it can be changed by
6112 things like jit-lock by mere temporary selection of some random
6113 window that happens to show this buffer.
6114 So if possible we want this arbitrary choice of "which point" to
6115 be the one from the to-be-selected-window so as to prevent this
6116 window's cursor from being copied from another window. */
6117 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
6118 /* If current_window = selected_window, its point is in BUF_PT. */
6119 && !EQ (selected_window
, data
->current_window
))
6120 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
6122 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
6125 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
6128 /* If f is a dead frame, don't bother rebuilding its window tree.
6129 However, there is other stuff we should still try to do below. */
6130 if (FRAME_LIVE_P (f
))
6132 register struct window
*w
;
6133 register struct saved_window
*p
;
6134 struct window
*root_window
;
6135 struct window
**leaf_windows
;
6139 /* If the frame has been resized since this window configuration was
6140 made, we change the frame to the size specified in the
6141 configuration, restore the configuration, and then resize it
6142 back. We keep track of the prevailing height in these variables. */
6143 int previous_frame_lines
= FRAME_LINES (f
);
6144 int previous_frame_cols
= FRAME_COLS (f
);
6145 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
6146 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
6148 /* The mouse highlighting code could get screwed up
6149 if it runs during this. */
6152 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
6153 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
6154 change_frame_size (f
, XFASTINT (data
->frame_lines
),
6155 XFASTINT (data
->frame_cols
), 0, 0, 0);
6156 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6157 if (XFASTINT (data
->frame_menu_bar_lines
)
6158 != previous_frame_menu_bar_lines
)
6159 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
6160 #ifdef HAVE_WINDOW_SYSTEM
6161 if (XFASTINT (data
->frame_tool_bar_lines
)
6162 != previous_frame_tool_bar_lines
)
6163 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
6167 /* "Swap out" point from the selected window's buffer
6168 into the window itself. (Normally the pointm of the selected
6169 window holds garbage.) We do this now, before
6170 restoring the window contents, and prevent it from
6171 being done later on when we select a new window. */
6172 if (! NILP (XWINDOW (selected_window
)->buffer
))
6174 w
= XWINDOW (selected_window
);
6175 set_marker_both (w
->pointm
,
6177 BUF_PT (XBUFFER (w
->buffer
)),
6178 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6181 windows_or_buffers_changed
++;
6182 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6184 /* Problem: Freeing all matrices and later allocating them again
6185 is a serious redisplay flickering problem. What we would
6186 really like to do is to free only those matrices not reused
6188 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6190 = (struct window
**) alloca (count_windows (root_window
)
6191 * sizeof (struct window
*));
6192 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6194 /* Temporarily avoid any problems with windows that are smaller
6195 than they are supposed to be. */
6196 window_min_height
= 1;
6197 window_min_width
= 1;
6200 Mark all windows now on frame as "deleted".
6201 Restoring the new configuration "undeletes" any that are in it.
6203 Save their current buffers in their height fields, since we may
6204 need it later, if a buffer saved in the configuration is now
6206 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6208 for (k
= 0; k
< saved_windows
->size
; k
++)
6210 p
= SAVED_WINDOW_N (saved_windows
, k
);
6211 w
= XWINDOW (p
->window
);
6214 if (!NILP (p
->parent
))
6215 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6216 XFASTINT (p
->parent
))->window
;
6220 if (!NILP (p
->prev
))
6222 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6223 XFASTINT (p
->prev
))->window
;
6224 XWINDOW (w
->prev
)->next
= p
->window
;
6229 if (!NILP (w
->parent
))
6231 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6233 XWINDOW (w
->parent
)->vchild
= p
->window
;
6234 XWINDOW (w
->parent
)->hchild
= Qnil
;
6238 XWINDOW (w
->parent
)->hchild
= p
->window
;
6239 XWINDOW (w
->parent
)->vchild
= Qnil
;
6244 /* If we squirreled away the buffer in the window's height,
6246 if (BUFFERP (w
->total_lines
))
6247 w
->buffer
= w
->total_lines
;
6248 w
->left_col
= p
->left_col
;
6249 w
->top_line
= p
->top_line
;
6250 w
->total_cols
= p
->total_cols
;
6251 w
->total_lines
= p
->total_lines
;
6252 w
->hscroll
= p
->hscroll
;
6253 w
->min_hscroll
= p
->min_hscroll
;
6254 w
->display_table
= p
->display_table
;
6255 w
->orig_top_line
= p
->orig_top_line
;
6256 w
->orig_total_lines
= p
->orig_total_lines
;
6257 w
->left_margin_cols
= p
->left_margin_cols
;
6258 w
->right_margin_cols
= p
->right_margin_cols
;
6259 w
->left_fringe_width
= p
->left_fringe_width
;
6260 w
->right_fringe_width
= p
->right_fringe_width
;
6261 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6262 w
->scroll_bar_width
= p
->scroll_bar_width
;
6263 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6264 w
->dedicated
= p
->dedicated
;
6265 XSETFASTINT (w
->last_modified
, 0);
6266 XSETFASTINT (w
->last_overlay_modified
, 0);
6268 /* Reinstall the saved buffer and pointers into it. */
6269 if (NILP (p
->buffer
))
6270 w
->buffer
= p
->buffer
;
6273 if (!NILP (XBUFFER (p
->buffer
)->name
))
6274 /* If saved buffer is alive, install it. */
6276 w
->buffer
= p
->buffer
;
6277 w
->start_at_line_beg
= p
->start_at_line_beg
;
6278 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6279 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6280 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6281 p
->mark
, w
->buffer
);
6283 /* As documented in Fcurrent_window_configuration, don't
6284 restore the location of point in the buffer which was
6285 current when the window configuration was recorded. */
6286 if (!EQ (p
->buffer
, new_current_buffer
)
6287 && XBUFFER (p
->buffer
) == current_buffer
)
6288 Fgoto_char (w
->pointm
);
6290 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6291 /* Else unless window has a live buffer, get one. */
6293 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6294 /* This will set the markers to beginning of visible
6296 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6297 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6298 w
->start_at_line_beg
= Qt
;
6301 /* Keeping window's old buffer; make sure the markers
6304 /* Set window markers at start of visible range. */
6305 if (XMARKER (w
->start
)->buffer
== 0)
6306 set_marker_restricted (w
->start
, make_number (0),
6308 if (XMARKER (w
->pointm
)->buffer
== 0)
6309 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6310 BUF_PT (XBUFFER (w
->buffer
)),
6311 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6312 w
->start_at_line_beg
= Qt
;
6317 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6318 /* Prevent "swapping out point" in the old selected window
6319 using the buffer that has been restored into it.
6320 We already swapped out point that from that window's old buffer. */
6321 selected_window
= Qnil
;
6323 /* Arrange *not* to restore point in the buffer that was
6324 current when the window configuration was saved. */
6325 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6326 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6327 make_number (old_point
),
6328 XWINDOW (data
->current_window
)->buffer
);
6330 Fselect_window (data
->current_window
, Qnil
);
6331 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6334 if (NILP (data
->focus_frame
)
6335 || (FRAMEP (data
->focus_frame
)
6336 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6337 Fredirect_frame_focus (frame
, data
->focus_frame
);
6339 #if 0 /* I don't understand why this is needed, and it causes problems
6340 when the frame's old selected window has been deleted. */
6341 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6342 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6346 /* Set the screen height to the value it had before this function. */
6347 if (previous_frame_lines
!= FRAME_LINES (f
)
6348 || previous_frame_cols
!= FRAME_COLS (f
))
6349 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6351 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6352 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6353 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6355 #ifdef HAVE_WINDOW_SYSTEM
6356 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6357 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6362 /* Now, free glyph matrices in windows that were not reused. */
6363 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6365 if (NILP (leaf_windows
[i
]->buffer
))
6367 /* Assert it's not reused as a combination. */
6368 xassert (NILP (leaf_windows
[i
]->hchild
)
6369 && NILP (leaf_windows
[i
]->vchild
));
6370 free_window_matrices (leaf_windows
[i
]);
6372 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6380 /* Fselect_window will have made f the selected frame, so we
6381 reselect the proper frame here. Fhandle_switch_frame will change the
6382 selected window too, but that doesn't make the call to
6383 Fselect_window above totally superfluous; it still sets f's
6385 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6386 do_switch_frame (data
->selected_frame
, 0, 0);
6388 if (! NILP (Vwindow_configuration_change_hook
)
6389 && ! NILP (Vrun_hooks
))
6390 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6393 if (!NILP (new_current_buffer
))
6394 Fset_buffer (new_current_buffer
);
6396 /* Restore the minimum heights recorded in the configuration. */
6397 window_min_height
= XINT (data
->min_height
);
6398 window_min_width
= XINT (data
->min_width
);
6400 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6401 minibuf_selected_window
= data
->minibuf_selected_window
;
6403 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6406 /* Mark all windows now on frame as deleted
6407 by setting their buffers to nil. */
6410 delete_all_subwindows (w
)
6411 register struct window
*w
;
6413 if (!NILP (w
->next
))
6414 delete_all_subwindows (XWINDOW (w
->next
));
6415 if (!NILP (w
->vchild
))
6416 delete_all_subwindows (XWINDOW (w
->vchild
));
6417 if (!NILP (w
->hchild
))
6418 delete_all_subwindows (XWINDOW (w
->hchild
));
6420 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6422 if (!NILP (w
->buffer
))
6425 /* We set all three of these fields to nil, to make sure that we can
6426 distinguish this dead window from any live window. Live leaf
6427 windows will have buffer set, and combination windows will have
6428 vchild or hchild set. */
6433 Vwindow_list
= Qnil
;
6437 count_windows (window
)
6438 register struct window
*window
;
6440 register int count
= 1;
6441 if (!NILP (window
->next
))
6442 count
+= count_windows (XWINDOW (window
->next
));
6443 if (!NILP (window
->vchild
))
6444 count
+= count_windows (XWINDOW (window
->vchild
));
6445 if (!NILP (window
->hchild
))
6446 count
+= count_windows (XWINDOW (window
->hchild
));
6451 /* Fill vector FLAT with leaf windows under W, starting at index I.
6452 Value is last index + 1. */
6455 get_leaf_windows (w
, flat
, i
)
6457 struct window
**flat
;
6462 if (!NILP (w
->hchild
))
6463 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6464 else if (!NILP (w
->vchild
))
6465 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6469 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6476 /* Return a pointer to the glyph W's physical cursor is on. Value is
6477 null if W's current matrix is invalid, so that no meaningfull glyph
6481 get_phys_cursor_glyph (w
)
6484 struct glyph_row
*row
;
6485 struct glyph
*glyph
;
6487 if (w
->phys_cursor
.vpos
>= 0
6488 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6489 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6491 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6492 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6501 save_window_save (window
, vector
, i
)
6503 struct Lisp_Vector
*vector
;
6506 register struct saved_window
*p
;
6507 register struct window
*w
;
6508 register Lisp_Object tem
;
6510 for (;!NILP (window
); window
= w
->next
)
6512 p
= SAVED_WINDOW_N (vector
, i
);
6513 w
= XWINDOW (window
);
6515 XSETFASTINT (w
->temslot
, i
); i
++;
6517 p
->buffer
= w
->buffer
;
6518 p
->left_col
= w
->left_col
;
6519 p
->top_line
= w
->top_line
;
6520 p
->total_cols
= w
->total_cols
;
6521 p
->total_lines
= w
->total_lines
;
6522 p
->hscroll
= w
->hscroll
;
6523 p
->min_hscroll
= w
->min_hscroll
;
6524 p
->display_table
= w
->display_table
;
6525 p
->orig_top_line
= w
->orig_top_line
;
6526 p
->orig_total_lines
= w
->orig_total_lines
;
6527 p
->left_margin_cols
= w
->left_margin_cols
;
6528 p
->right_margin_cols
= w
->right_margin_cols
;
6529 p
->left_fringe_width
= w
->left_fringe_width
;
6530 p
->right_fringe_width
= w
->right_fringe_width
;
6531 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6532 p
->scroll_bar_width
= w
->scroll_bar_width
;
6533 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6534 p
->dedicated
= w
->dedicated
;
6535 if (!NILP (w
->buffer
))
6537 /* Save w's value of point in the window configuration.
6538 If w is the selected window, then get the value of point
6539 from the buffer; pointm is garbage in the selected window. */
6540 if (EQ (window
, selected_window
))
6542 p
->pointm
= Fmake_marker ();
6543 set_marker_both (p
->pointm
, w
->buffer
,
6544 BUF_PT (XBUFFER (w
->buffer
)),
6545 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6548 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6550 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6551 p
->start_at_line_beg
= w
->start_at_line_beg
;
6553 tem
= XBUFFER (w
->buffer
)->mark
;
6554 p
->mark
= Fcopy_marker (tem
, Qnil
);
6561 p
->start_at_line_beg
= Qnil
;
6564 if (NILP (w
->parent
))
6567 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6572 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6574 if (!NILP (w
->vchild
))
6575 i
= save_window_save (w
->vchild
, vector
, i
);
6576 if (!NILP (w
->hchild
))
6577 i
= save_window_save (w
->hchild
, vector
, i
);
6583 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6584 Scurrent_window_configuration
, 0, 1, 0,
6585 doc
: /* Return an object representing the current window configuration of FRAME.
6586 If FRAME is nil or omitted, use the selected frame.
6587 This describes the number of windows, their sizes and current buffers,
6588 and for each displayed buffer, where display starts, and the positions of
6589 point and mark. An exception is made for point in the current buffer:
6590 its value is -not- saved.
6591 This also records the currently selected frame, and FRAME's focus
6592 redirection (see `redirect-frame-focus'). */)
6596 register Lisp_Object tem
;
6597 register int n_windows
;
6598 register struct save_window_data
*data
;
6599 register struct Lisp_Vector
*vec
;
6604 frame
= selected_frame
;
6605 CHECK_LIVE_FRAME (frame
);
6608 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6609 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6610 data
= (struct save_window_data
*)vec
;
6612 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6613 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6614 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6615 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6616 data
->selected_frame
= selected_frame
;
6617 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6618 XSETBUFFER (data
->current_buffer
, current_buffer
);
6619 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6620 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6621 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6622 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6623 XSETINT (data
->min_height
, window_min_height
);
6624 XSETINT (data
->min_width
, window_min_width
);
6625 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6626 data
->saved_windows
= tem
;
6627 for (i
= 0; i
< n_windows
; i
++)
6628 XVECTOR (tem
)->contents
[i
]
6629 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6630 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6631 XSETWINDOW_CONFIGURATION (tem
, data
);
6635 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6637 doc
: /* Execute BODY, preserving window sizes and contents.
6638 Return the value of the last form in BODY.
6639 Restore which buffer appears in which window, where display starts,
6640 and the value of point and mark for each window.
6641 Also restore the choice of selected window.
6642 Also restore which buffer is current.
6643 Does not restore the value of point in current buffer.
6644 usage: (save-window-excursion BODY ...) */)
6648 register Lisp_Object val
;
6649 register int count
= SPECPDL_INDEX ();
6651 record_unwind_protect (Fset_window_configuration
,
6652 Fcurrent_window_configuration (Qnil
));
6653 val
= Fprogn (args
);
6654 return unbind_to (count
, val
);
6659 /***********************************************************************
6661 ***********************************************************************/
6667 Lisp_Object tail
= Qnil
;
6668 Lisp_Object result
= Qnil
;
6675 if (!NILP (w
->hchild
))
6676 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6677 window_tree (XWINDOW (w
->hchild
))));
6678 else if (!NILP (w
->vchild
))
6679 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6680 window_tree (XWINDOW (w
->vchild
))));
6684 result
= tail
= Fcons (wn
, Qnil
);
6688 XSETCDR (tail
, Fcons (wn
, Qnil
));
6692 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6700 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6702 doc
: /* Return the window tree for frame FRAME.
6704 The return value is a list of the form (ROOT MINI), where ROOT
6705 represents the window tree of the frame's root window, and MINI
6706 is the frame's minibuffer window.
6708 If the root window is not split, ROOT is the root window itself.
6709 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6710 horizontal split, and t for a vertical split, EDGES gives the combined
6711 size and position of the subwindows in the split, and the rest of the
6712 elements are the subwindows in the split. Each of the subwindows may
6713 again be a window or a list representing a window split, and so on.
6714 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6716 If FRAME is nil or omitted, return information on the currently
6724 frame
= selected_frame
;
6726 CHECK_FRAME (frame
);
6729 if (!FRAME_LIVE_P (f
))
6732 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6736 /***********************************************************************
6738 ***********************************************************************/
6740 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6742 doc
: /* Set width of marginal areas of window WINDOW.
6743 If WINDOW is nil, set margins of the currently selected window.
6744 Second arg LEFT-WIDTH specifies the number of character cells to
6745 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6746 does the same for the right marginal area. A nil width parameter
6747 means no margin. */)
6748 (window
, left_width
, right_width
)
6749 Lisp_Object window
, left_width
, right_width
;
6751 struct window
*w
= decode_window (window
);
6753 /* Translate negative or zero widths to nil.
6754 Margins that are too wide have to be checked elsewhere. */
6756 if (!NILP (left_width
))
6758 CHECK_NUMBER (left_width
);
6759 if (XINT (left_width
) <= 0)
6763 if (!NILP (right_width
))
6765 CHECK_NUMBER (right_width
);
6766 if (XINT (right_width
) <= 0)
6770 if (!EQ (w
->left_margin_cols
, left_width
)
6771 || !EQ (w
->right_margin_cols
, right_width
))
6773 w
->left_margin_cols
= left_width
;
6774 w
->right_margin_cols
= right_width
;
6776 adjust_window_margins (w
);
6778 ++windows_or_buffers_changed
;
6779 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6786 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6788 doc
: /* Get width of marginal areas of window WINDOW.
6789 If WINDOW is omitted or nil, use the currently selected window.
6790 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6791 If a marginal area does not exist, its width will be returned
6796 struct window
*w
= decode_window (window
);
6797 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6802 /***********************************************************************
6804 ***********************************************************************/
6806 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6808 doc
: /* Set the fringe widths of window WINDOW.
6809 If WINDOW is nil, set the fringe widths of the currently selected
6811 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6812 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6813 fringe width. If a fringe width arg is nil, that means to use the
6814 frame's default fringe width. Default fringe widths can be set with
6815 the command `set-fringe-style'.
6816 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6817 outside of the display margins. By default, fringes are drawn between
6818 display marginal areas and the text area. */)
6819 (window
, left_width
, right_width
, outside_margins
)
6820 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6822 struct window
*w
= decode_window (window
);
6824 if (!NILP (left_width
))
6825 CHECK_NATNUM (left_width
);
6826 if (!NILP (right_width
))
6827 CHECK_NATNUM (right_width
);
6829 /* Do nothing on a tty. */
6830 if (FRAME_WINDOW_P (WINDOW_XFRAME (w
))
6831 && (!EQ (w
->left_fringe_width
, left_width
)
6832 || !EQ (w
->right_fringe_width
, right_width
)
6833 || !EQ (w
->fringes_outside_margins
, outside_margins
)))
6835 w
->left_fringe_width
= left_width
;
6836 w
->right_fringe_width
= right_width
;
6837 w
->fringes_outside_margins
= outside_margins
;
6839 adjust_window_margins (w
);
6841 clear_glyph_matrix (w
->current_matrix
);
6842 w
->window_end_valid
= Qnil
;
6844 ++windows_or_buffers_changed
;
6845 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6852 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6854 doc
: /* Get width of fringes of window WINDOW.
6855 If WINDOW is omitted or nil, use the currently selected window.
6856 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6860 struct window
*w
= decode_window (window
);
6862 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6863 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6864 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6865 ? Qt
: Qnil
), Qnil
)));
6870 /***********************************************************************
6872 ***********************************************************************/
6874 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6876 doc
: /* Set width and type of scroll bars of window WINDOW.
6877 If window is nil, set scroll bars of the currently selected window.
6878 Second parameter WIDTH specifies the pixel width for the scroll bar;
6879 this is automatically adjusted to a multiple of the frame column width.
6880 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6881 bar: left, right, or nil.
6882 If WIDTH is nil, use the frame's scroll-bar width.
6883 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6884 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6885 (window
, width
, vertical_type
, horizontal_type
)
6886 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6888 struct window
*w
= decode_window (window
);
6892 CHECK_NATNUM (width
);
6894 if (XINT (width
) == 0)
6895 vertical_type
= Qnil
;
6898 if (!(EQ (vertical_type
, Qnil
)
6899 || EQ (vertical_type
, Qleft
)
6900 || EQ (vertical_type
, Qright
)
6901 || EQ (vertical_type
, Qt
)))
6902 error ("Invalid type of vertical scroll bar");
6904 if (!EQ (w
->scroll_bar_width
, width
)
6905 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6907 w
->scroll_bar_width
= width
;
6908 w
->vertical_scroll_bar_type
= vertical_type
;
6910 adjust_window_margins (w
);
6912 clear_glyph_matrix (w
->current_matrix
);
6913 w
->window_end_valid
= Qnil
;
6915 ++windows_or_buffers_changed
;
6916 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6923 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6925 doc
: /* Get width and type of scroll bars of window WINDOW.
6926 If WINDOW is omitted or nil, use the currently selected window.
6927 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6928 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6933 struct window
*w
= decode_window (window
);
6934 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6935 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6936 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6937 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6938 Fcons (w
->vertical_scroll_bar_type
,
6939 Fcons (Qnil
, Qnil
))));
6944 /***********************************************************************
6946 ***********************************************************************/
6948 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6949 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6950 Use the selected window if WINDOW is nil or omitted.
6951 Normally, value is a multiple of the canonical character height of WINDOW;
6952 optional second arg PIXELS-P means value is measured in pixels. */)
6954 Lisp_Object window
, pixels_p
;
6961 window
= selected_window
;
6963 CHECK_WINDOW (window
);
6964 w
= XWINDOW (window
);
6965 f
= XFRAME (w
->frame
);
6967 if (FRAME_WINDOW_P (f
))
6968 result
= (NILP (pixels_p
)
6969 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6970 : make_number (-w
->vscroll
));
6972 result
= make_number (0);
6977 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6979 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6980 WINDOW nil means use the selected window. Normally, VSCROLL is a
6981 non-negative multiple of the canonical character height of WINDOW;
6982 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6983 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6984 corresponds to an integral number of pixels. The return value is the
6985 result of this rounding.
6986 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6987 (window
, vscroll
, pixels_p
)
6988 Lisp_Object window
, vscroll
, pixels_p
;
6994 window
= selected_window
;
6996 CHECK_WINDOW (window
);
6997 CHECK_NUMBER_OR_FLOAT (vscroll
);
6999 w
= XWINDOW (window
);
7000 f
= XFRAME (w
->frame
);
7002 if (FRAME_WINDOW_P (f
))
7004 int old_dy
= w
->vscroll
;
7006 w
->vscroll
= - (NILP (pixels_p
)
7007 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
7008 : XFLOATINT (vscroll
));
7009 w
->vscroll
= min (w
->vscroll
, 0);
7011 if (w
->vscroll
!= old_dy
)
7013 /* Adjust glyph matrix of the frame if the virtual display
7014 area becomes larger than before. */
7015 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
7018 /* Prevent redisplay shortcuts. */
7019 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
7023 return Fwindow_vscroll (window
, pixels_p
);
7027 /* Call FN for all leaf windows on frame F. FN is called with the
7028 first argument being a pointer to the leaf window, and with
7029 additional argument USER_DATA. Stops when FN returns 0. */
7032 foreach_window (f
, fn
, user_data
)
7034 int (* fn
) P_ ((struct window
*, void *));
7037 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
7038 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
7039 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
7043 /* Helper function for foreach_window. Call FN for all leaf windows
7044 reachable from W. FN is called with the first argument being a
7045 pointer to the leaf window, and with additional argument USER_DATA.
7046 Stop when FN returns 0. Value is 0 if stopped by FN. */
7049 foreach_window_1 (w
, fn
, user_data
)
7051 int (* fn
) P_ ((struct window
*, void *));
7056 for (cont
= 1; w
&& cont
;)
7058 if (!NILP (w
->hchild
))
7059 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
7060 else if (!NILP (w
->vchild
))
7061 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
7063 cont
= fn (w
, user_data
);
7065 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
7072 /* Freeze or unfreeze the window start of W unless it is a
7073 mini-window or the selected window. FREEZE_P non-null means freeze
7074 the window start. */
7077 freeze_window_start (w
, freeze_p
)
7081 if (w
== XWINDOW (selected_window
)
7082 || MINI_WINDOW_P (w
)
7083 || (MINI_WINDOW_P (XWINDOW (selected_window
))
7084 && ! NILP (Vminibuf_scroll_window
)
7085 && w
== XWINDOW (Vminibuf_scroll_window
)))
7088 w
->frozen_window_start_p
= freeze_p
!= NULL
;
7093 /* Freeze or unfreeze the window starts of all leaf windows on frame
7094 F, except the selected window and a mini-window. FREEZE_P non-zero
7095 means freeze the window start. */
7098 freeze_window_starts (f
, freeze_p
)
7102 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
7106 /***********************************************************************
7108 ***********************************************************************/
7110 /* Return 1 if window configurations C1 and C2
7111 describe the same state of affairs. This is used by Fequal. */
7114 compare_window_configurations (c1
, c2
, ignore_positions
)
7116 int ignore_positions
;
7118 register struct save_window_data
*d1
, *d2
;
7119 struct Lisp_Vector
*sw1
, *sw2
;
7122 CHECK_WINDOW_CONFIGURATION (c1
);
7123 CHECK_WINDOW_CONFIGURATION (c2
);
7125 d1
= (struct save_window_data
*) XVECTOR (c1
);
7126 d2
= (struct save_window_data
*) XVECTOR (c2
);
7127 sw1
= XVECTOR (d1
->saved_windows
);
7128 sw2
= XVECTOR (d2
->saved_windows
);
7130 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
7132 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
7134 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
7136 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
7138 /* Don't compare the current_window field directly.
7139 Instead see w1_is_current and w2_is_current, below. */
7140 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
7142 if (! ignore_positions
)
7144 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
7146 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
7149 /* Don't compare the root_window field.
7150 We don't require the two configurations
7151 to use the same window object,
7152 and the two root windows must be equivalent
7153 if everything else compares equal. */
7154 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
7156 if (! EQ (d1
->min_width
, d2
->min_width
))
7158 if (! EQ (d1
->min_height
, d2
->min_height
))
7161 /* Verify that the two confis have the same number of windows. */
7162 if (sw1
->size
!= sw2
->size
)
7165 for (i
= 0; i
< sw1
->size
; i
++)
7167 struct saved_window
*p1
, *p2
;
7168 int w1_is_current
, w2_is_current
;
7170 p1
= SAVED_WINDOW_N (sw1
, i
);
7171 p2
= SAVED_WINDOW_N (sw2
, i
);
7173 /* Verify that the current windows in the two
7174 configurations correspond to each other. */
7175 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7176 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7178 if (w1_is_current
!= w2_is_current
)
7181 /* Verify that the corresponding windows do match. */
7182 if (! EQ (p1
->buffer
, p2
->buffer
))
7184 if (! EQ (p1
->left_col
, p2
->left_col
))
7186 if (! EQ (p1
->top_line
, p2
->top_line
))
7188 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7190 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7192 if (! EQ (p1
->display_table
, p2
->display_table
))
7194 if (! EQ (p1
->parent
, p2
->parent
))
7196 if (! EQ (p1
->prev
, p2
->prev
))
7198 if (! ignore_positions
)
7200 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7202 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7204 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7206 if (NILP (Fequal (p1
->start
, p2
->start
)))
7208 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7210 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7213 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7215 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7217 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7219 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7221 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7223 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7225 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7232 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7233 Scompare_window_configurations
, 2, 2, 0,
7234 doc
: /* Compare two window configurations as regards the structure of windows.
7235 This function ignores details such as the values of point and mark
7236 and scrolling positions. */)
7240 if (compare_window_configurations (x
, y
, 1))
7248 struct frame
*f
= make_terminal_frame ();
7249 XSETFRAME (selected_frame
, f
);
7250 Vterminal_frame
= selected_frame
;
7251 minibuf_window
= f
->minibuffer_window
;
7252 selected_window
= f
->selected_window
;
7253 last_nonminibuf_frame
= f
;
7255 window_initialized
= 1;
7261 Vwindow_list
= Qnil
;
7267 Qscroll_up
= intern ("scroll-up");
7268 staticpro (&Qscroll_up
);
7270 Qscroll_down
= intern ("scroll-down");
7271 staticpro (&Qscroll_down
);
7273 Qwindow_size_fixed
= intern ("window-size-fixed");
7274 staticpro (&Qwindow_size_fixed
);
7275 Fset (Qwindow_size_fixed
, Qnil
);
7277 staticpro (&Qwindow_configuration_change_hook
);
7278 Qwindow_configuration_change_hook
7279 = intern ("window-configuration-change-hook");
7281 Qwindowp
= intern ("windowp");
7282 staticpro (&Qwindowp
);
7284 Qwindow_configuration_p
= intern ("window-configuration-p");
7285 staticpro (&Qwindow_configuration_p
);
7287 Qwindow_live_p
= intern ("window-live-p");
7288 staticpro (&Qwindow_live_p
);
7290 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7291 staticpro (&Qtemp_buffer_show_hook
);
7293 staticpro (&Vwindow_list
);
7295 minibuf_selected_window
= Qnil
;
7296 staticpro (&minibuf_selected_window
);
7298 window_scroll_pixel_based_preserve_y
= -1;
7300 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7301 doc
: /* Non-nil means call as function to display a help buffer.
7302 The function is called with one argument, the buffer to be displayed.
7303 Used by `with-output-to-temp-buffer'.
7304 If this function is used, then it must do the entire job of showing
7305 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7306 Vtemp_buffer_show_function
= Qnil
;
7308 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7309 doc
: /* If non-nil, function to call to handle `display-buffer'.
7310 It will receive two args, the buffer and a flag which if non-nil means
7311 that the currently selected window is not acceptable.
7312 It should choose or create a window, display the specified buffer in it,
7313 and return the window.
7314 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7315 work using this function. */);
7316 Vdisplay_buffer_function
= Qnil
;
7318 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7319 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7320 If nil, `display-buffer' will leave the window configuration alone. */);
7321 Veven_window_heights
= Qt
;
7323 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7324 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7325 Vminibuf_scroll_window
= Qnil
;
7327 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7328 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7329 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7330 is displayed in the `mode-line' face. */);
7331 mode_line_in_non_selected_windows
= 1;
7333 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7334 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7335 Vother_window_scroll_buffer
= Qnil
;
7337 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7338 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7341 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7342 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7343 auto_window_vscroll_p
= 1;
7345 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7346 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7347 If the buffer in question is already displayed in a frame, raise that frame. */);
7348 display_buffer_reuse_frames
= 0;
7350 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7351 doc
: /* Function to call to handle automatic new frame creation.
7352 It is called with no arguments and should return a newly created frame.
7354 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7355 where `pop-up-frame-alist' would hold the default frame parameters. */);
7356 Vpop_up_frame_function
= Qnil
;
7358 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7359 doc
: /* *List of buffer names that should have their own special frames.
7360 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7361 if its name is in this list, makes a special frame for it
7362 using `special-display-function'. See also `special-display-regexps'.
7364 An element of the list can be a list instead of just a string.
7365 There are two ways to use a list as an element:
7366 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7367 In the first case, the FRAME-PARAMETERS are pairs of the form
7368 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7369 In the second case, FUNCTION is called with BUFFER as the first argument,
7370 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7371 All this is done by the function found in `special-display-function'.
7373 If the specified frame parameters include (same-buffer . t), the
7374 buffer is displayed in the currently selected window. Otherwise, if
7375 they include (same-frame . t), the buffer is displayed in a new window
7376 in the currently selected frame.
7378 If this variable appears \"not to work\", because you add a name to it
7379 but that buffer still appears in the selected window, look at the
7380 values of `same-window-buffer-names' and `same-window-regexps'.
7381 Those variables take precedence over this one. */);
7382 Vspecial_display_buffer_names
= Qnil
;
7384 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7385 doc
: /* *List of regexps saying which buffers should have their own special frames.
7386 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7387 if any regexp in this list matches the buffer name, it makes a
7388 special frame for the buffer by calling `special-display-function'.
7390 An element of the list can be a list instead of just a string.
7391 There are two ways to use a list as an element:
7392 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7393 In the first case, the FRAME-PARAMETERS are pairs of the form
7394 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7395 In the second case, FUNCTION is called with BUFFER as the first argument,
7396 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7397 All this is done by the function found in `special-display-function'.
7399 If the specified frame parameters include (same-buffer . t), the
7400 buffer is displayed in the currently selected window. Otherwise, if
7401 they include (same-frame . t), the buffer is displayed in a new window
7402 in the currently selected frame.
7404 If this variable appears \"not to work\", because you add a regexp to it
7405 but the matching buffers still appear in the selected window, look at the
7406 values of `same-window-buffer-names' and `same-window-regexps'.
7407 Those variables take precedence over this one. */);
7408 Vspecial_display_regexps
= Qnil
;
7410 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7411 doc
: /* Function to call to make a new frame for a special buffer.
7412 It is called with two arguments, the buffer and optional buffer specific
7413 data, and should return a window displaying that buffer.
7414 The default value normally makes a separate frame for the buffer,
7415 using `special-display-frame-alist' to specify the frame parameters.
7416 But if the buffer specific data includes (same-buffer . t) then the
7417 buffer is displayed in the current selected window.
7418 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7419 a new window in the currently selected frame.
7421 A buffer is special if it is listed in `special-display-buffer-names'
7422 or matches a regexp in `special-display-regexps'. */);
7423 Vspecial_display_function
= Qnil
;
7425 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7426 doc
: /* *List of buffer names that should appear in the selected window.
7427 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7428 switches to it in the selected window, rather than making it appear
7429 in some other window.
7431 An element of the list can be a cons cell instead of just a string.
7432 Then the car must be a string, which specifies the buffer name.
7433 This is for compatibility with `special-display-buffer-names';
7434 the cdr of the cons cell is ignored.
7436 See also `same-window-regexps'. */);
7437 Vsame_window_buffer_names
= Qnil
;
7439 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7440 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7441 If a buffer name matches one of these regexps, then displaying it
7442 using `display-buffer' or `pop-to-buffer' switches to it
7443 in the selected window, rather than making it appear in some other window.
7445 An element of the list can be a cons cell instead of just a string.
7446 Then the car must be a string, which specifies the buffer name.
7447 This is for compatibility with `special-display-buffer-names';
7448 the cdr of the cons cell is ignored.
7450 See also `same-window-buffer-names'. */);
7451 Vsame_window_regexps
= Qnil
;
7453 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7454 doc
: /* *Non-nil means display-buffer should make new windows. */);
7457 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7458 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7459 next_screen_context_lines
= 2;
7461 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7462 doc
: /* *A window must be at least this tall to be eligible for splitting
7463 by `display-buffer'. The value is in line units.
7464 If there is only one window, it is split regardless of this value. */);
7465 split_height_threshold
= 500;
7467 DEFVAR_INT ("window-min-height", &window_min_height
,
7468 doc
: /* *Delete any window less than this tall (including its mode line).
7469 The value is in line units. */);
7470 window_min_height
= 4;
7472 DEFVAR_INT ("window-min-width", &window_min_width
,
7473 doc
: /* *Delete any window less than this wide (measured in characters). */);
7474 window_min_width
= 10;
7476 DEFVAR_LISP ("scroll-preserve-screen-position",
7477 &Vscroll_preserve_screen_position
,
7478 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7479 A value of nil means point does not keep its screen position except
7480 at the scroll margin or window boundary respectively.
7481 A value of t means point keeps its screen position if the scroll
7482 command moved it vertically out of the window, e.g. when scrolling
7484 Any other value means point always keeps its screen position. */);
7485 Vscroll_preserve_screen_position
= Qnil
;
7487 DEFVAR_LISP ("window-configuration-change-hook",
7488 &Vwindow_configuration_change_hook
,
7489 doc
: /* Functions to call when window configuration changes.
7490 The selected frame is the one whose configuration has changed. */);
7491 Vwindow_configuration_change_hook
= Qnil
;
7493 defsubr (&Sselected_window
);
7494 defsubr (&Sminibuffer_window
);
7495 defsubr (&Swindow_minibuffer_p
);
7496 defsubr (&Swindowp
);
7497 defsubr (&Swindow_live_p
);
7498 defsubr (&Spos_visible_in_window_p
);
7499 defsubr (&Swindow_line_height
);
7500 defsubr (&Swindow_buffer
);
7501 defsubr (&Swindow_height
);
7502 defsubr (&Swindow_width
);
7503 defsubr (&Swindow_hscroll
);
7504 defsubr (&Sset_window_hscroll
);
7505 defsubr (&Swindow_redisplay_end_trigger
);
7506 defsubr (&Sset_window_redisplay_end_trigger
);
7507 defsubr (&Swindow_edges
);
7508 defsubr (&Swindow_pixel_edges
);
7509 defsubr (&Swindow_inside_edges
);
7510 defsubr (&Swindow_inside_pixel_edges
);
7511 defsubr (&Scoordinates_in_window_p
);
7512 defsubr (&Swindow_at
);
7513 defsubr (&Swindow_point
);
7514 defsubr (&Swindow_start
);
7515 defsubr (&Swindow_end
);
7516 defsubr (&Sset_window_point
);
7517 defsubr (&Sset_window_start
);
7518 defsubr (&Swindow_dedicated_p
);
7519 defsubr (&Sset_window_dedicated_p
);
7520 defsubr (&Swindow_display_table
);
7521 defsubr (&Sset_window_display_table
);
7522 defsubr (&Snext_window
);
7523 defsubr (&Sprevious_window
);
7524 defsubr (&Sother_window
);
7525 defsubr (&Sget_lru_window
);
7526 defsubr (&Sget_largest_window
);
7527 defsubr (&Sget_buffer_window
);
7528 defsubr (&Sdelete_other_windows
);
7529 defsubr (&Sdelete_windows_on
);
7530 defsubr (&Sreplace_buffer_in_windows
);
7531 defsubr (&Sdelete_window
);
7532 defsubr (&Sset_window_buffer
);
7533 defsubr (&Sselect_window
);
7534 defsubr (&Sspecial_display_p
);
7535 defsubr (&Ssame_window_p
);
7536 defsubr (&Sdisplay_buffer
);
7537 defsubr (&Sforce_window_update
);
7538 defsubr (&Ssplit_window
);
7539 defsubr (&Senlarge_window
);
7540 defsubr (&Sshrink_window
);
7541 defsubr (&Sadjust_window_trailing_edge
);
7542 defsubr (&Sscroll_up
);
7543 defsubr (&Sscroll_down
);
7544 defsubr (&Sscroll_left
);
7545 defsubr (&Sscroll_right
);
7546 defsubr (&Sother_window_for_scrolling
);
7547 defsubr (&Sscroll_other_window
);
7548 defsubr (&Sminibuffer_selected_window
);
7549 defsubr (&Srecenter
);
7550 defsubr (&Swindow_text_height
);
7551 defsubr (&Smove_to_window_line
);
7552 defsubr (&Swindow_configuration_p
);
7553 defsubr (&Swindow_configuration_frame
);
7554 defsubr (&Sset_window_configuration
);
7555 defsubr (&Scurrent_window_configuration
);
7556 defsubr (&Ssave_window_excursion
);
7557 defsubr (&Swindow_tree
);
7558 defsubr (&Sset_window_margins
);
7559 defsubr (&Swindow_margins
);
7560 defsubr (&Sset_window_fringes
);
7561 defsubr (&Swindow_fringes
);
7562 defsubr (&Sset_window_scroll_bars
);
7563 defsubr (&Swindow_scroll_bars
);
7564 defsubr (&Swindow_vscroll
);
7565 defsubr (&Sset_window_vscroll
);
7566 defsubr (&Scompare_window_configurations
);
7567 defsubr (&Swindow_list
);
7573 initial_define_key (control_x_map
, '1', "delete-other-windows");
7574 initial_define_key (control_x_map
, '2', "split-window");
7575 initial_define_key (control_x_map
, '0', "delete-window");
7576 initial_define_key (control_x_map
, 'o', "other-window");
7577 initial_define_key (control_x_map
, '^', "enlarge-window");
7578 initial_define_key (control_x_map
, '<', "scroll-left");
7579 initial_define_key (control_x_map
, '>', "scroll-right");
7581 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7582 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7583 initial_define_key (meta_map
, 'v', "scroll-down");
7585 initial_define_key (global_map
, Ctl('L'), "recenter");
7586 initial_define_key (meta_map
, 'r', "move-to-window-line");
7589 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7590 (do not change this comment) */