1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985,86,87, 1993,94,95,96,97,98, 2000,01,02,03,04
4 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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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 Qwindow_size_fixed
;
54 extern Lisp_Object Qleft_margin
, Qright_margin
;
56 static int displayed_window_lines
P_ ((struct window
*));
57 static struct window
*decode_window
P_ ((Lisp_Object
));
58 static int count_windows
P_ ((struct window
*));
59 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
60 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
61 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
62 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
63 static int window_min_size_1
P_ ((struct window
*, int));
64 static int window_min_size
P_ ((struct window
*, int, int, int *));
65 static void size_window
P_ ((Lisp_Object
, int, int, int));
66 static int freeze_window_start
P_ ((struct window
*, void *));
67 static int window_fixed_size_p
P_ ((struct window
*, int, int));
68 static void enlarge_window
P_ ((Lisp_Object
, int, int, int));
69 static Lisp_Object window_list
P_ ((void));
70 static int add_window_to_list
P_ ((struct window
*, void *));
71 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
73 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
75 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
77 static int foreach_window_1
P_ ((struct window
*,
78 int (* fn
) (struct window
*, void *),
80 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
82 /* The value of `window-size-fixed'. */
84 int window_size_fixed
;
86 /* This is the window in which the terminal's cursor should
87 be left when nothing is being done with it. This must
88 always be a leaf window, and its buffer is selected by
89 the top level editing loop at the end of each command.
91 This value is always the same as
92 FRAME_SELECTED_WINDOW (selected_frame). */
94 Lisp_Object selected_window
;
96 /* A list of all windows for use by next_window and Fwindow_list.
97 Functions creating or deleting windows should invalidate this cache
98 by setting it to nil. */
100 Lisp_Object Vwindow_list
;
102 /* The mini-buffer window of the selected frame.
103 Note that you cannot test for mini-bufferness of an arbitrary window
104 by comparing against this; but you can test for mini-bufferness of
105 the selected window. */
107 Lisp_Object minibuf_window
;
109 /* Non-nil means it is the window whose mode line should be
110 shown as the selected window when the minibuffer is selected. */
112 Lisp_Object minibuf_selected_window
;
114 /* Non-nil means it is the window for C-M-v to scroll
115 when the mini-buffer is selected. */
117 Lisp_Object Vminibuf_scroll_window
;
119 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
121 Lisp_Object Vother_window_scroll_buffer
;
123 /* Non-nil means it's function to call to display temp buffers. */
125 Lisp_Object Vtemp_buffer_show_function
;
127 /* Non-zero means to use mode-line-inactive face in all windows but the
128 selected-window and the minibuffer-scroll-window when the
129 minibuffer is active. */
130 int mode_line_in_non_selected_windows
;
132 /* If a window gets smaller than either of these, it is removed. */
134 EMACS_INT window_min_height
;
135 EMACS_INT window_min_width
;
137 /* Nonzero implies Fdisplay_buffer should create windows. */
141 /* Nonzero implies make new frames for Fdisplay_buffer. */
145 /* Nonzero means reuse existing frames for displaying buffers. */
147 int display_buffer_reuse_frames
;
149 /* Non-nil means use this function instead of default */
151 Lisp_Object Vpop_up_frame_function
;
153 /* Function to call to handle Fdisplay_buffer. */
155 Lisp_Object Vdisplay_buffer_function
;
157 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
159 Lisp_Object Veven_window_heights
;
161 /* List of buffer *names* for buffers that should have their own frames. */
163 Lisp_Object Vspecial_display_buffer_names
;
165 /* List of regexps for buffer names that should have their own frames. */
167 Lisp_Object Vspecial_display_regexps
;
169 /* Function to pop up a special frame. */
171 Lisp_Object Vspecial_display_function
;
173 /* List of buffer *names* for buffers to appear in selected window. */
175 Lisp_Object Vsame_window_buffer_names
;
177 /* List of regexps for buffer names to appear in selected window. */
179 Lisp_Object Vsame_window_regexps
;
181 /* Hook run at end of temp_output_buffer_show. */
183 Lisp_Object Qtemp_buffer_show_hook
;
185 /* Fdisplay_buffer always splits the largest window
186 if that window is more than this high. */
188 EMACS_INT split_height_threshold
;
190 /* Number of lines of continuity in scrolling by screenfuls. */
192 EMACS_INT next_screen_context_lines
;
194 /* Incremented for each window created. */
196 static int sequence_number
;
198 /* Nonzero after init_window_once has finished. */
200 static int window_initialized
;
202 /* Hook to run when window config changes. */
204 Lisp_Object Qwindow_configuration_change_hook
;
205 Lisp_Object Vwindow_configuration_change_hook
;
207 /* Nonzero means scroll commands try to put point
208 at the same screen height as previously. */
210 Lisp_Object Vscroll_preserve_screen_position
;
212 #if 0 /* This isn't used anywhere. */
213 /* Nonzero means we can split a frame even if it is "unsplittable". */
214 static int inhibit_frame_unsplittable
;
217 extern EMACS_INT scroll_margin
;
219 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
221 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
222 doc
: /* Returns t if OBJECT is a window. */)
226 return WINDOWP (object
) ? Qt
: Qnil
;
229 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
230 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
234 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
241 register struct window
*p
;
243 p
= allocate_window ();
244 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
245 XSETFASTINT (p
->left_col
, 0);
246 XSETFASTINT (p
->top_line
, 0);
247 XSETFASTINT (p
->total_lines
, 0);
248 XSETFASTINT (p
->total_cols
, 0);
249 XSETFASTINT (p
->hscroll
, 0);
250 XSETFASTINT (p
->min_hscroll
, 0);
251 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
252 p
->start
= Fmake_marker ();
253 p
->pointm
= Fmake_marker ();
254 XSETFASTINT (p
->use_time
, 0);
256 p
->display_table
= Qnil
;
258 p
->pseudo_window_p
= 0;
259 bzero (&p
->cursor
, sizeof (p
->cursor
));
260 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
261 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
262 p
->desired_matrix
= p
->current_matrix
= 0;
263 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
264 p
->phys_cursor_type
= -1;
265 p
->phys_cursor_width
= -1;
266 p
->must_be_updated_p
= 0;
267 XSETFASTINT (p
->window_end_vpos
, 0);
268 XSETFASTINT (p
->window_end_pos
, 0);
269 p
->window_end_valid
= Qnil
;
272 XSETFASTINT (p
->last_point
, 0);
273 p
->frozen_window_start_p
= 0;
274 p
->height_fixed_p
= 0;
275 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
276 p
->left_margin_cols
= Qnil
;
277 p
->right_margin_cols
= Qnil
;
278 p
->left_fringe_width
= Qnil
;
279 p
->right_fringe_width
= Qnil
;
280 p
->fringes_outside_margins
= Qnil
;
281 p
->scroll_bar_width
= Qnil
;
282 p
->vertical_scroll_bar_type
= Qt
;
283 p
->overlay_arrow_bitmap
= 0;
289 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
290 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
293 return selected_window
;
296 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
297 doc
: /* Return the window used now for minibuffers.
298 If the optional argument FRAME is specified, return the minibuffer window
299 used by that frame. */)
304 frame
= selected_frame
;
305 CHECK_LIVE_FRAME (frame
);
306 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
309 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
310 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
311 WINDOW defaults to the selected window. */)
315 struct window
*w
= decode_window (window
);
316 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
320 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
321 Spos_visible_in_window_p
, 0, 3, 0,
322 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
323 Return nil if that position is scrolled vertically out of view.
324 If a character is only partially visible, nil is returned, unless the
325 optional argument PARTIALLY is non-nil.
326 If POS is only out of view because of horizontal scrolling, return non-nil.
327 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
329 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
330 return value is a list (X Y FULLY) where X and Y are the pixel coordinates
331 relative to the top left corner of the window, and FULLY is t if the
332 character after POS is fully visible and nil otherwise. */)
333 (pos
, window
, partially
)
334 Lisp_Object pos
, window
, partially
;
336 register struct window
*w
;
338 register struct buffer
*buf
;
340 Lisp_Object in_window
= Qnil
;
344 w
= decode_window (window
);
345 buf
= XBUFFER (w
->buffer
);
346 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
350 CHECK_NUMBER_COERCE_MARKER (pos
);
353 else if (w
== XWINDOW (selected_window
))
356 posint
= XMARKER (w
->pointm
)->charpos
;
358 /* If position is above window start or outside buffer boundaries,
359 or if window start is out of range, position is not visible. */
360 if (posint
>= CHARPOS (top
)
361 && posint
<= BUF_ZV (buf
)
362 && CHARPOS (top
) >= BUF_BEGV (buf
)
363 && CHARPOS (top
) <= BUF_ZV (buf
)
364 && pos_visible_p (w
, posint
, &fully_p
, &x
, &y
, NILP (partially
))
365 && (!NILP (partially
) || fully_p
))
368 if (!NILP (in_window
) && !NILP (partially
))
369 in_window
= Fcons (make_number (x
),
370 Fcons (make_number (y
),
371 Fcons (fully_p
? Qt
: Qnil
, Qnil
)));
376 static struct window
*
377 decode_window (window
)
378 register Lisp_Object window
;
381 return XWINDOW (selected_window
);
383 CHECK_LIVE_WINDOW (window
);
384 return XWINDOW (window
);
387 static struct window
*
388 decode_any_window (window
)
389 register Lisp_Object window
;
392 return XWINDOW (selected_window
);
394 CHECK_WINDOW (window
);
395 return XWINDOW (window
);
398 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
399 doc
: /* Return the buffer that WINDOW is displaying.
400 WINDOW defaults to the selected window. */)
404 return decode_window (window
)->buffer
;
407 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
408 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
412 return decode_any_window (window
)->total_lines
;
415 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
416 doc
: /* Return the number of display columns in WINDOW.
417 This is the width that is usable columns available for text in WINDOW.
418 If you want to find out how many columns WINDOW takes up,
419 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
423 return make_number (window_box_text_cols (decode_any_window (window
)));
426 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
427 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
431 return decode_window (window
)->hscroll
;
434 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
435 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
436 Return NCOL. NCOL should be zero or positive.
438 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
439 window so that the location of point becomes invisible. */)
441 Lisp_Object window
, ncol
;
443 struct window
*w
= decode_window (window
);
447 hscroll
= max (0, XINT (ncol
));
449 /* Prevent redisplay shortcuts when changing the hscroll. */
450 if (XINT (w
->hscroll
) != hscroll
)
451 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
453 w
->hscroll
= make_number (hscroll
);
457 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
458 Swindow_redisplay_end_trigger
, 0, 1, 0,
459 doc
: /* Return WINDOW's redisplay end trigger value.
460 See `set-window-redisplay-end-trigger' for more information. */)
464 return decode_window (window
)->redisplay_end_trigger
;
467 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
468 Sset_window_redisplay_end_trigger
, 2, 2, 0,
469 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
470 VALUE should be a buffer position (typically a marker) or nil.
471 If it is a buffer position, then if redisplay in WINDOW reaches a position
472 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
473 with two arguments: WINDOW, and the end trigger value.
474 Afterwards the end-trigger value is reset to nil. */)
476 register Lisp_Object window
, value
;
478 register struct window
*w
;
480 w
= decode_window (window
);
481 w
->redisplay_end_trigger
= value
;
485 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
486 doc
: /* Return a list of the edge coordinates of WINDOW.
487 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
488 RIGHT is one more than the rightmost column occupied by WINDOW,
489 and BOTTOM is one more than the bottommost row occupied by WINDOW.
490 The edges include the space used by the window's scroll bar,
491 display margins, fringes, header line, and mode line, if it has them.
492 To get the edges of the actual text area, use `window-inside-edges'. */)
496 register struct window
*w
= decode_any_window (window
);
498 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
499 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
500 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
501 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
505 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
506 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
507 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
508 RIGHT is one more than the rightmost x position occupied by WINDOW,
509 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
510 The pixel edges include the space used by the window's scroll bar,
511 display margins, fringes, header line, and mode line, if it has them.
512 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
516 register struct window
*w
= decode_any_window (window
);
518 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
519 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
520 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
521 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
525 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
526 doc
: /* Return a list of the edge coordinates of WINDOW.
527 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
528 RIGHT is one more than the rightmost column used by text in WINDOW,
529 and BOTTOM is one more than the bottommost row used by text in WINDOW.
530 The inside edges do not include the space used by the window's scroll bar,
531 display margins, fringes, header line, and/or mode line. */)
535 register struct window
*w
= decode_any_window (window
);
537 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
538 + WINDOW_LEFT_MARGIN_COLS (w
)
539 + WINDOW_LEFT_FRINGE_COLS (w
)),
540 make_number (WINDOW_TOP_EDGE_LINE (w
)
541 + WINDOW_HEADER_LINE_LINES (w
)),
542 make_number (WINDOW_RIGHT_EDGE_COL (w
)
543 - WINDOW_RIGHT_MARGIN_COLS (w
)
544 - WINDOW_RIGHT_FRINGE_COLS (w
)),
545 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
546 - WINDOW_MODE_LINE_LINES (w
)));
549 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
550 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
551 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
552 RIGHT is one more than the rightmost x position used by text in WINDOW,
553 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
554 The inside edges do not include the space used by the window's scroll bar,
555 display margins, fringes, header line, and/or mode line. */)
559 register struct window
*w
= decode_any_window (window
);
561 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
562 + WINDOW_LEFT_MARGIN_WIDTH (w
)
563 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
564 make_number (WINDOW_TOP_EDGE_Y (w
)
565 + WINDOW_HEADER_LINE_HEIGHT (w
)),
566 make_number (WINDOW_RIGHT_EDGE_X (w
)
567 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
568 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
569 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
570 - WINDOW_MODE_LINE_HEIGHT (w
)));
573 /* Test if the character at column *X, row *Y is within window W.
574 If it is not, return ON_NOTHING;
575 if it is in the window's text area,
576 set *x and *y to its location relative to the upper left corner
579 if it is on the window's modeline, return ON_MODE_LINE;
580 if it is on the border between the window and its right sibling,
581 return ON_VERTICAL_BORDER.
582 if it is on a scroll bar,
583 return ON_SCROLL_BAR.
584 if it is on the window's top line, return ON_HEADER_LINE;
585 if it is in left or right fringe of the window,
586 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
587 to window-relative coordinates;
588 if it is in the marginal area to the left/right of the window,
589 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
590 to window-relative coordinates.
592 X and Y are frame relative pixel coordinates. */
594 static enum window_part
595 coordinates_in_window (w
, x
, y
)
596 register struct window
*w
;
599 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
600 int left_x
, right_x
, top_y
, bottom_y
;
601 enum window_part part
;
602 int ux
= FRAME_COLUMN_WIDTH (f
);
603 int x0
= WINDOW_LEFT_EDGE_X (w
);
604 int x1
= WINDOW_RIGHT_EDGE_X (w
);
605 /* The width of the area where the vertical line can be dragged.
606 (Between mode lines for instance. */
607 int grabbable_width
= ux
;
608 int lmargin_width
, rmargin_width
, text_left
, text_right
;
610 if (*x
< x0
|| *x
>= x1
)
613 /* In what's below, we subtract 1 when computing right_x because we
614 want the rightmost pixel, which is given by left_pixel+width-1. */
615 if (w
->pseudo_window_p
)
618 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
619 top_y
= WINDOW_TOP_EDGE_Y (w
);
620 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
624 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
625 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
626 top_y
= WINDOW_TOP_EDGE_Y (w
);
627 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
630 /* Outside any interesting row? */
631 if (*y
< top_y
|| *y
>= bottom_y
)
634 /* On the mode line or header line? If it's near the start of
635 the mode or header line of window that's has a horizontal
636 sibling, say it's on the vertical line. That's to be able
637 to resize windows horizontally in case we're using toolkit
640 if (WINDOW_WANTS_MODELINE_P (w
)
641 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
645 header_vertical_border_check
:
646 /* We're somewhere on the mode line. We consider the place
647 between mode lines of horizontally adjacent mode lines
648 as the vertical border. If scroll bars on the left,
649 return the right window. */
650 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
651 || WINDOW_RIGHTMOST_P (w
))
653 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
654 return ON_VERTICAL_BORDER
;
658 if (abs (*x
- x1
) < grabbable_width
)
659 return ON_VERTICAL_BORDER
;
662 /* Convert X and Y to window relative coordinates.
663 Mode line starts at left edge of window. */
669 if (WINDOW_WANTS_HEADER_LINE_P (w
)
670 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
672 part
= ON_HEADER_LINE
;
673 goto header_vertical_border_check
;
676 /* Outside any interesting column? */
677 if (*x
< left_x
|| *x
> right_x
)
678 return ON_SCROLL_BAR
;
680 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
681 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
683 text_left
= window_box_left (w
, TEXT_AREA
);
684 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
686 if (FRAME_WINDOW_P (f
))
688 if (!w
->pseudo_window_p
689 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
690 && !WINDOW_RIGHTMOST_P (w
)
691 && (abs (*x
- right_x
) < grabbable_width
))
692 return ON_VERTICAL_BORDER
;
696 /* Need to say "*x > right_x" rather than >=, since on character
697 terminals, the vertical line's x coordinate is right_x. */
698 if (!w
->pseudo_window_p
699 && !WINDOW_RIGHTMOST_P (w
)
700 && *x
> right_x
- ux
)
702 /* On the border on the right side of the window? Assume that
703 this area begins at RIGHT_X minus a canonical char width. */
704 return ON_VERTICAL_BORDER
;
710 if (lmargin_width
> 0
711 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
712 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
713 : (*x
< left_x
+ lmargin_width
)))
716 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
717 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
719 return ON_LEFT_MARGIN
;
722 /* Convert X and Y to window-relative pixel coordinates. */
725 return ON_LEFT_FRINGE
;
728 if (*x
>= text_right
)
730 if (rmargin_width
> 0
731 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
732 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
733 : (*x
>= right_x
- rmargin_width
)))
736 if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
737 *x
-= WINDOW_RIGHT_FRINGE_WIDTH (w
);
739 return ON_RIGHT_MARGIN
;
742 /* Convert X and Y to window-relative pixel coordinates. */
743 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
745 return ON_RIGHT_FRINGE
;
748 /* Everything special ruled out - must be on text area */
749 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
755 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
756 Scoordinates_in_window_p
, 2, 2, 0,
757 doc
: /* Return non-nil if COORDINATES are in WINDOW.
758 COORDINATES is a cons of the form (X . Y), X and Y being distances
759 measured in characters from the upper-left corner of the frame.
760 \(0 . 0) denotes the character in the upper left corner of the
762 If COORDINATES are in the text portion of WINDOW,
763 the coordinates relative to the window are returned.
764 If they are in the mode line of WINDOW, `mode-line' is returned.
765 If they are in the top mode line of WINDOW, `header-line' is returned.
766 If they are in the left fringe of WINDOW, `left-fringe' is returned.
767 If they are in the right fringe of WINDOW, `right-fringe' is returned.
768 If they are on the border between WINDOW and its right sibling,
769 `vertical-line' is returned.
770 If they are in the windows's left or right marginal areas, `left-margin'\n\
771 or `right-margin' is returned. */)
772 (coordinates
, window
)
773 register Lisp_Object coordinates
, window
;
780 CHECK_WINDOW (window
);
781 w
= XWINDOW (window
);
782 f
= XFRAME (w
->frame
);
783 CHECK_CONS (coordinates
);
784 lx
= Fcar (coordinates
);
785 ly
= Fcdr (coordinates
);
786 CHECK_NUMBER_OR_FLOAT (lx
);
787 CHECK_NUMBER_OR_FLOAT (ly
);
788 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
789 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
791 switch (coordinates_in_window (w
, &x
, &y
))
797 /* X and Y are now window relative pixel coordinates. Convert
798 them to canonical char units before returning them. */
799 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
800 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
805 case ON_VERTICAL_BORDER
:
806 return Qvertical_line
;
814 case ON_RIGHT_FRINGE
:
815 return Qright_fringe
;
820 case ON_RIGHT_MARGIN
:
821 return Qright_margin
;
824 /* Historically we are supposed to return nil in this case. */
833 /* Callback for foreach_window, used in window_from_coordinates.
834 Check if window W contains coordinates specified by USER_DATA which
835 is actually a pointer to a struct check_window_data CW.
837 Check if window W contains coordinates *CW->x and *CW->y. If it
838 does, return W in *CW->window, as Lisp_Object, and return in
839 *CW->part the part of the window under coordinates *X,*Y. Return
840 zero from this function to stop iterating over windows. */
842 struct check_window_data
846 enum window_part
*part
;
850 check_window_containing (w
, user_data
)
854 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
855 enum window_part found
;
858 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
859 if (found
!= ON_NOTHING
)
862 XSETWINDOW (*cw
->window
, w
);
870 /* Find the window containing frame-relative pixel position X/Y and
871 return it as a Lisp_Object.
873 If X, Y is on one of the window's special `window_part' elements,
874 set *PART to the id of that element, and return X and Y converted
875 to window relative coordinates in WX and WY.
877 If there is no window under X, Y return nil and leave *PART
878 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
880 This function was previously implemented with a loop cycling over
881 windows with Fnext_window, and starting with the frame's selected
882 window. It turned out that this doesn't work with an
883 implementation of next_window using Vwindow_list, because
884 FRAME_SELECTED_WINDOW (F) is not always contained in the window
885 tree of F when this function is called asynchronously from
886 note_mouse_highlight. The original loop didn't terminate in this
890 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
893 enum window_part
*part
;
898 struct check_window_data cw
;
899 enum window_part dummy
;
905 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
906 foreach_window (f
, check_window_containing
, &cw
);
908 /* If not found above, see if it's in the tool bar window, if a tool
912 && WINDOWP (f
->tool_bar_window
)
913 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
914 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
918 window
= f
->tool_bar_window
;
927 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
928 doc
: /* Return window containing coordinates X and Y on FRAME.
929 If omitted, FRAME defaults to the currently selected frame.
930 The top left corner of the frame is considered to be row 0,
933 Lisp_Object x
, y
, frame
;
938 frame
= selected_frame
;
939 CHECK_LIVE_FRAME (frame
);
942 /* Check that arguments are integers or floats. */
943 CHECK_NUMBER_OR_FLOAT (x
);
944 CHECK_NUMBER_OR_FLOAT (y
);
946 return window_from_coordinates (f
,
947 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
948 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
949 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
950 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
954 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
955 doc
: /* Return current value of point in WINDOW.
956 For a nonselected window, this is the value point would have
957 if that window were selected.
959 Note that, when WINDOW is the selected window and its buffer
960 is also currently selected, the value returned is the same as (point).
961 It would be more strictly correct to return the `top-level' value
962 of point, outside of any save-excursion forms.
963 But that is hard to define. */)
967 register struct window
*w
= decode_window (window
);
969 if (w
== XWINDOW (selected_window
)
970 && current_buffer
== XBUFFER (w
->buffer
))
972 return Fmarker_position (w
->pointm
);
975 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
976 doc
: /* Return position at which display currently starts in WINDOW.
977 This is updated by redisplay or by calling `set-window-start'. */)
981 return Fmarker_position (decode_window (window
)->start
);
984 /* This is text temporarily removed from the doc string below.
986 This function returns nil if the position is not currently known.
987 That happens when redisplay is preempted and doesn't finish.
988 If in that case you want to compute where the end of the window would
989 have been if redisplay had finished, do this:
991 (goto-char (window-start window))
992 (vertical-motion (1- (window-height window)) window)
995 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
996 doc
: /* Return position at which display currently ends in WINDOW.
997 This is updated by redisplay, when it runs to completion.
998 Simply changing the buffer text or setting `window-start'
999 does not update this value.
1000 Return nil if there is no recorded value. \(This can happen if the
1001 last redisplay of WINDOW was preempted, and did not finish.)
1002 If UPDATE is non-nil, compute the up-to-date position
1003 if it isn't already recorded. */)
1005 Lisp_Object window
, update
;
1008 struct window
*w
= decode_window (window
);
1014 #if 0 /* This change broke some things. We should make it later. */
1015 /* If we don't know the end position, return nil.
1016 The user can compute it with vertical-motion if he wants to.
1017 It would be nicer to do it automatically,
1018 but that's so slow that it would probably bother people. */
1019 if (NILP (w
->window_end_valid
))
1024 && ! (! NILP (w
->window_end_valid
)
1025 && XFASTINT (w
->last_modified
) >= MODIFF
))
1027 struct text_pos startp
;
1029 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1031 /* In case W->start is out of the range, use something
1032 reasonable. This situation occurred when loading a file with
1033 `-l' containing a call to `rmail' with subsequent other
1034 commands. At the end, W->start happened to be BEG, while
1035 rmail had already narrowed the buffer. */
1036 if (XMARKER (w
->start
)->charpos
< BEGV
)
1037 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1038 else if (XMARKER (w
->start
)->charpos
> ZV
)
1039 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1041 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1043 /* Cannot use Fvertical_motion because that function doesn't
1044 cope with variable-height lines. */
1045 if (b
!= current_buffer
)
1047 old_buffer
= current_buffer
;
1048 set_buffer_internal (b
);
1051 start_display (&it
, w
, startp
);
1052 move_it_vertically (&it
, window_box_height (w
));
1053 if (it
.current_y
< it
.last_visible_y
)
1054 move_it_past_eol (&it
);
1055 value
= make_number (IT_CHARPOS (it
));
1058 set_buffer_internal (old_buffer
);
1061 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1066 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1067 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1070 Lisp_Object window
, pos
;
1072 register struct window
*w
= decode_window (window
);
1074 CHECK_NUMBER_COERCE_MARKER (pos
);
1075 if (w
== XWINDOW (selected_window
)
1076 && XBUFFER (w
->buffer
) == current_buffer
)
1079 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1081 /* We have to make sure that redisplay updates the window to show
1082 the new value of point. */
1083 if (!EQ (window
, selected_window
))
1084 ++windows_or_buffers_changed
;
1089 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1090 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1092 Optional third arg NOFORCE non-nil inhibits next redisplay
1093 from overriding motion of point in order to display at this exact start. */)
1094 (window
, pos
, noforce
)
1095 Lisp_Object window
, pos
, noforce
;
1097 register struct window
*w
= decode_window (window
);
1099 CHECK_NUMBER_COERCE_MARKER (pos
);
1100 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1101 /* this is not right, but much easier than doing what is right. */
1102 w
->start_at_line_beg
= Qnil
;
1104 w
->force_start
= Qt
;
1105 w
->update_mode_line
= Qt
;
1106 XSETFASTINT (w
->last_modified
, 0);
1107 XSETFASTINT (w
->last_overlay_modified
, 0);
1108 if (!EQ (window
, selected_window
))
1109 windows_or_buffers_changed
++;
1114 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1116 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1117 See also `set-window-dedicated-p'. */)
1121 return decode_window (window
)->dedicated
;
1124 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1125 Sset_window_dedicated_p
, 2, 2, 0,
1126 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1127 If it is dedicated, Emacs will not automatically change
1128 which buffer appears in it.
1129 The second argument is the new value for the dedication flag;
1130 non-nil means yes. */)
1132 Lisp_Object window
, arg
;
1134 register struct window
*w
= decode_window (window
);
1138 return w
->dedicated
;
1141 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1143 doc
: /* Return the display-table that WINDOW is using. */)
1147 return decode_window (window
)->display_table
;
1150 /* Get the display table for use on window W. This is either W's
1151 display table or W's buffer's display table. Ignore the specified
1152 tables if they are not valid; if no valid table is specified,
1155 struct Lisp_Char_Table
*
1156 window_display_table (w
)
1159 struct Lisp_Char_Table
*dp
= NULL
;
1161 if (DISP_TABLE_P (w
->display_table
))
1162 dp
= XCHAR_TABLE (w
->display_table
);
1163 else if (BUFFERP (w
->buffer
))
1165 struct buffer
*b
= XBUFFER (w
->buffer
);
1167 if (DISP_TABLE_P (b
->display_table
))
1168 dp
= XCHAR_TABLE (b
->display_table
);
1169 else if (DISP_TABLE_P (Vstandard_display_table
))
1170 dp
= XCHAR_TABLE (Vstandard_display_table
);
1176 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1177 doc
: /* Set WINDOW's display-table to TABLE. */)
1179 register Lisp_Object window
, table
;
1181 register struct window
*w
;
1183 w
= decode_window (window
);
1184 w
->display_table
= table
;
1188 /* Record info on buffer window w is displaying
1189 when it is about to cease to display that buffer. */
1192 register struct window
*w
;
1199 if (b
!= XMARKER (w
->pointm
)->buffer
)
1203 if (w
== XWINDOW (selected_window
)
1204 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1205 /* Do this except when the selected window's buffer
1206 is being removed from some other window. */
1208 /* last_window_start records the start position that this buffer
1209 had in the last window to be disconnected from it.
1210 Now that this statement is unconditional,
1211 it is possible for the buffer to be displayed in the
1212 selected window, while last_window_start reflects another
1213 window which was recently showing the same buffer.
1214 Some people might say that might be a good thing. Let's see. */
1215 b
->last_window_start
= marker_position (w
->start
);
1217 /* Point in the selected window's buffer
1218 is actually stored in that buffer, and the window's pointm isn't used.
1219 So don't clobber point in that buffer. */
1220 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1221 /* This line helps to fix Horsley's testbug.el bug. */
1222 && !(WINDOWP (b
->last_selected_window
)
1223 && w
!= XWINDOW (b
->last_selected_window
)
1224 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1225 temp_set_point_both (b
,
1226 clip_to_bounds (BUF_BEGV (b
),
1227 XMARKER (w
->pointm
)->charpos
,
1229 clip_to_bounds (BUF_BEGV_BYTE (b
),
1230 marker_byte_position (w
->pointm
),
1233 if (WINDOWP (b
->last_selected_window
)
1234 && w
== XWINDOW (b
->last_selected_window
))
1235 b
->last_selected_window
= Qnil
;
1238 /* Put replacement into the window structure in place of old. */
1240 replace_window (old
, replacement
)
1241 Lisp_Object old
, replacement
;
1243 register Lisp_Object tem
;
1244 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1246 /* If OLD is its frame's root_window, then replacement is the new
1247 root_window for that frame. */
1249 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1250 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1252 p
->left_col
= o
->left_col
;
1253 p
->top_line
= o
->top_line
;
1254 p
->total_cols
= o
->total_cols
;
1255 p
->total_lines
= o
->total_lines
;
1256 p
->desired_matrix
= p
->current_matrix
= 0;
1258 bzero (&p
->cursor
, sizeof (p
->cursor
));
1259 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1260 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1261 p
->phys_cursor_type
= -1;
1262 p
->phys_cursor_width
= -1;
1263 p
->must_be_updated_p
= 0;
1264 p
->pseudo_window_p
= 0;
1265 XSETFASTINT (p
->window_end_vpos
, 0);
1266 XSETFASTINT (p
->window_end_pos
, 0);
1267 p
->window_end_valid
= Qnil
;
1268 p
->frozen_window_start_p
= 0;
1269 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1271 p
->next
= tem
= o
->next
;
1273 XWINDOW (tem
)->prev
= replacement
;
1275 p
->prev
= tem
= o
->prev
;
1277 XWINDOW (tem
)->next
= replacement
;
1279 p
->parent
= tem
= o
->parent
;
1282 if (EQ (XWINDOW (tem
)->vchild
, old
))
1283 XWINDOW (tem
)->vchild
= replacement
;
1284 if (EQ (XWINDOW (tem
)->hchild
, old
))
1285 XWINDOW (tem
)->hchild
= replacement
;
1288 /*** Here, if replacement is a vertical combination
1289 and so is its new parent, we should make replacement's
1290 children be children of that parent instead. ***/
1293 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1294 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1296 register Lisp_Object window
;
1298 delete_window (window
);
1300 if (! NILP (Vwindow_configuration_change_hook
)
1301 && ! NILP (Vrun_hooks
))
1302 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1308 delete_window (window
)
1309 register Lisp_Object window
;
1311 register Lisp_Object tem
, parent
, sib
;
1312 register struct window
*p
;
1313 register struct window
*par
;
1316 /* Because this function is called by other C code on non-leaf
1317 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1318 so we can't decode_window here. */
1320 window
= selected_window
;
1322 CHECK_WINDOW (window
);
1323 p
= XWINDOW (window
);
1325 /* It's okay to delete an already-deleted window. */
1326 if (NILP (p
->buffer
)
1328 && NILP (p
->vchild
))
1333 error ("Attempt to delete minibuffer or sole ordinary window");
1334 par
= XWINDOW (parent
);
1336 windows_or_buffers_changed
++;
1337 Vwindow_list
= Qnil
;
1338 f
= XFRAME (WINDOW_FRAME (p
));
1339 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1341 /* Are we trying to delete any frame's selected window? */
1343 Lisp_Object swindow
, pwindow
;
1345 /* See if the frame's selected window is either WINDOW
1346 or any subwindow of it, by finding all that window's parents
1347 and comparing each one with WINDOW. */
1348 swindow
= FRAME_SELECTED_WINDOW (f
);
1353 while (!NILP (pwindow
))
1355 if (EQ (window
, pwindow
))
1357 pwindow
= XWINDOW (pwindow
)->parent
;
1360 /* If the window being deleted is not a parent of SWINDOW,
1361 then SWINDOW is ok as the new selected window. */
1362 if (!EQ (window
, pwindow
))
1364 /* Otherwise, try another window for SWINDOW. */
1365 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1367 /* If we get back to the frame's selected window,
1368 it means there was no acceptable alternative,
1369 so we cannot delete. */
1370 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1371 error ("Cannot delete window");
1374 /* If we need to change SWINDOW, do it. */
1375 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1377 /* If we're about to delete the selected window on the
1378 selected frame, then we should use Fselect_window to select
1379 the new window. On the other hand, if we're about to
1380 delete the selected window on any other frame, we shouldn't do
1381 anything but set the frame's selected_window slot. */
1382 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1383 Fselect_window (swindow
, Qnil
);
1385 FRAME_SELECTED_WINDOW (f
) = swindow
;
1390 /* tem is null for dummy parent windows
1391 (which have inferiors but not any contents themselves) */
1395 unchain_marker (XMARKER (p
->pointm
));
1396 unchain_marker (XMARKER (p
->start
));
1399 /* Free window glyph matrices. It is sure that they are allocated
1400 again when ADJUST_GLYPHS is called. Block input so that expose
1401 events and other events that access glyph matrices are not
1402 processed while we are changing them. */
1404 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1408 XWINDOW (tem
)->prev
= p
->prev
;
1412 XWINDOW (tem
)->next
= p
->next
;
1414 if (EQ (window
, par
->hchild
))
1415 par
->hchild
= p
->next
;
1416 if (EQ (window
, par
->vchild
))
1417 par
->vchild
= p
->next
;
1419 /* Find one of our siblings to give our space to. */
1423 /* If p gives its space to its next sibling, that sibling needs
1424 to have its top/left side pulled back to where p's is.
1425 set_window_{height,width} will re-position the sibling's
1428 XWINDOW (sib
)->top_line
= p
->top_line
;
1429 XWINDOW (sib
)->left_col
= p
->left_col
;
1432 /* Stretch that sibling. */
1433 if (!NILP (par
->vchild
))
1434 set_window_height (sib
,
1435 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1437 if (!NILP (par
->hchild
))
1438 set_window_width (sib
,
1439 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1442 /* If parent now has only one child,
1443 put the child into the parent's place. */
1447 if (NILP (XWINDOW (tem
)->next
))
1448 replace_window (parent
, tem
);
1450 /* Since we may be deleting combination windows, we must make sure that
1451 not only p but all its children have been marked as deleted. */
1452 if (! NILP (p
->hchild
))
1453 delete_all_subwindows (XWINDOW (p
->hchild
));
1454 else if (! NILP (p
->vchild
))
1455 delete_all_subwindows (XWINDOW (p
->vchild
));
1457 /* Mark this window as deleted. */
1458 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1460 /* Adjust glyph matrices. */
1467 /***********************************************************************
1469 ***********************************************************************/
1471 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1472 pointer. This is a callback function for foreach_window, used in
1473 function window_list. */
1476 add_window_to_list (w
, user_data
)
1480 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1482 XSETWINDOW (window
, w
);
1483 *list
= Fcons (window
, *list
);
1488 /* Return a list of all windows, for use by next_window. If
1489 Vwindow_list is a list, return that list. Otherwise, build a new
1490 list, cache it in Vwindow_list, and return that. */
1495 if (!CONSP (Vwindow_list
))
1499 Vwindow_list
= Qnil
;
1500 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1502 Lisp_Object args
[2];
1504 /* We are visiting windows in canonical order, and add
1505 new windows at the front of args[1], which means we
1506 have to reverse this list at the end. */
1508 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1509 args
[0] = Vwindow_list
;
1510 args
[1] = Fnreverse (args
[1]);
1511 Vwindow_list
= Fnconc (2, args
);
1515 return Vwindow_list
;
1519 /* Value is non-zero if WINDOW satisfies the constraints given by
1520 OWINDOW, MINIBUF and ALL_FRAMES.
1522 MINIBUF t means WINDOW may be minibuffer windows.
1523 `lambda' means WINDOW may not be a minibuffer window.
1524 a window means a specific minibuffer window
1526 ALL_FRAMES t means search all frames,
1527 nil means search just current frame,
1528 `visible' means search just visible frames,
1529 0 means search visible and iconified frames,
1530 a window means search the frame that window belongs to,
1531 a frame means consider windows on that frame, only. */
1534 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1535 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1537 struct window
*w
= XWINDOW (window
);
1538 struct frame
*f
= XFRAME (w
->frame
);
1539 int candidate_p
= 1;
1541 if (!BUFFERP (w
->buffer
))
1543 else if (MINI_WINDOW_P (w
)
1544 && (EQ (minibuf
, Qlambda
)
1545 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1547 /* If MINIBUF is `lambda' don't consider any mini-windows.
1548 If it is a window, consider only that one. */
1551 else if (EQ (all_frames
, Qt
))
1553 else if (NILP (all_frames
))
1555 xassert (WINDOWP (owindow
));
1556 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1558 else if (EQ (all_frames
, Qvisible
))
1560 FRAME_SAMPLE_VISIBILITY (f
);
1561 candidate_p
= FRAME_VISIBLE_P (f
);
1563 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1565 FRAME_SAMPLE_VISIBILITY (f
);
1566 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1568 else if (WINDOWP (all_frames
))
1569 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1570 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1571 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1572 else if (FRAMEP (all_frames
))
1573 candidate_p
= EQ (all_frames
, w
->frame
);
1579 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1580 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1584 decode_next_window_args (window
, minibuf
, all_frames
)
1585 Lisp_Object
*window
, *minibuf
, *all_frames
;
1588 *window
= selected_window
;
1590 CHECK_LIVE_WINDOW (*window
);
1592 /* MINIBUF nil may or may not include minibuffers. Decide if it
1594 if (NILP (*minibuf
))
1595 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1596 else if (!EQ (*minibuf
, Qt
))
1599 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1600 => count none of them, or a specific minibuffer window (the
1601 active one) to count. */
1603 /* ALL_FRAMES nil doesn't specify which frames to include. */
1604 if (NILP (*all_frames
))
1605 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1606 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1608 else if (EQ (*all_frames
, Qvisible
))
1610 else if (XFASTINT (*all_frames
) == 0)
1612 else if (FRAMEP (*all_frames
))
1614 else if (!EQ (*all_frames
, Qt
))
1617 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1618 search just current frame, `visible' meaning search just visible
1619 frames, 0 meaning search visible and iconified frames, or a
1620 window, meaning search the frame that window belongs to, or a
1621 frame, meaning consider windows on that frame, only. */
1625 /* Return the next or previous window of WINDOW in canonical ordering
1626 of windows. NEXT_P non-zero means return the next window. See the
1627 documentation string of next-window for the meaning of MINIBUF and
1631 next_window (window
, minibuf
, all_frames
, next_p
)
1632 Lisp_Object window
, minibuf
, all_frames
;
1635 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1637 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1638 return the first window on the frame. */
1639 if (FRAMEP (all_frames
)
1640 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1641 return Fframe_first_window (all_frames
);
1647 /* Find WINDOW in the list of all windows. */
1648 list
= Fmemq (window
, window_list ());
1650 /* Scan forward from WINDOW to the end of the window list. */
1652 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1653 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1656 /* Scan from the start of the window list up to WINDOW. */
1658 for (list
= Vwindow_list
;
1659 CONSP (list
) && !EQ (XCAR (list
), window
);
1661 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1665 window
= XCAR (list
);
1669 Lisp_Object candidate
, list
;
1671 /* Scan through the list of windows for candidates. If there are
1672 candidate windows in front of WINDOW, the last one of these
1673 is the one we want. If there are candidates following WINDOW
1674 in the list, again the last one of these is the one we want. */
1676 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1678 if (EQ (XCAR (list
), window
))
1680 if (WINDOWP (candidate
))
1683 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1685 candidate
= XCAR (list
);
1688 if (WINDOWP (candidate
))
1696 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1697 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1698 If omitted, WINDOW defaults to the selected window.
1700 Optional second arg MINIBUF t means count the minibuffer window even
1701 if not active. MINIBUF nil or omitted means count the minibuffer iff
1702 it is active. MINIBUF neither t nor nil means not to count the
1703 minibuffer even if it is active.
1705 Several frames may share a single minibuffer; if the minibuffer
1706 counts, all windows on all frames that share that minibuffer count
1707 too. Therefore, `next-window' can be used to iterate through the
1708 set of windows even when the minibuffer is on another frame. If the
1709 minibuffer does not count, only windows from WINDOW's frame count.
1711 Optional third arg ALL-FRAMES t means include windows on all frames.
1712 ALL-FRAMES nil or omitted means cycle within the frames as specified
1713 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1714 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1715 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1716 Anything else means restrict to WINDOW's frame.
1718 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1719 `next-window' to iterate through the entire cycle of acceptable
1720 windows, eventually ending up back at the window you started with.
1721 `previous-window' traverses the same cycle, in the reverse order. */)
1722 (window
, minibuf
, all_frames
)
1723 Lisp_Object window
, minibuf
, all_frames
;
1725 return next_window (window
, minibuf
, all_frames
, 1);
1729 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1730 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1731 If omitted, WINDOW defaults to the selected window.
1733 Optional second arg MINIBUF t means count the minibuffer window even
1734 if not active. MINIBUF nil or omitted means count the minibuffer iff
1735 it is active. MINIBUF neither t nor nil means not to count the
1736 minibuffer even if it is active.
1738 Several frames may share a single minibuffer; if the minibuffer
1739 counts, all windows on all frames that share that minibuffer count
1740 too. Therefore, `previous-window' can be used to iterate through
1741 the set of windows even when the minibuffer is on another frame. If
1742 the minibuffer does not count, only windows from WINDOW's frame count
1744 Optional third arg ALL-FRAMES t means include windows on all frames.
1745 ALL-FRAMES nil or omitted means cycle within the frames as specified
1746 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1747 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1748 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1749 Anything else means restrict to WINDOW's frame.
1751 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1752 `previous-window' to iterate through the entire cycle of acceptable
1753 windows, eventually ending up back at the window you started with.
1754 `next-window' traverses the same cycle, in the reverse order. */)
1755 (window
, minibuf
, all_frames
)
1756 Lisp_Object window
, minibuf
, all_frames
;
1758 return next_window (window
, minibuf
, all_frames
, 0);
1762 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1763 doc
: /* Select the ARG'th different window on this frame.
1764 All windows on current frame are arranged in a cyclic order.
1765 This command selects the window ARG steps away in that order.
1766 A negative ARG moves in the opposite order. The optional second
1767 argument ALL_FRAMES has the same meaning as in `next-window', which see. */)
1769 Lisp_Object arg
, all_frames
;
1775 window
= selected_window
;
1777 for (i
= XINT (arg
); i
> 0; --i
)
1778 window
= Fnext_window (window
, Qnil
, all_frames
);
1780 window
= Fprevious_window (window
, Qnil
, all_frames
);
1782 Fselect_window (window
, Qnil
);
1787 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1788 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1789 FRAME nil or omitted means use the selected frame.
1790 WINDOW nil or omitted means use the selected window.
1791 MINIBUF t means include the minibuffer window, even if it isn't active.
1792 MINIBUF nil or omitted means include the minibuffer window only
1794 MINIBUF neither nil nor t means never include the minibuffer window. */)
1795 (frame
, minibuf
, window
)
1796 Lisp_Object frame
, minibuf
, window
;
1799 window
= selected_window
;
1801 frame
= selected_frame
;
1803 if (!EQ (frame
, XWINDOW (window
)->frame
))
1804 error ("Window is on a different frame");
1806 return window_list_1 (window
, minibuf
, frame
);
1810 /* Return a list of windows in canonical ordering. Arguments are like
1811 for `next-window'. */
1814 window_list_1 (window
, minibuf
, all_frames
)
1815 Lisp_Object window
, minibuf
, all_frames
;
1817 Lisp_Object tail
, list
, rest
;
1819 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1822 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1823 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1824 list
= Fcons (XCAR (tail
), list
);
1826 /* Rotate the list to start with WINDOW. */
1827 list
= Fnreverse (list
);
1828 rest
= Fmemq (window
, list
);
1829 if (!NILP (rest
) && !EQ (rest
, list
))
1831 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1833 XSETCDR (tail
, Qnil
);
1834 list
= nconc2 (rest
, list
);
1841 /* Look at all windows, performing an operation specified by TYPE
1843 If FRAMES is Qt, look at all frames;
1844 Qnil, look at just the selected frame;
1845 Qvisible, look at visible frames;
1846 a frame, just look at windows on that frame.
1847 If MINI is non-zero, perform the operation on minibuffer windows too. */
1852 GET_BUFFER_WINDOW
, /* Arg is buffer */
1853 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1854 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1855 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1857 UNSHOW_BUFFER
, /* Arg is buffer */
1858 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1863 window_loop (type
, obj
, mini
, frames
)
1864 enum window_loop type
;
1865 Lisp_Object obj
, frames
;
1868 Lisp_Object window
, windows
, best_window
, frame_arg
;
1870 struct gcpro gcpro1
;
1872 /* If we're only looping through windows on a particular frame,
1873 frame points to that frame. If we're looping through windows
1874 on all frames, frame is 0. */
1875 if (FRAMEP (frames
))
1876 f
= XFRAME (frames
);
1877 else if (NILP (frames
))
1878 f
= SELECTED_FRAME ();
1883 frame_arg
= Qlambda
;
1884 else if (XFASTINT (frames
) == 0)
1886 else if (EQ (frames
, Qvisible
))
1891 /* frame_arg is Qlambda to stick to one frame,
1892 Qvisible to consider all visible frames,
1895 /* Pick a window to start with. */
1899 window
= FRAME_SELECTED_WINDOW (f
);
1901 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1903 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1907 for (; CONSP (windows
); windows
= CDR (windows
))
1911 window
= XCAR (windows
);
1912 w
= XWINDOW (window
);
1914 /* Note that we do not pay attention here to whether the frame
1915 is visible, since Fwindow_list skips non-visible frames if
1916 that is desired, under the control of frame_arg. */
1917 if (!MINI_WINDOW_P (w
)
1918 /* For UNSHOW_BUFFER, we must always consider all windows. */
1919 || type
== UNSHOW_BUFFER
1920 || (mini
&& minibuf_level
> 0))
1923 case GET_BUFFER_WINDOW
:
1924 if (EQ (w
->buffer
, obj
)
1925 /* Don't find any minibuffer window
1926 except the one that is currently in use. */
1927 && (MINI_WINDOW_P (w
)
1928 ? EQ (window
, minibuf_window
)
1931 if (NILP (best_window
))
1932 best_window
= window
;
1933 else if (EQ (window
, selected_window
))
1934 /* For compatibility with 20.x, prefer to return
1936 best_window
= window
;
1940 case GET_LRU_WINDOW
:
1941 /* t as arg means consider only full-width windows */
1942 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1944 /* Ignore dedicated windows and minibuffers. */
1945 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
1947 if (NILP (best_window
)
1948 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1949 > XFASTINT (w
->use_time
)))
1950 best_window
= window
;
1953 case DELETE_OTHER_WINDOWS
:
1954 if (!EQ (window
, obj
))
1955 Fdelete_window (window
);
1958 case DELETE_BUFFER_WINDOWS
:
1959 if (EQ (w
->buffer
, obj
))
1961 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1963 /* If this window is dedicated, and in a frame of its own,
1965 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1966 && !NILP (w
->dedicated
)
1967 && other_visible_frames (f
))
1969 /* Skip the other windows on this frame.
1970 There might be one, the minibuffer! */
1971 while (CONSP (XCDR (windows
))
1972 && EQ (XWINDOW (XCAR (windows
))->frame
,
1973 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1974 windows
= XCDR (windows
);
1976 /* Now we can safely delete the frame. */
1977 Fdelete_frame (w
->frame
, Qnil
);
1979 else if (NILP (w
->parent
))
1981 /* If we're deleting the buffer displayed in the
1982 only window on the frame, find a new buffer to
1985 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1986 Fset_window_buffer (window
, buffer
, Qnil
);
1987 if (EQ (window
, selected_window
))
1988 Fset_buffer (w
->buffer
);
1991 Fdelete_window (window
);
1995 case GET_LARGEST_WINDOW
:
1997 /* Ignore dedicated windows and minibuffers. */
1998 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
2001 if (NILP (best_window
))
2002 best_window
= window
;
2005 struct window
*b
= XWINDOW (best_window
);
2006 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2007 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2008 best_window
= window
;
2014 if (EQ (w
->buffer
, obj
))
2017 struct frame
*f
= XFRAME (w
->frame
);
2019 /* Find another buffer to show in this window. */
2020 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2022 /* If this window is dedicated, and in a frame of its own,
2024 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2025 && !NILP (w
->dedicated
)
2026 && other_visible_frames (f
))
2028 /* Skip the other windows on this frame.
2029 There might be one, the minibuffer! */
2030 while (CONSP (XCDR (windows
))
2031 && EQ (XWINDOW (XCAR (windows
))->frame
,
2032 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2033 windows
= XCDR (windows
);
2035 /* Now we can safely delete the frame. */
2036 Fdelete_frame (w
->frame
, Qnil
);
2038 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2041 XSETWINDOW (window
, w
);
2042 /* If this window is dedicated and not the only window
2043 in its frame, then kill it. */
2044 Fdelete_window (window
);
2048 /* Otherwise show a different buffer in the window. */
2049 w
->dedicated
= Qnil
;
2050 Fset_window_buffer (window
, buffer
, Qnil
);
2051 if (EQ (window
, selected_window
))
2052 Fset_buffer (w
->buffer
);
2057 case REDISPLAY_BUFFER_WINDOWS
:
2058 if (EQ (w
->buffer
, obj
))
2060 mark_window_display_accurate (window
, 0);
2061 w
->update_mode_line
= Qt
;
2062 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2063 ++update_mode_lines
;
2064 best_window
= window
;
2068 /* Check for a window that has a killed buffer. */
2069 case CHECK_ALL_WINDOWS
:
2070 if (! NILP (w
->buffer
)
2071 && NILP (XBUFFER (w
->buffer
)->name
))
2075 case WINDOW_LOOP_UNUSED
:
2084 /* Used for debugging. Abort if any window has a dead buffer. */
2087 check_all_windows ()
2089 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2092 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
2093 doc
: /* Return the window least recently selected or used for display.
2094 Return a full-width window if possible.
2095 A minibuffer window is never a candidate.
2096 If optional argument FRAME is `visible', search all visible frames.
2097 If FRAME is 0, search all visible and iconified frames.
2098 If FRAME is t, search all frames.
2099 If FRAME is nil, search only the selected frame.
2100 If FRAME is a frame, search only that frame. */)
2104 register Lisp_Object w
;
2105 /* First try for a window that is full-width */
2106 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
2107 if (!NILP (w
) && !EQ (w
, selected_window
))
2109 /* If none of them, try the rest */
2110 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
2113 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
2114 doc
: /* Return the largest window in area.
2115 A minibuffer window is never a candidate.
2116 If optional argument FRAME is `visible', search all visible frames.
2117 If FRAME is 0, search all visible and iconified frames.
2118 If FRAME is t, search all frames.
2119 If FRAME is nil, search only the selected frame.
2120 If FRAME is a frame, search only that frame. */)
2124 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
2128 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2129 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2130 BUFFER can be a buffer or a buffer name.
2131 If optional argument FRAME is `visible', search all visible frames.
2132 If optional argument FRAME is 0, search all visible and iconified frames.
2133 If FRAME is t, search all frames.
2134 If FRAME is nil, search only the selected frame.
2135 If FRAME is a frame, search only that frame. */)
2137 Lisp_Object buffer
, frame
;
2139 buffer
= Fget_buffer (buffer
);
2140 if (BUFFERP (buffer
))
2141 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2146 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2148 doc
: /* Make WINDOW (or the selected window) fill its frame.
2149 Only the frame WINDOW is on is affected.
2150 This function tries to reduce display jumps
2151 by keeping the text previously visible in WINDOW
2152 in the same place on the frame. Doing this depends on
2153 the value of (window-start WINDOW), so if calling this function
2154 in a program gives strange scrolling, make sure the window-start
2155 value is reasonable when this function is called. */)
2164 window
= selected_window
;
2166 CHECK_LIVE_WINDOW (window
);
2167 w
= XWINDOW (window
);
2169 startpos
= marker_position (w
->start
);
2170 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2172 if (MINI_WINDOW_P (w
) && top
> 0)
2173 error ("Can't expand minibuffer to full frame");
2175 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2177 /* Try to minimize scrolling, by setting the window start to the point
2178 will cause the text at the old window start to be at the same place
2179 on the frame. But don't try to do this if the window start is
2180 outside the visible portion (as might happen when the display is
2181 not current, due to typeahead). */
2182 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2184 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2185 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2187 struct position pos
;
2188 struct buffer
*obuf
= current_buffer
;
2190 Fset_buffer (w
->buffer
);
2191 /* This computation used to temporarily move point, but that can
2192 have unwanted side effects due to text properties. */
2193 pos
= *vmotion (startpos
, -top
, w
);
2195 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2196 w
->window_end_valid
= Qnil
;
2197 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2198 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2200 /* We need to do this, so that the window-scroll-functions
2202 w
->optional_new_start
= Qt
;
2204 set_buffer_internal (obuf
);
2210 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2211 1, 2, "bDelete windows on (buffer): ",
2212 doc
: /* Delete all windows showing BUFFER.
2213 BUFFER must be a buffer or the name of an existing buffer.
2214 Optional second argument FRAME controls which frames are affected.
2215 If optional argument FRAME is `visible', search all visible frames.
2216 If FRAME is 0, search all visible and iconified frames.
2217 If FRAME is nil, search all frames.
2218 If FRAME is t, search only the selected frame.
2219 If FRAME is a frame, search only that frame. */)
2221 Lisp_Object buffer
, frame
;
2223 /* FRAME uses t and nil to mean the opposite of what window_loop
2227 else if (EQ (frame
, Qt
))
2232 buffer
= Fget_buffer (buffer
);
2233 CHECK_BUFFER (buffer
);
2234 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2240 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2241 Sreplace_buffer_in_windows
,
2242 1, 1, "bReplace buffer in windows: ",
2243 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2244 BUFFER may be a buffer or the name of an existing buffer. */)
2250 buffer
= Fget_buffer (buffer
);
2251 CHECK_BUFFER (buffer
);
2252 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2257 /* Replace BUFFER with some other buffer in all windows
2258 of all frames, even those on other keyboards. */
2261 replace_buffer_in_all_windows (buffer
)
2265 Lisp_Object tail
, frame
;
2267 /* A single call to window_loop won't do the job
2268 because it only considers frames on the current keyboard.
2269 So loop manually over frames, and handle each one. */
2270 FOR_EACH_FRAME (tail
, frame
)
2271 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2273 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2277 /* Set the height of WINDOW and all its inferiors. */
2279 /* The smallest acceptable dimensions for a window. Anything smaller
2280 might crash Emacs. */
2282 #define MIN_SAFE_WINDOW_WIDTH (2)
2283 #define MIN_SAFE_WINDOW_HEIGHT (1)
2285 /* Make sure that window_min_height and window_min_width are
2286 not too small; if they are, set them to safe minima. */
2289 check_min_window_sizes ()
2291 /* Smaller values might permit a crash. */
2292 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2293 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2294 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2295 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2298 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2299 minimum allowable size. */
2302 check_frame_size (frame
, rows
, cols
)
2306 /* For height, we have to see:
2307 how many windows the frame has at minimum (one or two),
2308 and whether it has a menu bar or other special stuff at the top. */
2310 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2311 ? MIN_SAFE_WINDOW_HEIGHT
2312 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2314 if (FRAME_TOP_MARGIN (frame
) > 0)
2315 min_height
+= FRAME_TOP_MARGIN (frame
);
2317 if (*rows
< min_height
)
2319 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2320 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2324 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2325 check if W's width can be changed, otherwise check W's height.
2326 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2327 siblings, too. If none of the siblings is resizable, WINDOW isn't
2331 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2333 int width_p
, check_siblings_p
;
2338 if (!NILP (w
->hchild
))
2340 c
= XWINDOW (w
->hchild
);
2344 /* A horiz. combination is fixed-width if all of if its
2346 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2347 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2348 fixed_p
= c
== NULL
;
2352 /* A horiz. combination is fixed-height if one of if its
2354 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2355 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2356 fixed_p
= c
!= NULL
;
2359 else if (!NILP (w
->vchild
))
2361 c
= XWINDOW (w
->vchild
);
2365 /* A vert. combination is fixed-width if one of if its
2367 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2368 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2369 fixed_p
= c
!= NULL
;
2373 /* A vert. combination is fixed-height if all of if its
2375 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2376 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2377 fixed_p
= c
== NULL
;
2380 else if (BUFFERP (w
->buffer
))
2382 if (w
->height_fixed_p
&& !width_p
)
2386 struct buffer
*old
= current_buffer
;
2389 current_buffer
= XBUFFER (w
->buffer
);
2390 val
= find_symbol_value (Qwindow_size_fixed
);
2391 current_buffer
= old
;
2394 if (!EQ (val
, Qunbound
))
2396 fixed_p
= !NILP (val
);
2399 && ((EQ (val
, Qheight
) && width_p
)
2400 || (EQ (val
, Qwidth
) && !width_p
)))
2405 /* Can't tell if this one is resizable without looking at
2406 siblings. If all siblings are fixed-size this one is too. */
2407 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2411 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2412 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2416 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2417 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2431 /* Return the minimum size of window W, not taking fixed-width windows
2432 into account. WIDTH_P non-zero means return the minimum width,
2433 otherwise return the minimum height. If W is a combination window,
2434 compute the minimum size from the minimum sizes of W's children. */
2437 window_min_size_1 (w
, width_p
)
2444 if (!NILP (w
->hchild
))
2446 c
= XWINDOW (w
->hchild
);
2451 /* The min width of a horizontal combination is
2452 the sum of the min widths of its children. */
2455 size
+= window_min_size_1 (c
, width_p
);
2456 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2461 /* The min height a horizontal combination equals
2462 the maximum of all min height of its children. */
2465 int min_size
= window_min_size_1 (c
, width_p
);
2466 size
= max (min_size
, size
);
2467 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2471 else if (!NILP (w
->vchild
))
2473 c
= XWINDOW (w
->vchild
);
2478 /* The min width of a vertical combination is
2479 the maximum of the min widths of its children. */
2482 int min_size
= window_min_size_1 (c
, width_p
);
2483 size
= max (min_size
, size
);
2484 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2489 /* The min height of a vertical combination equals
2490 the sum of the min height of its children. */
2493 size
+= window_min_size_1 (c
, width_p
);
2494 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2501 size
= window_min_width
;
2504 if (MINI_WINDOW_P (w
)
2505 || (!WINDOW_WANTS_MODELINE_P (w
)
2506 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2509 size
= window_min_height
;
2517 /* Return the minimum size of window W, taking fixed-size windows into
2518 account. WIDTH_P non-zero means return the minimum width,
2519 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2520 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2521 unless FIXED is null. */
2524 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2526 int width_p
, ignore_fixed_p
, *fixed
;
2533 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2539 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2541 size
= window_min_size_1 (w
, width_p
);
2547 /* Adjust the margins of window W if text area is too small.
2548 Return 1 if window width is ok after adjustment; 0 if window
2549 is still too narrow. */
2552 adjust_window_margins (w
)
2555 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2556 - WINDOW_FRINGE_COLS (w
)
2557 - WINDOW_SCROLL_BAR_COLS (w
));
2558 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2559 + WINDOW_RIGHT_MARGIN_COLS (w
));
2561 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2564 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2567 /* Window's text area is too narrow, but reducing the window
2568 margins will fix that. */
2569 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2570 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2572 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2573 w
->left_margin_cols
= w
->right_margin_cols
2574 = make_number (margin_cols
/2);
2576 w
->right_margin_cols
= make_number (margin_cols
);
2579 w
->left_margin_cols
= make_number (margin_cols
);
2583 /* Calculate new sizes for windows in the list FORWARD when the window size
2584 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2585 The number of windows in FORWARD is NCHILDREN, and the number that
2586 can shrink is SHRINKABLE.
2587 The minimum size a window can have is MIN_SIZE.
2588 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2589 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2592 This function returns an allocated array of new sizes that the caller
2593 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2594 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2595 the second, and so on.
2597 This function tries to keep windows at least at the minimum size
2598 and resize other windows before it resizes any window to zero (i.e.
2599 delete that window).
2601 Windows are resized proportional to their size, so bigger windows
2602 shrink more than smaller windows. */
2604 shrink_windows (total
, size
, nchildren
, shrinkable
,
2605 min_size
, resize_fixed_p
, forward
, width_p
)
2606 int total
, size
, nchildren
, shrinkable
, min_size
;
2607 int resize_fixed_p
, width_p
;
2608 Lisp_Object forward
;
2610 int available_resize
= 0;
2614 int smallest
= total
;
2615 int total_removed
= 0;
2616 int total_shrink
= total
- size
;
2619 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2621 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2625 c
= XWINDOW (child
);
2626 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2628 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2632 new_sizes
[i
] = child_size
;
2633 if (child_size
> min_size
)
2634 available_resize
+= child_size
- min_size
;
2637 /* We might need to shrink some windows to zero. Find the smallest
2638 windows and set them to 0 until we can fulfil the new size. */
2640 while (shrinkable
> 1 && size
+ available_resize
< total
)
2642 for (i
= 0; i
< nchildren
; ++i
)
2643 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2644 smallest
= new_sizes
[i
];
2646 for (i
= 0; i
< nchildren
; ++i
)
2647 if (new_sizes
[i
] == smallest
)
2649 /* Resize this window down to zero. */
2651 if (smallest
> min_size
)
2652 available_resize
-= smallest
- min_size
;
2653 available_resize
+= smallest
;
2655 total_removed
+= smallest
;
2657 /* Out of for, just remove one window at the time and
2658 check again if we have enough space. */
2663 /* Now, calculate the new sizes. Try to shrink each window
2664 proportional to its size. */
2665 for (i
= 0; i
< nchildren
; ++i
)
2667 if (new_sizes
[i
] > min_size
)
2669 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2670 if (new_sizes
[i
] - to_shrink
< min_size
)
2671 to_shrink
= new_sizes
[i
] - min_size
;
2672 new_sizes
[i
] -= to_shrink
;
2673 total_removed
+= to_shrink
;
2677 /* Any reminder due to rounding, we just subtract from windows
2678 that are left and still can be shrunk. */
2679 while (total_shrink
> total_removed
)
2681 for (i
= 0; i
< nchildren
; ++i
)
2682 if (new_sizes
[i
] > min_size
)
2687 /* Out of for, just shrink one window at the time and
2688 check again if we have enough space. */
2696 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2697 WINDOW's width. Resize WINDOW's children, if any, so that they
2698 keep their proportionate size relative to WINDOW. Propagate
2699 WINDOW's top or left edge position to children. Delete windows
2700 that become too small unless NODELETE_P is non-zero.
2702 If NODELETE_P is 2, that means we do delete windows that are
2703 too small, even if they were too small before! */
2706 size_window (window
, size
, width_p
, nodelete_p
)
2708 int size
, width_p
, nodelete_p
;
2710 struct window
*w
= XWINDOW (window
);
2712 Lisp_Object child
, *forward
, *sideward
;
2713 int old_size
, min_size
, safe_min_size
;
2715 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2716 seems like it's too soon to do this here. ++KFS. */
2717 if (nodelete_p
== 2)
2720 check_min_window_sizes ();
2721 size
= max (0, size
);
2723 /* If the window has been "too small" at one point,
2724 don't delete it for being "too small" in the future.
2725 Preserve it as long as that is at all possible. */
2728 old_size
= WINDOW_TOTAL_COLS (w
);
2729 min_size
= window_min_width
;
2730 /* Ensure that there is room for the scroll bar and fringes!
2731 We may reduce display margins though. */
2732 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2733 + WINDOW_FRINGE_COLS (w
)
2734 + WINDOW_SCROLL_BAR_COLS (w
));
2738 old_size
= XINT (w
->total_lines
);
2739 min_size
= window_min_height
;
2740 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2743 if (old_size
< min_size
&& nodelete_p
!= 2)
2744 w
->too_small_ok
= Qt
;
2746 /* Maybe delete WINDOW if it's too small. */
2747 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2749 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2750 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2751 if (min_size
< safe_min_size
)
2752 min_size
= safe_min_size
;
2753 if (size
< min_size
)
2755 delete_window (window
);
2760 /* Set redisplay hints. */
2761 w
->last_modified
= make_number (0);
2762 w
->last_overlay_modified
= make_number (0);
2763 windows_or_buffers_changed
++;
2764 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2768 sideward
= &w
->vchild
;
2769 forward
= &w
->hchild
;
2770 w
->total_cols
= make_number (size
);
2771 adjust_window_margins (w
);
2775 sideward
= &w
->hchild
;
2776 forward
= &w
->vchild
;
2777 w
->total_lines
= make_number (size
);
2778 w
->orig_total_lines
= Qnil
;
2781 if (!NILP (*sideward
))
2783 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2785 c
= XWINDOW (child
);
2787 c
->left_col
= w
->left_col
;
2789 c
->top_line
= w
->top_line
;
2790 size_window (child
, size
, width_p
, nodelete_p
);
2793 else if (!NILP (*forward
))
2795 int fixed_size
, each
, extra
, n
;
2796 int resize_fixed_p
, nfixed
;
2797 int last_pos
, first_pos
, nchildren
, total
;
2798 int *new_sizes
= NULL
;
2800 /* Determine the fixed-size portion of the this window, and the
2801 number of child windows. */
2802 fixed_size
= nchildren
= nfixed
= total
= 0;
2803 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2807 c
= XWINDOW (child
);
2808 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2809 total
+= child_size
;
2811 if (window_fixed_size_p (c
, width_p
, 0))
2813 fixed_size
+= child_size
;
2818 /* If the new size is smaller than fixed_size, or if there
2819 aren't any resizable windows, allow resizing fixed-size
2821 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2823 /* Compute how many lines/columns to add/remove to each child. The
2824 value of extra takes care of rounding errors. */
2825 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2826 if (size
< total
&& n
> 1)
2827 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2828 resize_fixed_p
, *forward
, width_p
);
2831 each
= (size
- total
) / n
;
2832 extra
= (size
- total
) - n
* each
;
2835 /* Compute new children heights and edge positions. */
2836 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2837 last_pos
= first_pos
;
2838 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2840 int new_size
, old_size
;
2842 c
= XWINDOW (child
);
2843 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2844 new_size
= old_size
;
2846 /* The top or left edge position of this child equals the
2847 bottom or right edge of its predecessor. */
2849 c
->left_col
= make_number (last_pos
);
2851 c
->top_line
= make_number (last_pos
);
2853 /* If this child can be resized, do it. */
2854 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2856 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2860 /* Set new height. Note that size_window also propagates
2861 edge positions to children, so it's not a no-op if we
2862 didn't change the child's size. */
2863 size_window (child
, new_size
, width_p
, 1);
2865 /* Remember the bottom/right edge position of this child; it
2866 will be used to set the top/left edge of the next child. */
2867 last_pos
+= new_size
;
2870 if (new_sizes
) xfree (new_sizes
);
2872 /* We should have covered the parent exactly with child windows. */
2873 xassert (size
== last_pos
- first_pos
);
2875 /* Now delete any children that became too small. */
2877 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2880 c
= XWINDOW (child
);
2881 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2882 size_window (child
, child_size
, width_p
, 2);
2887 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2888 WINDOW's children. NODELETE non-zero means don't delete windows
2889 that become too small in the process. (The caller should check
2890 later and do so if appropriate.) */
2893 set_window_height (window
, height
, nodelete
)
2898 size_window (window
, height
, 0, nodelete
);
2902 /* Set WINDOW's width to WIDTH, and recursively change the width of
2903 WINDOW's children. NODELETE non-zero means don't delete windows
2904 that become too small in the process. (The caller should check
2905 later and do so if appropriate.) */
2908 set_window_width (window
, width
, nodelete
)
2913 size_window (window
, width
, 1, nodelete
);
2916 /* Change window heights in windows rooted in WINDOW by N lines. */
2919 change_window_heights (window
, n
)
2923 struct window
*w
= XWINDOW (window
);
2925 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
2926 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
2928 if (INTEGERP (w
->orig_top_line
))
2929 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
2930 if (INTEGERP (w
->orig_total_lines
))
2931 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
2933 /* Handle just the top child in a vertical split. */
2934 if (!NILP (w
->vchild
))
2935 change_window_heights (w
->vchild
, n
);
2937 /* Adjust all children in a horizontal split. */
2938 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
2940 w
= XWINDOW (window
);
2941 change_window_heights (window
, n
);
2946 int window_select_count
;
2949 Fset_window_buffer_unwind (obuf
)
2956 EXFUN (Fset_window_fringes
, 4);
2957 EXFUN (Fset_window_scroll_bars
, 4);
2959 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2960 means it's allowed to run hooks. See make_frame for a case where
2961 it's not allowed. KEEP_MARGINS_P non-zero means that the current
2962 margins, fringes, and scroll-bar settings of the window are not
2963 reset from the buffer's local settings. */
2966 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
2967 Lisp_Object window
, buffer
;
2968 int run_hooks_p
, keep_margins_p
;
2970 struct window
*w
= XWINDOW (window
);
2971 struct buffer
*b
= XBUFFER (buffer
);
2972 int count
= SPECPDL_INDEX ();
2976 if (EQ (window
, selected_window
))
2977 b
->last_selected_window
= window
;
2979 /* Update time stamps of buffer display. */
2980 if (INTEGERP (b
->display_count
))
2981 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
2982 b
->display_time
= Fcurrent_time ();
2984 XSETFASTINT (w
->window_end_pos
, 0);
2985 XSETFASTINT (w
->window_end_vpos
, 0);
2986 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
2987 w
->window_end_valid
= Qnil
;
2988 w
->hscroll
= w
->min_hscroll
= make_number (0);
2990 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
2991 set_marker_restricted (w
->start
,
2992 make_number (b
->last_window_start
),
2994 w
->start_at_line_beg
= Qnil
;
2995 w
->force_start
= Qnil
;
2996 XSETFASTINT (w
->last_modified
, 0);
2997 XSETFASTINT (w
->last_overlay_modified
, 0);
2998 windows_or_buffers_changed
++;
3000 /* We must select BUFFER for running the window-scroll-functions.
3001 If WINDOW is selected, switch permanently.
3002 Otherwise, switch but go back to the ambient buffer afterward. */
3003 if (EQ (window
, selected_window
))
3004 Fset_buffer (buffer
);
3005 /* We can't check ! NILP (Vwindow_scroll_functions) here
3006 because that might itself be a local variable. */
3007 else if (window_initialized
)
3009 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3010 Fset_buffer (buffer
);
3013 if (!keep_margins_p
)
3015 /* Set left and right marginal area width etc. from buffer. */
3017 /* This may call adjust_window_margins three times, so
3018 temporarily disable window margins. */
3019 Lisp_Object save_left
= w
->left_margin_cols
;
3020 Lisp_Object save_right
= w
->right_margin_cols
;
3022 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3024 Fset_window_fringes (window
,
3025 b
->left_fringe_width
, b
->right_fringe_width
,
3026 b
->fringes_outside_margins
);
3028 Fset_window_scroll_bars (window
,
3029 b
->scroll_bar_width
,
3030 b
->vertical_scroll_bar_type
, Qnil
);
3032 w
->left_margin_cols
= save_left
;
3033 w
->right_margin_cols
= save_right
;
3035 Fset_window_margins (window
,
3036 b
->left_margin_cols
, b
->right_margin_cols
);
3041 if (! NILP (Vwindow_scroll_functions
))
3042 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3043 Fmarker_position (w
->start
));
3045 if (! NILP (Vwindow_configuration_change_hook
)
3046 && ! NILP (Vrun_hooks
))
3047 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3050 unbind_to (count
, Qnil
);
3054 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3055 doc
: /* Make WINDOW display BUFFER as its contents.
3056 BUFFER can be a buffer or the name of an existing buffer.
3057 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3058 display margins, fringe widths, and scroll bar settings are maintained;
3059 the default is to reset these from BUFFER's local settings or the frame
3062 This function runs the hook `window-scroll-functions'. */)
3063 (window
, buffer
, keep_margins
)
3064 register Lisp_Object window
, buffer
, keep_margins
;
3066 register Lisp_Object tem
;
3067 register struct window
*w
= decode_window (window
);
3069 XSETWINDOW (window
, w
);
3070 buffer
= Fget_buffer (buffer
);
3071 CHECK_BUFFER (buffer
);
3073 if (NILP (XBUFFER (buffer
)->name
))
3074 error ("Attempt to display deleted buffer");
3078 error ("Window is deleted");
3079 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3080 is first being set up. */
3082 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3083 error ("Window is dedicated to `%s'",
3084 SDATA (XBUFFER (tem
)->name
));
3089 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3093 /* Note that selected_window can be nil
3094 when this is called from Fset_window_configuration. */
3096 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3097 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3098 If WINDOW is not already selected, make WINDOW's buffer current
3099 and make WINDOW the frame's selected window. Return WINDOW.
3100 Optional second arg NORECORD non-nil means
3101 do not put this buffer at the front of the list of recently selected ones.
3103 Note that the main editor command loop
3104 selects the buffer of the selected window before each command. */)
3106 register Lisp_Object window
, norecord
;
3108 register struct window
*w
;
3109 register struct window
*ow
;
3112 CHECK_LIVE_WINDOW (window
);
3114 w
= XWINDOW (window
);
3115 w
->frozen_window_start_p
= 0;
3117 XSETFASTINT (w
->use_time
, ++window_select_count
);
3118 if (EQ (window
, selected_window
))
3121 if (!NILP (selected_window
))
3123 ow
= XWINDOW (selected_window
);
3124 if (! NILP (ow
->buffer
))
3125 set_marker_both (ow
->pointm
, ow
->buffer
,
3126 BUF_PT (XBUFFER (ow
->buffer
)),
3127 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3130 selected_window
= window
;
3131 sf
= SELECTED_FRAME ();
3132 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3134 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3135 /* Use this rather than Fhandle_switch_frame
3136 so that FRAME_FOCUS_FRAME is moved appropriately as we
3137 move around in the state where a minibuffer in a separate
3139 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
3142 sf
->selected_window
= window
;
3144 if (NILP (norecord
))
3145 record_buffer (w
->buffer
);
3146 Fset_buffer (w
->buffer
);
3148 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3150 /* Go to the point recorded in the window.
3151 This is important when the buffer is in more
3152 than one window. It also matters when
3153 redisplay_window has altered point after scrolling,
3154 because it makes the change only in the window. */
3156 register int new_point
= marker_position (w
->pointm
);
3157 if (new_point
< BEGV
)
3159 else if (new_point
> ZV
)
3165 windows_or_buffers_changed
++;
3170 select_window_norecord (window
)
3173 return Fselect_window (window
, Qt
);
3176 /* Deiconify the frame containing the window WINDOW,
3177 unless it is the selected frame;
3180 The reason for the exception for the selected frame
3181 is that it seems better not to change the selected frames visibility
3182 merely because of displaying a different buffer in it.
3183 The deiconification is useful when a buffer gets shown in
3184 another frame that you were not using lately. */
3187 display_buffer_1 (window
)
3190 Lisp_Object frame
= XWINDOW (window
)->frame
;
3191 FRAME_PTR f
= XFRAME (frame
);
3193 FRAME_SAMPLE_VISIBILITY (f
);
3195 if (EQ (frame
, selected_frame
))
3196 ; /* Assume the selected frame is already visible enough. */
3197 else if (minibuf_level
> 0
3198 && MINI_WINDOW_P (XWINDOW (selected_window
))
3199 && WINDOW_LIVE_P (minibuf_selected_window
)
3200 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3201 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3204 if (FRAME_ICONIFIED_P (f
))
3205 Fmake_frame_visible (frame
);
3206 else if (FRAME_VISIBLE_P (f
))
3207 Fraise_frame (frame
);
3213 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3214 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would be created specially.
3215 The value is actually t if the frame should be called with default frame
3216 parameters, and a list of frame parameters if they were specified.
3217 See `special-display-buffer-names', and `special-display-regexps'. */)
3219 Lisp_Object buffer_name
;
3223 CHECK_STRING (buffer_name
);
3225 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3229 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3233 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3235 Lisp_Object car
= XCAR (tem
);
3237 && fast_string_match (car
, buffer_name
) >= 0)
3239 else if (CONSP (car
)
3240 && STRINGP (XCAR (car
))
3241 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3247 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3248 doc
: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
3249 See `same-window-buffer-names' and `same-window-regexps'. */)
3251 Lisp_Object buffer_name
;
3255 CHECK_STRING (buffer_name
);
3257 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3261 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3265 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3267 Lisp_Object car
= XCAR (tem
);
3269 && fast_string_match (car
, buffer_name
) >= 0)
3271 else if (CONSP (car
)
3272 && STRINGP (XCAR (car
))
3273 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3279 /* Use B so the default is (other-buffer). */
3280 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3281 "BDisplay buffer: \nP",
3282 doc
: /* Make BUFFER appear in some window but don't select it.
3283 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3285 If BUFFER is shown already in some window, just use that one,
3286 unless the window is the selected window and the optional second
3287 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3288 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3289 Returns the window displaying BUFFER.
3290 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3291 displaying BUFFER, then simply raise that frame.
3293 The variables `special-display-buffer-names',
3294 `special-display-regexps', `same-window-buffer-names', and
3295 `same-window-regexps' customize how certain buffer names are handled.
3296 The latter two take effect only if NOT-THIS-WINDOW is t.
3298 If optional argument FRAME is `visible', search all visible frames.
3299 If FRAME is 0, search all visible and iconified frames.
3300 If FRAME is t, search all frames.
3301 If FRAME is a frame, search only that frame.
3302 If FRAME is nil, search only the selected frame
3303 (actually the last nonminibuffer frame),
3304 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3305 which means search visible and iconified frames.
3307 If a full-width window on a splittable frame is available to display
3308 the buffer, it may be split, subject to the value of the variable
3309 `split-height-threshold'.
3311 If `even-window-heights' is non-nil, window heights will be evened out
3312 if displaying the buffer causes two vertically adjacent windows to be
3314 (buffer
, not_this_window
, frame
)
3315 register Lisp_Object buffer
, not_this_window
, frame
;
3317 register Lisp_Object window
, tem
, swp
;
3321 buffer
= Fget_buffer (buffer
);
3322 CHECK_BUFFER (buffer
);
3324 if (!NILP (Vdisplay_buffer_function
))
3325 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3327 if (NILP (not_this_window
)
3328 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3329 return display_buffer_1 (selected_window
);
3331 /* See if the user has specified this buffer should appear
3332 in the selected window. */
3333 if (NILP (not_this_window
))
3335 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3336 if (!NILP (swp
) && !no_switch_window (selected_window
))
3338 Fswitch_to_buffer (buffer
, Qnil
);
3339 return display_buffer_1 (selected_window
);
3343 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3344 look for a window showing BUFFER on any visible or iconified frame.
3345 Otherwise search only the current frame. */
3348 else if (pop_up_frames
3349 || display_buffer_reuse_frames
3350 || last_nonminibuf_frame
== 0)
3351 XSETFASTINT (tem
, 0);
3353 XSETFRAME (tem
, last_nonminibuf_frame
);
3355 window
= Fget_buffer_window (buffer
, tem
);
3357 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3358 return display_buffer_1 (window
);
3360 /* Certain buffer names get special handling. */
3361 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3363 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3365 return call1 (Vspecial_display_function
, buffer
);
3367 return call2 (Vspecial_display_function
, buffer
, tem
);
3370 /* If there are no frames open that have more than a minibuffer,
3371 we need to create a new frame. */
3372 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3374 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3375 Fset_window_buffer (window
, buffer
, Qnil
);
3376 return display_buffer_1 (window
);
3379 f
= SELECTED_FRAME ();
3381 || FRAME_MINIBUF_ONLY_P (f
)
3382 /* If the current frame is a special display frame,
3383 don't try to reuse its windows. */
3384 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3389 if (FRAME_MINIBUF_ONLY_P (f
))
3390 XSETFRAME (frames
, last_nonminibuf_frame
);
3391 /* Don't try to create a window if we would get an error. */
3392 if (split_height_threshold
< window_min_height
<< 1)
3393 split_height_threshold
= window_min_height
<< 1;
3395 /* Note that both Fget_largest_window and Fget_lru_window
3396 ignore minibuffers and dedicated windows.
3397 This means they can return nil. */
3399 /* If the frame we would try to split cannot be split,
3400 try other frames. */
3401 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3403 /* Try visible frames first. */
3404 window
= Fget_largest_window (Qvisible
);
3405 /* If that didn't work, try iconified frames. */
3407 window
= Fget_largest_window (make_number (0));
3409 window
= Fget_largest_window (Qt
);
3412 window
= Fget_largest_window (frames
);
3414 /* If we got a tall enough full-width window that can be split,
3417 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3418 && window_height (window
) >= split_height_threshold
3419 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3420 window
= Fsplit_window (window
, Qnil
, Qnil
);
3423 Lisp_Object upper
, lower
, other
;
3425 window
= Fget_lru_window (frames
);
3426 /* If the LRU window is selected, and big enough,
3427 and can be split, split it. */
3429 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3430 && (EQ (window
, selected_window
)
3431 || EQ (XWINDOW (window
)->parent
, Qnil
))
3432 && window_height (window
) >= window_min_height
<< 1)
3433 window
= Fsplit_window (window
, Qnil
, Qnil
);
3434 /* If Fget_lru_window returned nil, try other approaches. */
3436 /* Try visible frames first. */
3438 window
= Fget_buffer_window (buffer
, Qvisible
);
3440 window
= Fget_largest_window (Qvisible
);
3441 /* If that didn't work, try iconified frames. */
3443 window
= Fget_buffer_window (buffer
, make_number (0));
3445 window
= Fget_largest_window (make_number (0));
3446 /* Try invisible frames. */
3448 window
= Fget_buffer_window (buffer
, Qt
);
3450 window
= Fget_largest_window (Qt
);
3451 /* As a last resort, make a new frame. */
3453 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3454 /* If window appears above or below another,
3455 even out their heights. */
3456 other
= upper
= lower
= Qnil
;
3457 if (!NILP (XWINDOW (window
)->prev
))
3458 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3459 if (!NILP (XWINDOW (window
)->next
))
3460 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3462 && !NILP (Veven_window_heights
)
3463 /* Check that OTHER and WINDOW are vertically arrayed. */
3464 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3465 && (XFASTINT (XWINDOW (other
)->total_lines
)
3466 > XFASTINT (XWINDOW (window
)->total_lines
)))
3468 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3469 + XFASTINT (XWINDOW (window
)->total_lines
));
3470 enlarge_window (upper
,
3471 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3477 window
= Fget_lru_window (Qnil
);
3479 Fset_window_buffer (window
, buffer
, Qnil
);
3480 return display_buffer_1 (window
);
3484 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3486 doc
: /* Force redisplay of all windows.
3487 If optional arg OBJECT is a window, force redisplay of that window only.
3488 If OBJECT is a buffer or buffer name, force redisplay of all windows
3489 displaying that buffer. */)
3495 windows_or_buffers_changed
++;
3496 update_mode_lines
++;
3500 if (WINDOWP (object
))
3502 struct window
*w
= XWINDOW (object
);
3503 mark_window_display_accurate (object
, 0);
3504 w
->update_mode_line
= Qt
;
3505 if (BUFFERP (w
->buffer
))
3506 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3507 ++update_mode_lines
;
3511 if (STRINGP (object
))
3512 object
= Fget_buffer (object
);
3513 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3515 /* Walk all windows looking for buffer, and force update
3516 of each of those windows. */
3518 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3519 return NILP (object
) ? Qnil
: Qt
;
3522 /* If nothing suitable was found, just return.
3523 We could signal an error, but this feature will typically be used
3524 asynchronously in timers or process sentinels, so we don't. */
3530 temp_output_buffer_show (buf
)
3531 register Lisp_Object buf
;
3533 register struct buffer
*old
= current_buffer
;
3534 register Lisp_Object window
;
3535 register struct window
*w
;
3537 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3540 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3544 #if 0 /* rms: there should be no reason for this. */
3545 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3547 set_buffer_internal (old
);
3549 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3550 call1 (Vtemp_buffer_show_function
, buf
);
3553 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3555 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3556 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3557 Vminibuf_scroll_window
= window
;
3558 w
= XWINDOW (window
);
3559 XSETFASTINT (w
->hscroll
, 0);
3560 XSETFASTINT (w
->min_hscroll
, 0);
3561 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3562 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3564 /* Run temp-buffer-show-hook, with the chosen window selected
3565 and its buffer current. */
3567 if (!NILP (Vrun_hooks
)
3568 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3569 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3571 int count
= SPECPDL_INDEX ();
3572 Lisp_Object prev_window
, prev_buffer
;
3573 prev_window
= selected_window
;
3574 XSETBUFFER (prev_buffer
, old
);
3576 /* Select the window that was chosen, for running the hook.
3577 Note: Both Fselect_window and select_window_norecord may
3578 set-buffer to the buffer displayed in the window,
3579 so we need to save the current buffer. --stef */
3580 record_unwind_protect (Fset_buffer
, prev_buffer
);
3581 record_unwind_protect (select_window_norecord
, prev_window
);
3582 Fselect_window (window
, Qt
);
3583 Fset_buffer (w
->buffer
);
3584 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3585 unbind_to (count
, Qnil
);
3591 make_dummy_parent (window
)
3595 register struct window
*o
, *p
;
3598 o
= XWINDOW (window
);
3599 p
= allocate_window ();
3600 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3601 ((struct Lisp_Vector
*) p
)->contents
[i
]
3602 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3603 XSETWINDOW (new, p
);
3605 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
3607 /* Put new into window structure in place of window */
3608 replace_window (window
, new);
3621 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3622 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3623 WINDOW defaults to selected one and SIZE to half its size.
3624 If optional third arg HORFLAG is non-nil, split side by side
3625 and put SIZE columns in the first of the pair. In that case,
3626 SIZE includes that window's scroll bar, or the divider column to its right.
3627 Interactively, all arguments are nil.
3629 Returns the newly created window (which is the lower or rightmost one).
3630 The upper or leftmost window is the original one and remains selected.
3631 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3632 (window
, size
, horflag
)
3633 Lisp_Object window
, size
, horflag
;
3635 register Lisp_Object
new;
3636 register struct window
*o
, *p
;
3638 register int size_int
;
3641 window
= selected_window
;
3643 CHECK_LIVE_WINDOW (window
);
3645 o
= XWINDOW (window
);
3646 fo
= XFRAME (WINDOW_FRAME (o
));
3650 if (!NILP (horflag
))
3651 /* Calculate the size of the left-hand window, by dividing
3652 the usable space in columns by two.
3653 We round up, since the left-hand window may include
3654 a dividing line, while the right-hand may not. */
3655 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3657 size_int
= XFASTINT (o
->total_lines
) >> 1;
3661 CHECK_NUMBER (size
);
3662 size_int
= XINT (size
);
3665 if (MINI_WINDOW_P (o
))
3666 error ("Attempt to split minibuffer window");
3667 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3668 error ("Attempt to split fixed-size window");
3670 check_min_window_sizes ();
3674 if (size_int
< window_min_height
)
3675 error ("Window height %d too small (after splitting)", size_int
);
3676 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3677 error ("Window height %d too small (after splitting)",
3678 XFASTINT (o
->total_lines
) - size_int
);
3679 if (NILP (o
->parent
)
3680 || NILP (XWINDOW (o
->parent
)->vchild
))
3682 make_dummy_parent (window
);
3684 XWINDOW (new)->vchild
= window
;
3689 if (size_int
< window_min_width
)
3690 error ("Window width %d too small (after splitting)", size_int
);
3692 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3693 error ("Window width %d too small (after splitting)",
3694 XFASTINT (o
->total_cols
) - size_int
);
3695 if (NILP (o
->parent
)
3696 || NILP (XWINDOW (o
->parent
)->hchild
))
3698 make_dummy_parent (window
);
3700 XWINDOW (new)->hchild
= window
;
3704 /* Now we know that window's parent is a vertical combination
3705 if we are dividing vertically, or a horizontal combination
3706 if we are making side-by-side windows */
3708 windows_or_buffers_changed
++;
3709 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3710 new = make_window ();
3713 p
->frame
= o
->frame
;
3715 if (!NILP (p
->next
))
3716 XWINDOW (p
->next
)->prev
= new;
3719 p
->parent
= o
->parent
;
3721 p
->window_end_valid
= Qnil
;
3722 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3724 /* Duplicate special geometry settings. */
3726 p
->left_margin_cols
= o
->left_margin_cols
;
3727 p
->right_margin_cols
= o
->right_margin_cols
;
3728 p
->left_fringe_width
= o
->left_fringe_width
;
3729 p
->right_fringe_width
= o
->right_fringe_width
;
3730 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3731 p
->scroll_bar_width
= o
->scroll_bar_width
;
3732 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3734 /* Apportion the available frame space among the two new windows */
3736 if (!NILP (horflag
))
3738 p
->total_lines
= o
->total_lines
;
3739 p
->top_line
= o
->top_line
;
3740 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3741 XSETFASTINT (o
->total_cols
, size_int
);
3742 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3743 adjust_window_margins (p
);
3744 adjust_window_margins (o
);
3748 p
->left_col
= o
->left_col
;
3749 p
->total_cols
= o
->total_cols
;
3750 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3751 XSETFASTINT (o
->total_lines
, size_int
);
3752 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3755 /* Adjust glyph matrices. */
3758 Fset_window_buffer (new, o
->buffer
, Qt
);
3762 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 3, "p",
3763 doc
: /* Make current window ARG lines bigger.
3764 From program, optional second arg non-nil means grow sideways ARG columns.
3765 Interactively, if an argument is not given, make the window one line bigger.
3767 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3768 of the siblings above or to the left of the selected window. Only
3769 siblings to the right or below are changed. */)
3770 (arg
, side
, preserve_before
)
3771 register Lisp_Object arg
, side
, preserve_before
;
3774 enlarge_window (selected_window
, XINT (arg
), !NILP (side
),
3775 !NILP (preserve_before
));
3777 if (! NILP (Vwindow_configuration_change_hook
))
3778 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3783 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3784 doc
: /* Make current window ARG lines smaller.
3785 From program, optional second arg non-nil means shrink sideways arg columns.
3786 Interactively, if an argument is not given, make the window one line smaller.
3788 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3789 of the siblings above or to the left of the selected window. Only
3790 siblings to the right or below are changed. */)
3791 (arg
, side
, preserve_before
)
3792 register Lisp_Object arg
, side
, preserve_before
;
3795 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3796 !NILP (preserve_before
));
3798 if (! NILP (Vwindow_configuration_change_hook
))
3799 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3805 window_height (window
)
3808 register struct window
*p
= XWINDOW (window
);
3809 return WINDOW_TOTAL_LINES (p
);
3813 window_width (window
)
3816 register struct window
*p
= XWINDOW (window
);
3817 return WINDOW_TOTAL_COLS (p
);
3822 *(widthflag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3824 #define CURSIZE(w) \
3825 *(widthflag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3828 /* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
3829 increase its width. Siblings of the selected window are resized to
3830 fulfill the size request. If they become too small in the process,
3831 they will be deleted.
3833 If PRESERVE_BEFORE is nonzero, that means don't alter
3834 the siblings to the left or above WINDOW. */
3837 enlarge_window (window
, delta
, widthflag
, preserve_before
)
3839 int delta
, widthflag
, preserve_before
;
3841 Lisp_Object parent
, next
, prev
;
3845 int (*sizefun
) P_ ((Lisp_Object
))
3846 = widthflag
? window_width
: window_height
;
3847 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3848 = (widthflag
? set_window_width
: set_window_height
);
3850 /* Check values of window_min_width and window_min_height for
3852 check_min_window_sizes ();
3854 /* Give up if this window cannot be resized. */
3855 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3856 error ("Window is not resizable");
3858 /* Find the parent of the selected window. */
3861 p
= XWINDOW (window
);
3867 error ("No other window to side of this one");
3872 ? !NILP (XWINDOW (parent
)->hchild
)
3873 : !NILP (XWINDOW (parent
)->vchild
))
3879 sizep
= &CURSIZE (window
);
3882 register int maxdelta
;
3884 /* Compute the maximum size increment this window can have. */
3886 if (preserve_before
)
3890 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
3891 /* Subtract size of siblings before, since we can't take that. */
3892 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
3895 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3896 - window_min_size (XWINDOW (p
->next
),
3901 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3902 /* This is a main window followed by a minibuffer. */
3903 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3904 - window_min_size (XWINDOW (p
->next
),
3906 /* This is a minibuffer following a main window. */
3907 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3908 - window_min_size (XWINDOW (p
->prev
),
3910 /* This is a frame with only one window, a minibuffer-only
3911 or a minibufferless frame. */
3914 if (delta
> maxdelta
)
3915 /* This case traps trying to make the minibuffer
3916 the full frame, or make the only window aside from the
3917 minibuffer the full frame. */
3921 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3923 delete_window (window
);
3930 /* Find the total we can get from other siblings without deleting them. */
3932 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3933 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3935 if (! preserve_before
)
3936 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3937 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3940 /* If we can get it all from them without deleting them, do so. */
3941 if (delta
<= maximum
)
3943 Lisp_Object first_unaffected
;
3944 Lisp_Object first_affected
;
3949 first_affected
= window
;
3950 /* Look at one sibling at a time,
3951 moving away from this window in both directions alternately,
3952 and take as much as we can get without deleting that sibling. */
3954 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
3958 int this_one
= ((*sizefun
) (next
)
3959 - window_min_size (XWINDOW (next
),
3960 widthflag
, 0, &fixed_p
));
3963 if (this_one
> delta
)
3966 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
3967 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3972 next
= XWINDOW (next
)->next
;
3978 if (!preserve_before
&& ! NILP (prev
))
3980 int this_one
= ((*sizefun
) (prev
)
3981 - window_min_size (XWINDOW (prev
),
3982 widthflag
, 0, &fixed_p
));
3985 if (this_one
> delta
)
3988 first_affected
= prev
;
3990 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
3991 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3996 prev
= XWINDOW (prev
)->prev
;
4000 xassert (delta
== 0);
4002 /* Now recalculate the edge positions of all the windows affected,
4003 based on the new sizes. */
4004 first_unaffected
= next
;
4005 prev
= first_affected
;
4006 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4007 prev
= next
, next
= XWINDOW (next
)->next
)
4009 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4010 /* This does not change size of NEXT,
4011 but it propagates the new top edge to its children */
4012 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4017 register int delta1
;
4018 register int opht
= (*sizefun
) (parent
);
4020 if (opht
<= XINT (*sizep
) + delta
)
4022 /* If trying to grow this window to or beyond size of the parent,
4023 just delete all the sibling windows. */
4024 Lisp_Object start
, tem
, next
;
4026 start
= XWINDOW (parent
)->vchild
;
4028 start
= XWINDOW (parent
)->hchild
;
4030 /* Delete any siblings that come after WINDOW. */
4031 tem
= XWINDOW (window
)->next
;
4032 while (! NILP (tem
))
4034 next
= XWINDOW (tem
)->next
;
4035 delete_window (tem
);
4039 /* Delete any siblings that come after WINDOW.
4040 Note that if START is not WINDOW, then WINDOW still
4041 Fhas siblings, so WINDOW has not yet replaced its parent. */
4043 while (! EQ (tem
, window
))
4045 next
= XWINDOW (tem
)->next
;
4046 delete_window (tem
);
4052 /* Otherwise, make delta1 just right so that if we add
4053 delta1 lines to this window and to the parent, and then
4054 shrink the parent back to its original size, the new
4055 proportional size of this window will increase by delta.
4057 The function size_window will compute the new height h'
4058 of the window from delta1 as:
4061 x = delta1 - delta1/n * n for the 1st resizable child
4064 where n is the number of children that can be resized.
4065 We can ignore x by choosing a delta1 that is a multiple of
4066 n. We want the height of this window to come out as
4076 The number of children n equals the number of resizable
4077 children of this window + 1 because we know window itself
4078 is resizable (otherwise we would have signalled an error. */
4080 struct window
*w
= XWINDOW (window
);
4084 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4085 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4087 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4088 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4093 /* Add delta1 lines or columns to this window, and to the parent,
4094 keeping things consistent while not affecting siblings. */
4095 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4096 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4098 /* Squeeze out delta1 lines or columns from our parent,
4099 shriking this window and siblings proportionately.
4100 This brings parent back to correct size.
4101 Delta1 was calculated so this makes this window the desired size,
4102 taking it all out of the siblings. */
4103 (*setsizefun
) (parent
, opht
, 0);
4108 XSETFASTINT (p
->last_modified
, 0);
4109 XSETFASTINT (p
->last_overlay_modified
, 0);
4111 /* Adjust glyph matrices. */
4112 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4120 /***********************************************************************
4121 Resizing Mini-Windows
4122 ***********************************************************************/
4124 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4126 enum save_restore_action
4133 static int save_restore_orig_size
P_ ((struct window
*,
4134 enum save_restore_action
));
4136 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4137 from lowest windows first. */
4140 shrink_window_lowest_first (w
, height
)
4148 xassert (!MINI_WINDOW_P (w
));
4150 /* Set redisplay hints. */
4151 XSETFASTINT (w
->last_modified
, 0);
4152 XSETFASTINT (w
->last_overlay_modified
, 0);
4153 windows_or_buffers_changed
++;
4154 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4156 old_height
= XFASTINT (w
->total_lines
);
4157 XSETFASTINT (w
->total_lines
, height
);
4159 if (!NILP (w
->hchild
))
4161 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4163 c
= XWINDOW (child
);
4164 c
->top_line
= w
->top_line
;
4165 shrink_window_lowest_first (c
, height
);
4168 else if (!NILP (w
->vchild
))
4170 Lisp_Object last_child
;
4171 int delta
= old_height
- height
;
4176 /* Find the last child. We are taking space from lowest windows
4177 first, so we iterate over children from the last child
4179 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4182 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4183 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4187 c
= XWINDOW (child
);
4188 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4190 if (this_one
> delta
)
4193 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4197 /* Compute new positions. */
4198 last_top
= XINT (w
->top_line
);
4199 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4201 c
= XWINDOW (child
);
4202 c
->top_line
= make_number (last_top
);
4203 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4204 last_top
+= XFASTINT (c
->total_lines
);
4210 /* Save, restore, or check positions and sizes in the window tree
4211 rooted at W. ACTION says what to do.
4213 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4214 orig_total_lines members are valid for all windows in the window
4215 tree. Value is non-zero if they are valid.
4217 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4218 orig_top_line and orig_total_lines for all windows in the tree.
4220 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4221 stored in orig_top_line and orig_total_lines for all windows. */
4224 save_restore_orig_size (w
, action
)
4226 enum save_restore_action action
;
4232 if (!NILP (w
->hchild
))
4234 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4237 else if (!NILP (w
->vchild
))
4239 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4245 case CHECK_ORIG_SIZES
:
4246 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4250 case SAVE_ORIG_SIZES
:
4251 w
->orig_top_line
= w
->top_line
;
4252 w
->orig_total_lines
= w
->total_lines
;
4253 XSETFASTINT (w
->last_modified
, 0);
4254 XSETFASTINT (w
->last_overlay_modified
, 0);
4257 case RESTORE_ORIG_SIZES
:
4258 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4259 w
->top_line
= w
->orig_top_line
;
4260 w
->total_lines
= w
->orig_total_lines
;
4261 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4262 XSETFASTINT (w
->last_modified
, 0);
4263 XSETFASTINT (w
->last_overlay_modified
, 0);
4270 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4277 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4278 without deleting other windows. */
4281 grow_mini_window (w
, delta
)
4285 struct frame
*f
= XFRAME (w
->frame
);
4286 struct window
*root
;
4288 xassert (MINI_WINDOW_P (w
));
4289 xassert (delta
>= 0);
4291 /* Check values of window_min_width and window_min_height for
4293 check_min_window_sizes ();
4295 /* Compute how much we can enlarge the mini-window without deleting
4297 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4300 int min_height
= window_min_size (root
, 0, 0, 0);
4301 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4302 /* Note that the root window may already be smaller than
4304 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4309 /* Save original window sizes and positions, if not already done. */
4310 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4311 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4313 /* Shrink other windows. */
4314 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4316 /* Grow the mini-window. */
4317 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4318 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4319 XSETFASTINT (w
->last_modified
, 0);
4320 XSETFASTINT (w
->last_overlay_modified
, 0);
4327 /* Shrink mini-window W. If there is recorded info about window sizes
4328 before a call to grow_mini_window, restore recorded window sizes.
4329 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4333 shrink_mini_window (w
)
4336 struct frame
*f
= XFRAME (w
->frame
);
4337 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4339 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4341 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4343 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4344 windows_or_buffers_changed
= 1;
4346 else if (XFASTINT (w
->total_lines
) > 1)
4348 /* Distribute the additional lines of the mini-window
4349 among the other windows. */
4351 XSETWINDOW (window
, w
);
4352 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0, 0);
4358 /* Mark window cursors off for all windows in the window tree rooted
4359 at W by setting their phys_cursor_on_p flag to zero. Called from
4360 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4361 the frame are cleared. */
4364 mark_window_cursors_off (w
)
4369 if (!NILP (w
->hchild
))
4370 mark_window_cursors_off (XWINDOW (w
->hchild
));
4371 else if (!NILP (w
->vchild
))
4372 mark_window_cursors_off (XWINDOW (w
->vchild
));
4374 w
->phys_cursor_on_p
= 0;
4376 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4381 /* Return number of lines of text (not counting mode lines) in W. */
4384 window_internal_height (w
)
4387 int ht
= XFASTINT (w
->total_lines
);
4389 if (!MINI_WINDOW_P (w
))
4391 if (!NILP (w
->parent
)
4392 || !NILP (w
->vchild
)
4393 || !NILP (w
->hchild
)
4396 || WINDOW_WANTS_MODELINE_P (w
))
4399 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4407 /* Return the number of columns in W.
4408 Don't count columns occupied by scroll bars or the vertical bar
4409 separating W from the sibling to its right. */
4412 window_box_text_cols (w
)
4415 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4416 int width
= XINT (w
->total_cols
);
4418 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4419 /* Scroll bars occupy a few columns. */
4420 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4421 else if (!FRAME_WINDOW_P (f
)
4422 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4423 /* The column of `|' characters separating side-by-side windows
4424 occupies one column only. */
4427 if (FRAME_WINDOW_P (f
))
4428 /* On window-systems, fringes and display margins cannot be
4429 used for normal text. */
4430 width
-= (WINDOW_FRINGE_COLS (w
)
4431 + WINDOW_LEFT_MARGIN_COLS (w
)
4432 + WINDOW_RIGHT_MARGIN_COLS (w
));
4438 /************************************************************************
4440 ***********************************************************************/
4442 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4443 N screen-fulls, which is defined as the height of the window minus
4444 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4445 instead. Negative values of N mean scroll down. NOERROR non-zero
4446 means don't signal an error if we try to move over BEGV or ZV,
4450 window_scroll (window
, n
, whole
, noerror
)
4458 /* If we must, use the pixel-based version which is much slower than
4459 the line-based one but can handle varying line heights. */
4460 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4461 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4463 window_scroll_line_based (window
, n
, whole
, noerror
);
4469 /* Implementation of window_scroll that works based on pixel line
4470 heights. See the comment of window_scroll for parameter
4474 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4481 struct window
*w
= XWINDOW (window
);
4482 struct text_pos start
;
4484 int this_scroll_margin
;
4486 /* True if we fiddled the window vscroll field without really scrolling. */
4489 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4491 /* If PT is not visible in WINDOW, move back one half of
4492 the screen. Allow PT to be partially visible, otherwise
4493 something like (scroll-down 1) with PT in the line before
4494 the partially visible one would recenter. */
4495 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4498 /* Move backward half the height of the window. Performance note:
4499 vmotion used here is about 10% faster, but would give wrong
4500 results for variable height lines. */
4501 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4502 it
.current_y
= it
.last_visible_y
;
4503 move_it_vertically (&it
, - window_box_height (w
) / 2);
4505 /* The function move_iterator_vertically may move over more than
4506 the specified y-distance. If it->w is small, e.g. a
4507 mini-buffer window, we may end up in front of the window's
4508 display area. This is the case when Start displaying at the
4509 start of the line containing PT in this case. */
4510 if (it
.current_y
<= 0)
4512 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4513 move_it_vertically (&it
, 0);
4517 start
= it
.current
.pos
;
4520 /* If scroll_preserve_screen_position is non-zero, we try to set
4521 point in the same window line as it is now, so get that line. */
4522 if (!NILP (Vscroll_preserve_screen_position
))
4524 start_display (&it
, w
, start
);
4525 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4526 preserve_y
= it
.current_y
;
4531 /* Move iterator it from start the specified distance forward or
4532 backward. The result is the new window start. */
4533 start_display (&it
, w
, start
);
4536 int screen_full
= (window_box_height (w
)
4537 - next_screen_context_lines
* FRAME_LINE_HEIGHT (it
.f
));
4538 int dy
= n
* screen_full
;
4540 /* Note that move_it_vertically always moves the iterator to the
4541 start of a line. So, if the last line doesn't have a newline,
4542 we would end up at the start of the line ending at ZV. */
4544 move_it_vertically_backward (&it
, -dy
);
4546 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4547 MOVE_TO_POS
| MOVE_TO_Y
);
4550 move_it_by_lines (&it
, n
, 1);
4552 /* We failed if we find ZV is already on the screen (scrolling up,
4553 means there's nothing past the end), or if we can't start any
4554 earlier (scrolling down, means there's nothing past the top). */
4555 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4556 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4558 if (IT_CHARPOS (it
) == ZV
)
4560 if (it
.current_y
< it
.last_visible_y
4561 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4562 >= it
.last_visible_y
))
4564 /* The last line was only partially visible, make it fully
4566 w
->vscroll
= (it
.last_visible_y
4567 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4568 adjust_glyphs (it
.f
);
4573 Fsignal (Qend_of_buffer
, Qnil
);
4577 if (w
->vscroll
!= 0)
4578 /* The first line was only partially visible, make it fully
4584 Fsignal (Qbeginning_of_buffer
, Qnil
);
4587 /* If control gets here, then we vscrolled. */
4589 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4591 /* Don't try to change the window start below. */
4597 int pos
= IT_CHARPOS (it
);
4600 /* If in the middle of a multi-glyph character move forward to
4601 the next character. */
4602 if (in_display_vector_p (&it
))
4605 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4608 /* Set the window start, and set up the window for redisplay. */
4609 set_marker_restricted (w
->start
, make_number (pos
),
4611 bytepos
= XMARKER (w
->start
)->bytepos
;
4612 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4614 w
->update_mode_line
= Qt
;
4615 XSETFASTINT (w
->last_modified
, 0);
4616 XSETFASTINT (w
->last_overlay_modified
, 0);
4617 /* Set force_start so that redisplay_window will run the
4618 window-scroll-functions. */
4619 w
->force_start
= Qt
;
4622 it
.current_y
= it
.vpos
= 0;
4624 /* Preserve the screen position if we must. */
4625 if (preserve_y
>= 0)
4627 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4628 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4632 /* Move PT out of scroll margins. */
4633 this_scroll_margin
= max (0, scroll_margin
);
4634 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4635 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4639 /* We moved the window start towards ZV, so PT may be now
4640 in the scroll margin at the top. */
4641 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4642 while (it
.current_y
< this_scroll_margin
)
4644 int prev
= it
.current_y
;
4645 move_it_by_lines (&it
, 1, 1);
4646 if (prev
== it
.current_y
)
4649 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4653 int charpos
, bytepos
;
4655 /* We moved the window start towards BEGV, so PT may be now
4656 in the scroll margin at the bottom. */
4657 move_it_to (&it
, PT
, -1,
4658 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4659 MOVE_TO_POS
| MOVE_TO_Y
);
4661 /* Save our position, in case it's correct. */
4662 charpos
= IT_CHARPOS (it
);
4663 bytepos
= IT_BYTEPOS (it
);
4665 /* See if point is on a partially visible line at the end. */
4666 move_it_by_lines (&it
, 1, 1);
4667 if (it
.current_y
> it
.last_visible_y
)
4668 /* The last line was only partially visible, so back up two
4669 lines to make sure we're on a fully visible line. */
4671 move_it_by_lines (&it
, -2, 0);
4672 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4675 /* No, the position we saved is OK, so use it. */
4676 SET_PT_BOTH (charpos
, bytepos
);
4682 /* Implementation of window_scroll that works based on screen lines.
4683 See the comment of window_scroll for parameter descriptions. */
4686 window_scroll_line_based (window
, n
, whole
, noerror
)
4692 register struct window
*w
= XWINDOW (window
);
4693 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4694 register int pos
, pos_byte
;
4695 register int ht
= window_internal_height (w
);
4696 register Lisp_Object tem
;
4700 struct position posit
;
4703 /* If scrolling screen-fulls, compute the number of lines to
4704 scroll from the window's height. */
4706 n
*= max (1, ht
- next_screen_context_lines
);
4708 startpos
= marker_position (w
->start
);
4710 posit
= *compute_motion (startpos
, 0, 0, 0,
4712 -1, XINT (w
->hscroll
),
4714 original_vpos
= posit
.vpos
;
4716 XSETFASTINT (tem
, PT
);
4717 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4721 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4726 lose
= n
< 0 && PT
== BEGV
;
4727 Fvertical_motion (make_number (n
), window
);
4731 SET_PT_BOTH (opoint
, opoint_byte
);
4738 Fsignal (Qbeginning_of_buffer
, Qnil
);
4743 int this_scroll_margin
= scroll_margin
;
4745 /* Don't use a scroll margin that is negative or too large. */
4746 if (this_scroll_margin
< 0)
4747 this_scroll_margin
= 0;
4749 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
4750 this_scroll_margin
= XINT (w
->total_lines
) / 4;
4752 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4753 w
->start_at_line_beg
= bolp
;
4754 w
->update_mode_line
= Qt
;
4755 XSETFASTINT (w
->last_modified
, 0);
4756 XSETFASTINT (w
->last_overlay_modified
, 0);
4757 /* Set force_start so that redisplay_window will run
4758 the window-scroll-functions. */
4759 w
->force_start
= Qt
;
4761 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4763 SET_PT_BOTH (pos
, pos_byte
);
4764 Fvertical_motion (make_number (original_vpos
), window
);
4766 /* If we scrolled forward, put point enough lines down
4767 that it is outside the scroll margin. */
4772 if (this_scroll_margin
> 0)
4774 SET_PT_BOTH (pos
, pos_byte
);
4775 Fvertical_motion (make_number (this_scroll_margin
), window
);
4781 if (top_margin
<= opoint
)
4782 SET_PT_BOTH (opoint
, opoint_byte
);
4783 else if (!NILP (Vscroll_preserve_screen_position
))
4785 SET_PT_BOTH (pos
, pos_byte
);
4786 Fvertical_motion (make_number (original_vpos
), window
);
4789 SET_PT (top_margin
);
4795 /* If we scrolled backward, put point near the end of the window
4796 but not within the scroll margin. */
4797 SET_PT_BOTH (pos
, pos_byte
);
4798 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4799 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4802 bottom_margin
= PT
+ 1;
4804 if (bottom_margin
> opoint
)
4805 SET_PT_BOTH (opoint
, opoint_byte
);
4808 if (!NILP (Vscroll_preserve_screen_position
))
4810 SET_PT_BOTH (pos
, pos_byte
);
4811 Fvertical_motion (make_number (original_vpos
), window
);
4814 Fvertical_motion (make_number (-1), window
);
4823 Fsignal (Qend_of_buffer
, Qnil
);
4828 /* Scroll selected_window up or down. If N is nil, scroll a
4829 screen-full which is defined as the height of the window minus
4830 next_screen_context_lines. If N is the symbol `-', scroll.
4831 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4832 up. This is the guts of Fscroll_up and Fscroll_down. */
4835 scroll_command (n
, direction
)
4839 int count
= SPECPDL_INDEX ();
4841 xassert (abs (direction
) == 1);
4843 /* If selected window's buffer isn't current, make it current for
4844 the moment. But don't screw up if window_scroll gets an error. */
4845 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4847 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4848 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4850 /* Make redisplay consider other windows than just selected_window. */
4851 ++windows_or_buffers_changed
;
4855 window_scroll (selected_window
, direction
, 1, 0);
4856 else if (EQ (n
, Qminus
))
4857 window_scroll (selected_window
, -direction
, 1, 0);
4860 n
= Fprefix_numeric_value (n
);
4861 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4864 unbind_to (count
, Qnil
);
4867 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
4868 doc
: /* Scroll text of current window upward ARG lines.
4869 If ARG is omitted or nil, scroll upward by a near full screen.
4870 A near full screen is `next-screen-context-lines' less than a full screen.
4871 Negative ARG means scroll downward.
4872 If ARG is the atom `-', scroll downward by nearly full screen.
4873 When calling from a program, supply as argument a number, nil, or `-'. */)
4877 scroll_command (arg
, 1);
4881 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
4882 doc
: /* Scroll text of current window down ARG lines.
4883 If ARG is omitted or nil, scroll down by a near full screen.
4884 A near full screen is `next-screen-context-lines' less than a full screen.
4885 Negative ARG means scroll upward.
4886 If ARG is the atom `-', scroll upward by nearly full screen.
4887 When calling from a program, supply as argument a number, nil, or `-'. */)
4891 scroll_command (arg
, -1);
4895 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4896 doc
: /* Return the other window for \"other window scroll\" commands.
4897 If `other-window-scroll-buffer' is non-nil, a window
4898 showing that buffer is used.
4899 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4900 specifies the window. This takes precedence over
4901 `other-window-scroll-buffer'. */)
4906 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4907 && !NILP (Vminibuf_scroll_window
))
4908 window
= Vminibuf_scroll_window
;
4909 /* If buffer is specified, scroll that buffer. */
4910 else if (!NILP (Vother_window_scroll_buffer
))
4912 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4914 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4918 /* Nothing specified; look for a neighboring window on the same
4920 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4922 if (EQ (window
, selected_window
))
4923 /* That didn't get us anywhere; look for a window on another
4926 window
= Fnext_window (window
, Qnil
, Qt
);
4927 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4928 && ! EQ (window
, selected_window
));
4931 CHECK_LIVE_WINDOW (window
);
4933 if (EQ (window
, selected_window
))
4934 error ("There is no other window");
4939 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4940 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4941 A near full screen is `next-screen-context-lines' less than a full screen.
4942 The next window is the one below the current one; or the one at the top
4943 if the current one is at the bottom. Negative ARG means scroll downward.
4944 If ARG is the atom `-', scroll downward by nearly full screen.
4945 When calling from a program, supply as argument a number, nil, or `-'.
4947 If `other-window-scroll-buffer' is non-nil, scroll the window
4948 showing that buffer, popping the buffer up if necessary.
4949 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4950 specifies the window to scroll. This takes precedence over
4951 `other-window-scroll-buffer'. */)
4957 int count
= SPECPDL_INDEX ();
4959 window
= Fother_window_for_scrolling ();
4960 w
= XWINDOW (window
);
4962 /* Don't screw up if window_scroll gets an error. */
4963 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4964 ++windows_or_buffers_changed
;
4966 Fset_buffer (w
->buffer
);
4967 SET_PT (marker_position (w
->pointm
));
4970 window_scroll (window
, 1, 1, 1);
4971 else if (EQ (arg
, Qminus
))
4972 window_scroll (window
, -1, 1, 1);
4978 window_scroll (window
, XINT (arg
), 0, 1);
4981 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4982 unbind_to (count
, Qnil
);
4987 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
4988 doc
: /* Scroll selected window display ARG columns left.
4989 Default for ARG is window width minus 2.
4990 Value is the total amount of leftward horizontal scrolling in
4991 effect after the change.
4992 If `automatic-hscrolling' is non-nil, the argument ARG modifies
4993 a lower bound for automatic scrolling, i.e. automatic scrolling
4994 will not scroll a window to a column less than the value returned
4995 by this function. */)
4997 register Lisp_Object arg
;
5001 struct window
*w
= XWINDOW (selected_window
);
5004 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5006 arg
= Fprefix_numeric_value (arg
);
5008 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5009 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5011 if (interactive_p (0))
5012 w
->min_hscroll
= w
->hscroll
;
5017 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
5018 doc
: /* Scroll selected window display ARG columns right.
5019 Default for ARG is window width minus 2.
5020 Value is the total amount of leftward horizontal scrolling in
5021 effect after the change.
5022 If `automatic-hscrolling' is non-nil, the argument ARG modifies
5023 a lower bound for automatic scrolling, i.e. automatic scrolling
5024 will not scroll a window to a column less than the value returned
5025 by this function. */)
5027 register Lisp_Object arg
;
5031 struct window
*w
= XWINDOW (selected_window
);
5034 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5036 arg
= Fprefix_numeric_value (arg
);
5038 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5039 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5041 if (interactive_p (0))
5042 w
->min_hscroll
= w
->hscroll
;
5047 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5048 doc
: /* Return the window which was selected when entering the minibuffer.
5049 Returns nil, if current window is not a minibuffer window. */)
5052 if (minibuf_level
> 0
5053 && MINI_WINDOW_P (XWINDOW (selected_window
))
5054 && WINDOW_LIVE_P (minibuf_selected_window
))
5055 return minibuf_selected_window
;
5060 /* Value is the number of lines actually displayed in window W,
5061 as opposed to its height. */
5064 displayed_window_lines (w
)
5068 struct text_pos start
;
5069 int height
= window_box_height (w
);
5070 struct buffer
*old_buffer
;
5073 if (XBUFFER (w
->buffer
) != current_buffer
)
5075 old_buffer
= current_buffer
;
5076 set_buffer_internal (XBUFFER (w
->buffer
));
5081 /* In case W->start is out of the accessible range, do something
5082 reasonable. This happens in Info mode when Info-scroll-down
5083 calls (recenter -1) while W->start is 1. */
5084 if (XMARKER (w
->start
)->charpos
< BEGV
)
5085 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5086 else if (XMARKER (w
->start
)->charpos
> ZV
)
5087 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5089 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5091 start_display (&it
, w
, start
);
5092 move_it_vertically (&it
, height
);
5093 bottom_y
= line_bottom_y (&it
);
5095 /* rms: On a non-window display,
5096 the value of it.vpos at the bottom of the screen
5097 seems to be 1 larger than window_box_height (w).
5098 This kludge fixes a bug whereby (move-to-window-line -1)
5099 when ZV is on the last screen line
5100 moves to the previous screen line instead of the last one. */
5101 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5104 /* Add in empty lines at the bottom of the window. */
5105 if (bottom_y
< height
)
5107 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5108 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5112 set_buffer_internal (old_buffer
);
5118 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5119 doc
: /* Center point in window and redisplay frame.
5120 With prefix argument ARG, recenter putting point on screen line ARG
5121 relative to the current window. If ARG is negative, it counts up from the
5122 bottom of the window. (ARG should be less than the height of the window.)
5124 If ARG is omitted or nil, erase the entire frame and then
5125 redraw with point in the center of the current window.
5126 Just C-u as prefix means put point in the center of the window
5127 and redisplay normally--don't erase and redraw the frame. */)
5129 register Lisp_Object arg
;
5131 struct window
*w
= XWINDOW (selected_window
);
5132 struct buffer
*buf
= XBUFFER (w
->buffer
);
5133 struct buffer
*obuf
= current_buffer
;
5135 int charpos
, bytepos
;
5137 /* If redisplay is suppressed due to an error, try again. */
5138 obuf
->display_error_modiff
= 0;
5144 /* Invalidate pixel data calculated for all compositions. */
5145 for (i
= 0; i
< n_compositions
; i
++)
5146 composition_table
[i
]->font
= NULL
;
5148 Fredraw_frame (w
->frame
);
5149 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5152 else if (CONSP (arg
)) /* Just C-u. */
5156 arg
= Fprefix_numeric_value (arg
);
5160 set_buffer_internal (buf
);
5162 /* Handle centering on a graphical frame specially. Such frames can
5163 have variable-height lines and centering point on the basis of
5164 line counts would lead to strange effects. */
5165 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5172 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5173 start_display (&it
, w
, pt
);
5174 move_it_vertically (&it
, - window_box_height (w
) / 2);
5175 charpos
= IT_CHARPOS (it
);
5176 bytepos
= IT_BYTEPOS (it
);
5178 else if (XINT (arg
) < 0)
5182 int y0
, y1
, h
, nlines
;
5184 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5185 start_display (&it
, w
, pt
);
5188 /* The amount of pixels we have to move back is the window
5189 height minus what's displayed in the line containing PT,
5190 and the lines below. */
5191 nlines
= - XINT (arg
) - 1;
5192 move_it_by_lines (&it
, nlines
, 1);
5194 y1
= line_bottom_y (&it
);
5196 /* If we can't move down NLINES lines because we hit
5197 the end of the buffer, count in some empty lines. */
5198 if (it
.vpos
< nlines
)
5199 y1
+= (nlines
- it
.vpos
) * FRAME_LINE_HEIGHT (it
.f
);
5201 h
= window_box_height (w
) - (y1
- y0
);
5203 start_display (&it
, w
, pt
);
5204 move_it_vertically (&it
, - h
);
5205 charpos
= IT_CHARPOS (it
);
5206 bytepos
= IT_BYTEPOS (it
);
5210 struct position pos
;
5211 pos
= *vmotion (PT
, - XINT (arg
), w
);
5212 charpos
= pos
.bufpos
;
5213 bytepos
= pos
.bytepos
;
5218 struct position pos
;
5219 int ht
= window_internal_height (w
);
5222 arg
= make_number (ht
/ 2);
5223 else if (XINT (arg
) < 0)
5224 arg
= make_number (XINT (arg
) + ht
);
5226 pos
= *vmotion (PT
, - XINT (arg
), w
);
5227 charpos
= pos
.bufpos
;
5228 bytepos
= pos
.bytepos
;
5231 /* Set the new window start. */
5232 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5233 w
->window_end_valid
= Qnil
;
5235 w
->optional_new_start
= Qt
;
5237 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5238 w
->start_at_line_beg
= Qt
;
5240 w
->start_at_line_beg
= Qnil
;
5242 set_buffer_internal (obuf
);
5247 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5249 doc
: /* Return the height in lines of the text display area of WINDOW.
5250 This doesn't include the mode-line (or header-line if any) or any
5251 partial-height lines in the text display area. */)
5255 struct window
*w
= decode_window (window
);
5256 int pixel_height
= window_box_height (w
);
5257 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5258 return make_number (line_height
);
5263 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5265 doc
: /* Position point relative to window.
5266 With no argument, position point at center of window.
5267 An argument specifies vertical position within the window;
5268 zero means top of window, negative means relative to bottom of window. */)
5272 struct window
*w
= XWINDOW (selected_window
);
5276 window
= selected_window
;
5277 start
= marker_position (w
->start
);
5278 if (start
< BEGV
|| start
> ZV
)
5280 int height
= window_internal_height (w
);
5281 Fvertical_motion (make_number (- (height
/ 2)), window
);
5282 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5283 w
->start_at_line_beg
= Fbolp ();
5284 w
->force_start
= Qt
;
5287 Fgoto_char (w
->start
);
5289 lines
= displayed_window_lines (w
);
5291 XSETFASTINT (arg
, lines
/ 2);
5294 arg
= Fprefix_numeric_value (arg
);
5296 XSETINT (arg
, XINT (arg
) + lines
);
5299 /* Skip past a partially visible first line. */
5301 XSETINT (arg
, XINT (arg
) + 1);
5303 return Fvertical_motion (arg
, window
);
5308 /***********************************************************************
5309 Window Configuration
5310 ***********************************************************************/
5312 struct save_window_data
5314 EMACS_INT size_from_Lisp_Vector_struct
;
5315 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5316 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5317 Lisp_Object frame_tool_bar_lines
;
5318 Lisp_Object selected_frame
;
5319 Lisp_Object current_window
;
5320 Lisp_Object current_buffer
;
5321 Lisp_Object minibuf_scroll_window
;
5322 Lisp_Object minibuf_selected_window
;
5323 Lisp_Object root_window
;
5324 Lisp_Object focus_frame
;
5325 /* Record the values of window-min-width and window-min-height
5326 so that window sizes remain consistent with them. */
5327 Lisp_Object min_width
, min_height
;
5328 /* A vector, each of whose elements is a struct saved_window
5330 Lisp_Object saved_windows
;
5333 /* This is saved as a Lisp_Vector */
5336 /* these first two must agree with struct Lisp_Vector in lisp.h */
5337 EMACS_INT size_from_Lisp_Vector_struct
;
5338 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5341 Lisp_Object buffer
, start
, pointm
, mark
;
5342 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5343 Lisp_Object hscroll
, min_hscroll
;
5344 Lisp_Object parent
, prev
;
5345 Lisp_Object start_at_line_beg
;
5346 Lisp_Object display_table
;
5347 Lisp_Object orig_top_line
, orig_total_lines
;
5348 Lisp_Object left_margin_cols
, right_margin_cols
;
5349 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5350 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5353 #define SAVED_WINDOW_VECTOR_SIZE 24 /* Arg to Fmake_vector */
5355 #define SAVED_WINDOW_N(swv,n) \
5356 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5358 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5359 doc
: /* Return t if OBJECT is a window-configuration object. */)
5363 if (WINDOW_CONFIGURATIONP (object
))
5368 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5369 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5373 register struct save_window_data
*data
;
5374 struct Lisp_Vector
*saved_windows
;
5376 if (! WINDOW_CONFIGURATIONP (config
))
5377 wrong_type_argument (Qwindow_configuration_p
, config
);
5379 data
= (struct save_window_data
*) XVECTOR (config
);
5380 saved_windows
= XVECTOR (data
->saved_windows
);
5381 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5384 DEFUN ("set-window-configuration", Fset_window_configuration
,
5385 Sset_window_configuration
, 1, 1, 0,
5386 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5387 CONFIGURATION must be a value previously returned
5388 by `current-window-configuration' (which see).
5389 If CONFIGURATION was made from a frame that is now deleted,
5390 only frame-independent values can be restored. In this case,
5391 the return value is nil. Otherwise the value is t. */)
5393 Lisp_Object configuration
;
5395 register struct save_window_data
*data
;
5396 struct Lisp_Vector
*saved_windows
;
5397 Lisp_Object new_current_buffer
;
5402 while (!WINDOW_CONFIGURATIONP (configuration
))
5403 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5405 data
= (struct save_window_data
*) XVECTOR (configuration
);
5406 saved_windows
= XVECTOR (data
->saved_windows
);
5408 new_current_buffer
= data
->current_buffer
;
5409 if (NILP (XBUFFER (new_current_buffer
)->name
))
5410 new_current_buffer
= Qnil
;
5413 if (XBUFFER (new_current_buffer
) == current_buffer
)
5416 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5419 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5422 /* If f is a dead frame, don't bother rebuilding its window tree.
5423 However, there is other stuff we should still try to do below. */
5424 if (FRAME_LIVE_P (f
))
5426 register struct window
*w
;
5427 register struct saved_window
*p
;
5428 struct window
*root_window
;
5429 struct window
**leaf_windows
;
5433 /* If the frame has been resized since this window configuration was
5434 made, we change the frame to the size specified in the
5435 configuration, restore the configuration, and then resize it
5436 back. We keep track of the prevailing height in these variables. */
5437 int previous_frame_lines
= FRAME_LINES (f
);
5438 int previous_frame_cols
= FRAME_COLS (f
);
5439 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5440 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5442 /* The mouse highlighting code could get screwed up
5443 if it runs during this. */
5446 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5447 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5448 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5449 XFASTINT (data
->frame_cols
), 0, 0, 0);
5450 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5451 if (XFASTINT (data
->frame_menu_bar_lines
)
5452 != previous_frame_menu_bar_lines
)
5453 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5454 #ifdef HAVE_WINDOW_SYSTEM
5455 if (XFASTINT (data
->frame_tool_bar_lines
)
5456 != previous_frame_tool_bar_lines
)
5457 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5461 /* "Swap out" point from the selected window
5462 into its buffer. We do this now, before
5463 restoring the window contents, and prevent it from
5464 being done later on when we select a new window. */
5465 if (! NILP (XWINDOW (selected_window
)->buffer
))
5467 w
= XWINDOW (selected_window
);
5468 set_marker_both (w
->pointm
,
5470 BUF_PT (XBUFFER (w
->buffer
)),
5471 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5474 windows_or_buffers_changed
++;
5475 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5477 /* Problem: Freeing all matrices and later allocating them again
5478 is a serious redisplay flickering problem. What we would
5479 really like to do is to free only those matrices not reused
5481 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5483 = (struct window
**) alloca (count_windows (root_window
)
5484 * sizeof (struct window
*));
5485 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5487 /* Temporarily avoid any problems with windows that are smaller
5488 than they are supposed to be. */
5489 window_min_height
= 1;
5490 window_min_width
= 1;
5493 Mark all windows now on frame as "deleted".
5494 Restoring the new configuration "undeletes" any that are in it.
5496 Save their current buffers in their height fields, since we may
5497 need it later, if a buffer saved in the configuration is now
5499 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5501 for (k
= 0; k
< saved_windows
->size
; k
++)
5503 p
= SAVED_WINDOW_N (saved_windows
, k
);
5504 w
= XWINDOW (p
->window
);
5507 if (!NILP (p
->parent
))
5508 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5509 XFASTINT (p
->parent
))->window
;
5513 if (!NILP (p
->prev
))
5515 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5516 XFASTINT (p
->prev
))->window
;
5517 XWINDOW (w
->prev
)->next
= p
->window
;
5522 if (!NILP (w
->parent
))
5524 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5526 XWINDOW (w
->parent
)->vchild
= p
->window
;
5527 XWINDOW (w
->parent
)->hchild
= Qnil
;
5531 XWINDOW (w
->parent
)->hchild
= p
->window
;
5532 XWINDOW (w
->parent
)->vchild
= Qnil
;
5537 /* If we squirreled away the buffer in the window's height,
5539 if (BUFFERP (w
->total_lines
))
5540 w
->buffer
= w
->total_lines
;
5541 w
->left_col
= p
->left_col
;
5542 w
->top_line
= p
->top_line
;
5543 w
->total_cols
= p
->total_cols
;
5544 w
->total_lines
= p
->total_lines
;
5545 w
->hscroll
= p
->hscroll
;
5546 w
->min_hscroll
= p
->min_hscroll
;
5547 w
->display_table
= p
->display_table
;
5548 w
->orig_top_line
= p
->orig_top_line
;
5549 w
->orig_total_lines
= p
->orig_total_lines
;
5550 w
->left_margin_cols
= p
->left_margin_cols
;
5551 w
->right_margin_cols
= p
->right_margin_cols
;
5552 w
->left_fringe_width
= p
->left_fringe_width
;
5553 w
->right_fringe_width
= p
->right_fringe_width
;
5554 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5555 w
->scroll_bar_width
= p
->scroll_bar_width
;
5556 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5557 XSETFASTINT (w
->last_modified
, 0);
5558 XSETFASTINT (w
->last_overlay_modified
, 0);
5560 /* Reinstall the saved buffer and pointers into it. */
5561 if (NILP (p
->buffer
))
5562 w
->buffer
= p
->buffer
;
5565 if (!NILP (XBUFFER (p
->buffer
)->name
))
5566 /* If saved buffer is alive, install it. */
5568 w
->buffer
= p
->buffer
;
5569 w
->start_at_line_beg
= p
->start_at_line_beg
;
5570 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5571 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5572 Fset_marker (XBUFFER (w
->buffer
)->mark
,
5573 p
->mark
, w
->buffer
);
5575 /* As documented in Fcurrent_window_configuration, don't
5576 restore the location of point in the buffer which was
5577 current when the window configuration was recorded. */
5578 if (!EQ (p
->buffer
, new_current_buffer
)
5579 && XBUFFER (p
->buffer
) == current_buffer
)
5580 Fgoto_char (w
->pointm
);
5582 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
5583 /* Else unless window has a live buffer, get one. */
5585 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5586 /* This will set the markers to beginning of visible
5588 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5589 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5590 w
->start_at_line_beg
= Qt
;
5593 /* Keeping window's old buffer; make sure the markers
5596 /* Set window markers at start of visible range. */
5597 if (XMARKER (w
->start
)->buffer
== 0)
5598 set_marker_restricted (w
->start
, make_number (0),
5600 if (XMARKER (w
->pointm
)->buffer
== 0)
5601 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5602 BUF_PT (XBUFFER (w
->buffer
)),
5603 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5604 w
->start_at_line_beg
= Qt
;
5609 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5610 /* Prevent "swapping out point" in the old selected window
5611 using the buffer that has been restored into it.
5612 Use the point value from the beginning of this function
5613 since unshow_buffer (called from delete_all_subwindows)
5614 could have altered it. */
5615 selected_window
= Qnil
;
5616 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5617 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5618 make_number (old_point
),
5619 XWINDOW (data
->current_window
)->buffer
);
5621 Fselect_window (data
->current_window
, Qnil
);
5622 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
5625 if (NILP (data
->focus_frame
)
5626 || (FRAMEP (data
->focus_frame
)
5627 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5628 Fredirect_frame_focus (frame
, data
->focus_frame
);
5630 #if 0 /* I don't understand why this is needed, and it causes problems
5631 when the frame's old selected window has been deleted. */
5632 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
5633 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5637 /* Set the screen height to the value it had before this function. */
5638 if (previous_frame_lines
!= FRAME_LINES (f
)
5639 || previous_frame_cols
!= FRAME_COLS (f
))
5640 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5642 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5643 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5644 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5646 #ifdef HAVE_WINDOW_SYSTEM
5647 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5648 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5653 /* Now, free glyph matrices in windows that were not reused. */
5654 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5656 if (NILP (leaf_windows
[i
]->buffer
))
5658 /* Assert it's not reused as a combination. */
5659 xassert (NILP (leaf_windows
[i
]->hchild
)
5660 && NILP (leaf_windows
[i
]->vchild
));
5661 free_window_matrices (leaf_windows
[i
]);
5663 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5671 /* Fselect_window will have made f the selected frame, so we
5672 reselect the proper frame here. Fhandle_switch_frame will change the
5673 selected window too, but that doesn't make the call to
5674 Fselect_window above totally superfluous; it still sets f's
5676 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5677 do_switch_frame (data
->selected_frame
, 0, 0);
5679 if (! NILP (Vwindow_configuration_change_hook
)
5680 && ! NILP (Vrun_hooks
))
5681 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5684 if (!NILP (new_current_buffer
))
5685 Fset_buffer (new_current_buffer
);
5687 /* Restore the minimum heights recorded in the configuration. */
5688 window_min_height
= XINT (data
->min_height
);
5689 window_min_width
= XINT (data
->min_width
);
5691 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5692 minibuf_selected_window
= data
->minibuf_selected_window
;
5694 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5697 /* Mark all windows now on frame as deleted
5698 by setting their buffers to nil. */
5701 delete_all_subwindows (w
)
5702 register struct window
*w
;
5704 if (!NILP (w
->next
))
5705 delete_all_subwindows (XWINDOW (w
->next
));
5706 if (!NILP (w
->vchild
))
5707 delete_all_subwindows (XWINDOW (w
->vchild
));
5708 if (!NILP (w
->hchild
))
5709 delete_all_subwindows (XWINDOW (w
->hchild
));
5711 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5713 if (!NILP (w
->buffer
))
5716 /* We set all three of these fields to nil, to make sure that we can
5717 distinguish this dead window from any live window. Live leaf
5718 windows will have buffer set, and combination windows will have
5719 vchild or hchild set. */
5724 Vwindow_list
= Qnil
;
5728 count_windows (window
)
5729 register struct window
*window
;
5731 register int count
= 1;
5732 if (!NILP (window
->next
))
5733 count
+= count_windows (XWINDOW (window
->next
));
5734 if (!NILP (window
->vchild
))
5735 count
+= count_windows (XWINDOW (window
->vchild
));
5736 if (!NILP (window
->hchild
))
5737 count
+= count_windows (XWINDOW (window
->hchild
));
5742 /* Fill vector FLAT with leaf windows under W, starting at index I.
5743 Value is last index + 1. */
5746 get_leaf_windows (w
, flat
, i
)
5748 struct window
**flat
;
5753 if (!NILP (w
->hchild
))
5754 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5755 else if (!NILP (w
->vchild
))
5756 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5760 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5767 /* Return a pointer to the glyph W's physical cursor is on. Value is
5768 null if W's current matrix is invalid, so that no meaningfull glyph
5772 get_phys_cursor_glyph (w
)
5775 struct glyph_row
*row
;
5776 struct glyph
*glyph
;
5778 if (w
->phys_cursor
.vpos
>= 0
5779 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5780 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5782 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5783 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5792 save_window_save (window
, vector
, i
)
5794 struct Lisp_Vector
*vector
;
5797 register struct saved_window
*p
;
5798 register struct window
*w
;
5799 register Lisp_Object tem
;
5801 for (;!NILP (window
); window
= w
->next
)
5803 p
= SAVED_WINDOW_N (vector
, i
);
5804 w
= XWINDOW (window
);
5806 XSETFASTINT (w
->temslot
, i
++);
5808 p
->buffer
= w
->buffer
;
5809 p
->left_col
= w
->left_col
;
5810 p
->top_line
= w
->top_line
;
5811 p
->total_cols
= w
->total_cols
;
5812 p
->total_lines
= w
->total_lines
;
5813 p
->hscroll
= w
->hscroll
;
5814 p
->min_hscroll
= w
->min_hscroll
;
5815 p
->display_table
= w
->display_table
;
5816 p
->orig_top_line
= w
->orig_top_line
;
5817 p
->orig_total_lines
= w
->orig_total_lines
;
5818 p
->left_margin_cols
= w
->left_margin_cols
;
5819 p
->right_margin_cols
= w
->right_margin_cols
;
5820 p
->left_fringe_width
= w
->left_fringe_width
;
5821 p
->right_fringe_width
= w
->right_fringe_width
;
5822 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
5823 p
->scroll_bar_width
= w
->scroll_bar_width
;
5824 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5825 if (!NILP (w
->buffer
))
5827 /* Save w's value of point in the window configuration.
5828 If w is the selected window, then get the value of point
5829 from the buffer; pointm is garbage in the selected window. */
5830 if (EQ (window
, selected_window
))
5832 p
->pointm
= Fmake_marker ();
5833 set_marker_both (p
->pointm
, w
->buffer
,
5834 BUF_PT (XBUFFER (w
->buffer
)),
5835 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5838 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5840 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5841 p
->start_at_line_beg
= w
->start_at_line_beg
;
5843 tem
= XBUFFER (w
->buffer
)->mark
;
5844 p
->mark
= Fcopy_marker (tem
, Qnil
);
5851 p
->start_at_line_beg
= Qnil
;
5854 if (NILP (w
->parent
))
5857 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5862 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5864 if (!NILP (w
->vchild
))
5865 i
= save_window_save (w
->vchild
, vector
, i
);
5866 if (!NILP (w
->hchild
))
5867 i
= save_window_save (w
->hchild
, vector
, i
);
5873 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5874 Scurrent_window_configuration
, 0, 1, 0,
5875 doc
: /* Return an object representing the current window configuration of FRAME.
5876 If FRAME is nil or omitted, use the selected frame.
5877 This describes the number of windows, their sizes and current buffers,
5878 and for each displayed buffer, where display starts, and the positions of
5879 point and mark. An exception is made for point in the current buffer:
5880 its value is -not- saved.
5881 This also records the currently selected frame, and FRAME's focus
5882 redirection (see `redirect-frame-focus'). */)
5886 register Lisp_Object tem
;
5887 register int n_windows
;
5888 register struct save_window_data
*data
;
5889 register struct Lisp_Vector
*vec
;
5894 frame
= selected_frame
;
5895 CHECK_LIVE_FRAME (frame
);
5898 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5899 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
5900 data
= (struct save_window_data
*)vec
;
5902 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
5903 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
5904 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
5905 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
5906 data
->selected_frame
= selected_frame
;
5907 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5908 XSETBUFFER (data
->current_buffer
, current_buffer
);
5909 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
5910 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
5911 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5912 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5913 XSETINT (data
->min_height
, window_min_height
);
5914 XSETINT (data
->min_width
, window_min_width
);
5915 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5916 data
->saved_windows
= tem
;
5917 for (i
= 0; i
< n_windows
; i
++)
5918 XVECTOR (tem
)->contents
[i
]
5919 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
5920 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5921 XSETWINDOW_CONFIGURATION (tem
, data
);
5925 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
5927 doc
: /* Execute BODY, preserving window sizes and contents.
5928 Return the value of the last form in BODY.
5929 Restore which buffer appears in which window, where display starts,
5930 and the value of point and mark for each window.
5931 Also restore the choice of selected window.
5932 Also restore which buffer is current.
5933 Does not restore the value of point in current buffer.
5934 usage: (save-window-excursion BODY ...) */)
5938 register Lisp_Object val
;
5939 register int count
= SPECPDL_INDEX ();
5941 record_unwind_protect (Fset_window_configuration
,
5942 Fcurrent_window_configuration (Qnil
));
5943 val
= Fprogn (args
);
5944 return unbind_to (count
, val
);
5948 /***********************************************************************
5950 ***********************************************************************/
5952 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5954 doc
: /* Set width of marginal areas of window WINDOW.
5955 If WINDOW is nil, set margins of the currently selected window.
5956 Second arg LEFT-WIDTH specifies the number of character cells to
5957 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
5958 does the same for the right marginal area. A nil width parameter
5959 means no margin. */)
5960 (window
, left
, right
)
5961 Lisp_Object window
, left
, right
;
5963 struct window
*w
= decode_window (window
);
5965 /* Translate negative or zero widths to nil.
5966 Margins that are too wide have to be checked elsewhere. */
5970 CHECK_NUMBER (left
);
5971 if (XINT (left
) <= 0)
5977 CHECK_NUMBER (right
);
5978 if (XINT (right
) <= 0)
5982 if (!EQ (w
->left_margin_cols
, left
)
5983 || !EQ (w
->right_margin_cols
, right
))
5985 w
->left_margin_cols
= left
;
5986 w
->right_margin_cols
= right
;
5988 adjust_window_margins (w
);
5990 ++windows_or_buffers_changed
;
5991 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
5998 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6000 doc
: /* Get width of marginal areas of window WINDOW.
6001 If WINDOW is omitted or nil, use the currently selected window.
6002 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6003 If a marginal area does not exist, its width will be returned
6008 struct window
*w
= decode_window (window
);
6009 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6014 /***********************************************************************
6016 ***********************************************************************/
6018 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6020 doc
: /* Set the fringe widths of window WINDOW.
6021 If WINDOW is nil, set the fringe widths of the currently selected
6023 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6024 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6025 fringe width. If a fringe width arg is nil, that means to use the
6026 frame's default fringe width. Default fringe widths can be set with
6027 the command `set-fringe-style'.
6028 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6029 outside of the display margins. By default, fringes are drawn between
6030 display marginal areas and the text area. */)
6031 (window
, left
, right
, outside_margins
)
6032 Lisp_Object window
, left
, right
, outside_margins
;
6034 struct window
*w
= decode_window (window
);
6037 CHECK_NUMBER (left
);
6039 CHECK_NUMBER (right
);
6041 if (!EQ (w
->left_fringe_width
, left
)
6042 || !EQ (w
->right_fringe_width
, right
)
6043 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6045 w
->left_fringe_width
= left
;
6046 w
->right_fringe_width
= right
;
6047 w
->fringes_outside_margins
= outside_margins
;
6049 adjust_window_margins (w
);
6051 clear_glyph_matrix (w
->current_matrix
);
6052 w
->window_end_valid
= Qnil
;
6054 ++windows_or_buffers_changed
;
6055 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6062 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6064 doc
: /* Get width of fringes of window WINDOW.
6065 If WINDOW is omitted or nil, use the currently selected window.
6066 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6070 struct window
*w
= decode_window (window
);
6071 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6072 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6073 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6074 Qt
: Qnil
), Qnil
)));
6079 /***********************************************************************
6081 ***********************************************************************/
6083 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6085 doc
: /* Set width and type of scroll bars of window WINDOW.
6086 If window is nil, set scroll bars of the currently selected window.
6087 Second parameter WIDTH specifies the pixel width for the scroll bar;
6088 this is automatically adjusted to a multiple of the frame column width.
6089 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6090 bar: left, right, or nil.
6091 If WIDTH is nil, use the frame's scroll-bar width.
6092 If TYPE is t, use the frame's scroll-bar type. */)
6093 (window
, width
, vertical_type
, horizontal_type
)
6094 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6096 struct window
*w
= decode_window (window
);
6099 CHECK_NUMBER (width
);
6101 if (XINT (width
) == 0)
6102 vertical_type
= Qnil
;
6104 if (!(EQ (vertical_type
, Qnil
)
6105 || EQ (vertical_type
, Qleft
)
6106 || EQ (vertical_type
, Qright
)
6107 || EQ (vertical_type
, Qt
)))
6108 error ("Invalid type of vertical scroll bar");
6110 if (!EQ (w
->scroll_bar_width
, width
)
6111 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6113 w
->scroll_bar_width
= width
;
6114 w
->vertical_scroll_bar_type
= vertical_type
;
6116 adjust_window_margins (w
);
6118 clear_glyph_matrix (w
->current_matrix
);
6119 w
->window_end_valid
= Qnil
;
6121 ++windows_or_buffers_changed
;
6122 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6129 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6131 doc
: /* Get width and type of scroll bars of window WINDOW.
6132 If WINDOW is omitted or nil, use the currently selected window.
6133 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6134 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6139 struct window
*w
= decode_window (window
);
6140 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6141 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6142 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6143 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6144 Fcons (w
->vertical_scroll_bar_type
,
6145 Fcons (Qnil
, Qnil
))));
6150 /***********************************************************************
6152 ***********************************************************************/
6154 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6155 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6156 Use the selected window if WINDOW is nil or omitted.
6157 Normally, value is a multiple of the canonical character height of WINDOW;
6158 optional second arg PIXELS_P means value is measured in pixels. */)
6160 Lisp_Object window
, pixels_p
;
6167 window
= selected_window
;
6169 CHECK_WINDOW (window
);
6170 w
= XWINDOW (window
);
6171 f
= XFRAME (w
->frame
);
6173 if (FRAME_WINDOW_P (f
))
6174 result
= (NILP (pixels_p
)
6175 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6176 : make_number (-w
->vscroll
));
6178 result
= make_number (0);
6183 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6185 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6186 WINDOW nil means use the selected window. Normally, VSCROLL is a
6187 non-negative multiple of the canonical character height of WINDOW;
6188 optional third arg PIXELS_P non-nil means that VSCROLL is in pixels.
6189 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6190 corresponds to an integral number of pixels. The return value is the
6191 result of this rounding.
6192 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6193 (window
, vscroll
, pixels_p
)
6194 Lisp_Object window
, vscroll
, pixels_p
;
6200 window
= selected_window
;
6202 CHECK_WINDOW (window
);
6203 CHECK_NUMBER_OR_FLOAT (vscroll
);
6205 w
= XWINDOW (window
);
6206 f
= XFRAME (w
->frame
);
6208 if (FRAME_WINDOW_P (f
))
6210 int old_dy
= w
->vscroll
;
6212 w
->vscroll
= - (NILP (pixels_p
)
6213 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6214 : XFLOATINT (vscroll
));
6215 w
->vscroll
= min (w
->vscroll
, 0);
6217 /* Adjust glyph matrix of the frame if the virtual display
6218 area becomes larger than before. */
6219 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6222 /* Prevent redisplay shortcuts. */
6223 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6226 return Fwindow_vscroll (window
, pixels_p
);
6230 /* Call FN for all leaf windows on frame F. FN is called with the
6231 first argument being a pointer to the leaf window, and with
6232 additional argument USER_DATA. Stops when FN returns 0. */
6235 foreach_window (f
, fn
, user_data
)
6237 int (* fn
) P_ ((struct window
*, void *));
6240 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6244 /* Helper function for foreach_window. Call FN for all leaf windows
6245 reachable from W. FN is called with the first argument being a
6246 pointer to the leaf window, and with additional argument USER_DATA.
6247 Stop when FN returns 0. Value is 0 if stopped by FN. */
6250 foreach_window_1 (w
, fn
, user_data
)
6252 int (* fn
) P_ ((struct window
*, void *));
6257 for (cont
= 1; w
&& cont
;)
6259 if (!NILP (w
->hchild
))
6260 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6261 else if (!NILP (w
->vchild
))
6262 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6264 cont
= fn (w
, user_data
);
6266 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6273 /* Freeze or unfreeze the window start of W unless it is a
6274 mini-window or the selected window. FREEZE_P non-null means freeze
6275 the window start. */
6278 freeze_window_start (w
, freeze_p
)
6282 if (w
== XWINDOW (selected_window
)
6283 || MINI_WINDOW_P (w
)
6284 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6285 && ! NILP (Vminibuf_scroll_window
)
6286 && w
== XWINDOW (Vminibuf_scroll_window
)))
6289 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6294 /* Freeze or unfreeze the window starts of all leaf windows on frame
6295 F, except the selected window and a mini-window. FREEZE_P non-zero
6296 means freeze the window start. */
6299 freeze_window_starts (f
, freeze_p
)
6303 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6307 /***********************************************************************
6309 ***********************************************************************/
6311 /* Return 1 if window configurations C1 and C2
6312 describe the same state of affairs. This is used by Fequal. */
6315 compare_window_configurations (c1
, c2
, ignore_positions
)
6317 int ignore_positions
;
6319 register struct save_window_data
*d1
, *d2
;
6320 struct Lisp_Vector
*sw1
, *sw2
;
6323 if (!WINDOW_CONFIGURATIONP (c1
))
6324 wrong_type_argument (Qwindow_configuration_p
, c1
);
6325 if (!WINDOW_CONFIGURATIONP (c2
))
6326 wrong_type_argument (Qwindow_configuration_p
, c2
);
6328 d1
= (struct save_window_data
*) XVECTOR (c1
);
6329 d2
= (struct save_window_data
*) XVECTOR (c2
);
6330 sw1
= XVECTOR (d1
->saved_windows
);
6331 sw2
= XVECTOR (d2
->saved_windows
);
6333 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6335 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6337 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6339 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6341 /* Don't compare the current_window field directly.
6342 Instead see w1_is_current and w2_is_current, below. */
6343 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6345 if (! ignore_positions
)
6347 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6349 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6352 /* Don't compare the root_window field.
6353 We don't require the two configurations
6354 to use the same window object,
6355 and the two root windows must be equivalent
6356 if everything else compares equal. */
6357 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6359 if (! EQ (d1
->min_width
, d2
->min_width
))
6361 if (! EQ (d1
->min_height
, d2
->min_height
))
6364 /* Verify that the two confis have the same number of windows. */
6365 if (sw1
->size
!= sw2
->size
)
6368 for (i
= 0; i
< sw1
->size
; i
++)
6370 struct saved_window
*p1
, *p2
;
6371 int w1_is_current
, w2_is_current
;
6373 p1
= SAVED_WINDOW_N (sw1
, i
);
6374 p2
= SAVED_WINDOW_N (sw2
, i
);
6376 /* Verify that the current windows in the two
6377 configurations correspond to each other. */
6378 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6379 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6381 if (w1_is_current
!= w2_is_current
)
6384 /* Verify that the corresponding windows do match. */
6385 if (! EQ (p1
->buffer
, p2
->buffer
))
6387 if (! EQ (p1
->left_col
, p2
->left_col
))
6389 if (! EQ (p1
->top_line
, p2
->top_line
))
6391 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6393 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6395 if (! EQ (p1
->display_table
, p2
->display_table
))
6397 if (! EQ (p1
->parent
, p2
->parent
))
6399 if (! EQ (p1
->prev
, p2
->prev
))
6401 if (! ignore_positions
)
6403 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6405 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6407 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6409 if (NILP (Fequal (p1
->start
, p2
->start
)))
6411 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6413 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6416 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6418 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6420 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6422 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6424 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6426 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6428 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6435 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6436 Scompare_window_configurations
, 2, 2, 0,
6437 doc
: /* Compare two window configurations as regards the structure of windows.
6438 This function ignores details such as the values of point and mark
6439 and scrolling positions. */)
6443 if (compare_window_configurations (x
, y
, 1))
6451 struct frame
*f
= make_terminal_frame ();
6452 XSETFRAME (selected_frame
, f
);
6453 Vterminal_frame
= selected_frame
;
6454 minibuf_window
= f
->minibuffer_window
;
6455 selected_window
= f
->selected_window
;
6456 last_nonminibuf_frame
= f
;
6458 window_initialized
= 1;
6464 Vwindow_list
= Qnil
;
6470 Qwindow_size_fixed
= intern ("window-size-fixed");
6471 staticpro (&Qwindow_size_fixed
);
6473 staticpro (&Qwindow_configuration_change_hook
);
6474 Qwindow_configuration_change_hook
6475 = intern ("window-configuration-change-hook");
6477 Qwindowp
= intern ("windowp");
6478 staticpro (&Qwindowp
);
6480 Qwindow_configuration_p
= intern ("window-configuration-p");
6481 staticpro (&Qwindow_configuration_p
);
6483 Qwindow_live_p
= intern ("window-live-p");
6484 staticpro (&Qwindow_live_p
);
6486 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
6487 staticpro (&Qtemp_buffer_show_hook
);
6489 staticpro (&Vwindow_list
);
6491 minibuf_selected_window
= Qnil
;
6492 staticpro (&minibuf_selected_window
);
6494 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
6495 doc
: /* Non-nil means call as function to display a help buffer.
6496 The function is called with one argument, the buffer to be displayed.
6497 Used by `with-output-to-temp-buffer'.
6498 If this function is used, then it must do the entire job of showing
6499 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6500 Vtemp_buffer_show_function
= Qnil
;
6502 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
6503 doc
: /* If non-nil, function to call to handle `display-buffer'.
6504 It will receive two args, the buffer and a flag which if non-nil means
6505 that the currently selected window is not acceptable.
6506 It should choose or create a window, display the specified buffer in it,
6507 and return the window.
6508 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
6509 work using this function. */);
6510 Vdisplay_buffer_function
= Qnil
;
6512 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
6513 doc
: /* *If non-nil, `display-buffer' should even the window heights.
6514 If nil, `display-buffer' will leave the window configuration alone. */);
6515 Veven_window_heights
= Qt
;
6517 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
6518 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6519 Vminibuf_scroll_window
= Qnil
;
6521 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
6522 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6523 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6524 is displayed in the `mode-line' face. */);
6525 mode_line_in_non_selected_windows
= 1;
6527 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
6528 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6529 Vother_window_scroll_buffer
= Qnil
;
6531 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
6532 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
6535 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
6536 doc
: /* *Non-nil means `display-buffer' should reuse frames.
6537 If the buffer in question is already displayed in a frame, raise that frame. */);
6538 display_buffer_reuse_frames
= 0;
6540 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
6541 doc
: /* Function to call to handle automatic new frame creation.
6542 It is called with no arguments and should return a newly created frame.
6544 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
6545 where `pop-up-frame-alist' would hold the default frame parameters. */);
6546 Vpop_up_frame_function
= Qnil
;
6548 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
6549 doc
: /* *List of buffer names that should have their own special frames.
6550 Displaying a buffer whose name is in this list makes a special frame for it
6551 using `special-display-function'. See also `special-display-regexps'.
6553 An element of the list can be a list instead of just a string.
6554 There are two ways to use a list as an element:
6555 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
6556 In the first case, the FRAME-PARAMETERS are pairs of the form
6557 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6558 In the second case, FUNCTION is called with BUFFER as the first argument,
6559 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
6560 All this is done by the function found in `special-display-function'.
6562 If the specified frame parameters include (same-buffer . t), the
6563 buffer is displayed in the currently selected window. Otherwise, if
6564 they include (same-frame . t), the buffer is displayed in a new window
6565 in the currently selected frame.
6567 If this variable appears \"not to work\", because you add a name to it
6568 but that buffer still appears in the selected window, look at the
6569 values of `same-window-buffer-names' and `same-window-regexps'.
6570 Those variables take precedence over this one. */);
6571 Vspecial_display_buffer_names
= Qnil
;
6573 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
6574 doc
: /* *List of regexps saying which buffers should have their own special frames.
6575 If a buffer name matches one of these regexps, it gets its own frame.
6576 Displaying a buffer whose name is in this list makes a special frame for it
6577 using `special-display-function'.
6579 An element of the list can be a list instead of just a string.
6580 There are two ways to use a list as an element:
6581 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
6582 In the first case, the FRAME-PARAMETERS are pairs of the form
6583 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6584 In the second case, FUNCTION is called with BUFFER as the first argument,
6585 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
6586 All this is done by the function found in `special-display-function'.
6588 If the specified frame parameters include (same-buffer . t), the
6589 buffer is displayed in the currently selected window. Otherwise, if
6590 they include (same-frame . t), the buffer is displayed in a new window
6591 in the currently selected frame.
6593 If this variable appears \"not to work\", because you add a regexp to it
6594 but the matching buffers still appear in the selected window, look at the
6595 values of `same-window-buffer-names' and `same-window-regexps'.
6596 Those variables take precedence over this one. */);
6597 Vspecial_display_regexps
= Qnil
;
6599 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
6600 doc
: /* Function to call to make a new frame for a special buffer.
6601 It is called with two arguments, the buffer and optional buffer specific
6602 data, and should return a window displaying that buffer.
6603 The default value normally makes a separate frame for the buffer,
6604 using `special-display-frame-alist' to specify the frame parameters.
6605 But if the buffer specific data includes (same-buffer . t) then the
6606 buffer is displayed in the current selected window.
6607 Otherwise if it includes (same-frame . t) then the buffer is displayed in
6608 a new window in the currently selected frame.
6610 A buffer is special if it is listed in `special-display-buffer-names'
6611 or matches a regexp in `special-display-regexps'. */);
6612 Vspecial_display_function
= Qnil
;
6614 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
6615 doc
: /* *List of buffer names that should appear in the selected window.
6616 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
6617 switches to it in the selected window, rather than making it appear
6618 in some other window.
6620 An element of the list can be a cons cell instead of just a string.
6621 Then the car must be a string, which specifies the buffer name.
6622 This is for compatibility with `special-display-buffer-names';
6623 the cdr of the cons cell is ignored.
6625 See also `same-window-regexps'. */);
6626 Vsame_window_buffer_names
= Qnil
;
6628 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
6629 doc
: /* *List of regexps saying which buffers should appear in the selected window.
6630 If a buffer name matches one of these regexps, then displaying it
6631 using `display-buffer' or `pop-to-buffer' switches to it
6632 in the selected window, rather than making it appear in some other window.
6634 An element of the list can be a cons cell instead of just a string.
6635 Then the car must be a string, which specifies the buffer name.
6636 This is for compatibility with `special-display-buffer-names';
6637 the cdr of the cons cell is ignored.
6639 See also `same-window-buffer-names'. */);
6640 Vsame_window_regexps
= Qnil
;
6642 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
6643 doc
: /* *Non-nil means display-buffer should make new windows. */);
6646 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
6647 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
6648 next_screen_context_lines
= 2;
6650 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
6651 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
6652 If there is only one window, it is split regardless of this value. */);
6653 split_height_threshold
= 500;
6655 DEFVAR_INT ("window-min-height", &window_min_height
,
6656 doc
: /* *Delete any window less than this tall (including its mode line). */);
6657 window_min_height
= 4;
6659 DEFVAR_INT ("window-min-width", &window_min_width
,
6660 doc
: /* *Delete any window less than this wide. */);
6661 window_min_width
= 10;
6663 DEFVAR_LISP ("scroll-preserve-screen-position",
6664 &Vscroll_preserve_screen_position
,
6665 doc
: /* *Non-nil means scroll commands move point to keep its screen line unchanged. */);
6666 Vscroll_preserve_screen_position
= Qnil
;
6668 DEFVAR_LISP ("window-configuration-change-hook",
6669 &Vwindow_configuration_change_hook
,
6670 doc
: /* Functions to call when window configuration changes.
6671 The selected frame is the one whose configuration has changed. */);
6672 Vwindow_configuration_change_hook
= Qnil
;
6674 DEFVAR_BOOL ("window-size-fixed", &window_size_fixed
,
6675 doc
: /* Non-nil in a buffer means windows displaying the buffer are fixed-size.
6676 If the value is`height', then only the window's height is fixed.
6677 If the value is `width', then only the window's width is fixed.
6678 Any other non-nil value fixes both the width and the height.
6679 Emacs won't change the size of any window displaying that buffer,
6680 unless you explicitly change the size, or Emacs has no other choice. */);
6681 Fmake_variable_buffer_local (Qwindow_size_fixed
);
6682 window_size_fixed
= 0;
6684 defsubr (&Sselected_window
);
6685 defsubr (&Sminibuffer_window
);
6686 defsubr (&Swindow_minibuffer_p
);
6687 defsubr (&Swindowp
);
6688 defsubr (&Swindow_live_p
);
6689 defsubr (&Spos_visible_in_window_p
);
6690 defsubr (&Swindow_buffer
);
6691 defsubr (&Swindow_height
);
6692 defsubr (&Swindow_width
);
6693 defsubr (&Swindow_hscroll
);
6694 defsubr (&Sset_window_hscroll
);
6695 defsubr (&Swindow_redisplay_end_trigger
);
6696 defsubr (&Sset_window_redisplay_end_trigger
);
6697 defsubr (&Swindow_edges
);
6698 defsubr (&Swindow_pixel_edges
);
6699 defsubr (&Swindow_inside_edges
);
6700 defsubr (&Swindow_inside_pixel_edges
);
6701 defsubr (&Scoordinates_in_window_p
);
6702 defsubr (&Swindow_at
);
6703 defsubr (&Swindow_point
);
6704 defsubr (&Swindow_start
);
6705 defsubr (&Swindow_end
);
6706 defsubr (&Sset_window_point
);
6707 defsubr (&Sset_window_start
);
6708 defsubr (&Swindow_dedicated_p
);
6709 defsubr (&Sset_window_dedicated_p
);
6710 defsubr (&Swindow_display_table
);
6711 defsubr (&Sset_window_display_table
);
6712 defsubr (&Snext_window
);
6713 defsubr (&Sprevious_window
);
6714 defsubr (&Sother_window
);
6715 defsubr (&Sget_lru_window
);
6716 defsubr (&Sget_largest_window
);
6717 defsubr (&Sget_buffer_window
);
6718 defsubr (&Sdelete_other_windows
);
6719 defsubr (&Sdelete_windows_on
);
6720 defsubr (&Sreplace_buffer_in_windows
);
6721 defsubr (&Sdelete_window
);
6722 defsubr (&Sset_window_buffer
);
6723 defsubr (&Sselect_window
);
6724 defsubr (&Sspecial_display_p
);
6725 defsubr (&Ssame_window_p
);
6726 defsubr (&Sdisplay_buffer
);
6727 defsubr (&Sforce_window_update
);
6728 defsubr (&Ssplit_window
);
6729 defsubr (&Senlarge_window
);
6730 defsubr (&Sshrink_window
);
6731 defsubr (&Sscroll_up
);
6732 defsubr (&Sscroll_down
);
6733 defsubr (&Sscroll_left
);
6734 defsubr (&Sscroll_right
);
6735 defsubr (&Sother_window_for_scrolling
);
6736 defsubr (&Sscroll_other_window
);
6737 defsubr (&Sminibuffer_selected_window
);
6738 defsubr (&Srecenter
);
6739 defsubr (&Swindow_text_height
);
6740 defsubr (&Smove_to_window_line
);
6741 defsubr (&Swindow_configuration_p
);
6742 defsubr (&Swindow_configuration_frame
);
6743 defsubr (&Sset_window_configuration
);
6744 defsubr (&Scurrent_window_configuration
);
6745 defsubr (&Ssave_window_excursion
);
6746 defsubr (&Sset_window_margins
);
6747 defsubr (&Swindow_margins
);
6748 defsubr (&Sset_window_fringes
);
6749 defsubr (&Swindow_fringes
);
6750 defsubr (&Sset_window_scroll_bars
);
6751 defsubr (&Swindow_scroll_bars
);
6752 defsubr (&Swindow_vscroll
);
6753 defsubr (&Sset_window_vscroll
);
6754 defsubr (&Scompare_window_configurations
);
6755 defsubr (&Swindow_list
);
6761 initial_define_key (control_x_map
, '1', "delete-other-windows");
6762 initial_define_key (control_x_map
, '2', "split-window");
6763 initial_define_key (control_x_map
, '0', "delete-window");
6764 initial_define_key (control_x_map
, 'o', "other-window");
6765 initial_define_key (control_x_map
, '^', "enlarge-window");
6766 initial_define_key (control_x_map
, '<', "scroll-left");
6767 initial_define_key (control_x_map
, '>', "scroll-right");
6769 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
6770 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6771 initial_define_key (meta_map
, 'v', "scroll-down");
6773 initial_define_key (global_map
, Ctl('L'), "recenter");
6774 initial_define_key (meta_map
, 'r', "move-to-window-line");
6777 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
6778 (do not change this comment) */