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. */
36 #include "dispextern.h"
37 #include "blockinput.h"
38 #include "intervals.h"
42 #endif /* HAVE_X_WINDOWS */
54 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
55 Lisp_Object Qwindow_size_fixed
;
56 extern Lisp_Object Qleft_margin
, Qright_margin
;
58 static int displayed_window_lines
P_ ((struct window
*));
59 static struct window
*decode_window
P_ ((Lisp_Object
));
60 static int count_windows
P_ ((struct window
*));
61 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
62 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
63 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
64 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
65 static int window_min_size_1
P_ ((struct window
*, int));
66 static int window_min_size
P_ ((struct window
*, int, int, int *));
67 static void size_window
P_ ((Lisp_Object
, int, int, int));
68 static int freeze_window_start
P_ ((struct window
*, void *));
69 static int window_fixed_size_p
P_ ((struct window
*, int, int));
70 static void enlarge_window
P_ ((Lisp_Object
, int, int, int));
71 static Lisp_Object window_list
P_ ((void));
72 static int add_window_to_list
P_ ((struct window
*, void *));
73 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
75 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
77 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
79 static int foreach_window_1
P_ ((struct window
*,
80 int (* fn
) (struct window
*, void *),
82 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
84 /* The value of `window-size-fixed'. */
86 int window_size_fixed
;
88 /* This is the window in which the terminal's cursor should
89 be left when nothing is being done with it. This must
90 always be a leaf window, and its buffer is selected by
91 the top level editing loop at the end of each command.
93 This value is always the same as
94 FRAME_SELECTED_WINDOW (selected_frame). */
96 Lisp_Object selected_window
;
98 /* A list of all windows for use by next_window and Fwindow_list.
99 Functions creating or deleting windows should invalidate this cache
100 by setting it to nil. */
102 Lisp_Object Vwindow_list
;
104 /* The mini-buffer window of the selected frame.
105 Note that you cannot test for mini-bufferness of an arbitrary window
106 by comparing against this; but you can test for mini-bufferness of
107 the selected window. */
109 Lisp_Object minibuf_window
;
111 /* Non-nil means it is the window whose mode line should be
112 shown as the selected window when the minibuffer is selected. */
114 Lisp_Object minibuf_selected_window
;
116 /* Non-nil means it is the window for C-M-v to scroll
117 when the mini-buffer is selected. */
119 Lisp_Object Vminibuf_scroll_window
;
121 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
123 Lisp_Object Vother_window_scroll_buffer
;
125 /* Non-nil means it's function to call to display temp buffers. */
127 Lisp_Object Vtemp_buffer_show_function
;
129 /* Non-zero means line and page scrolling on tall lines (with images)
130 does partial scrolling by modifying window-vscroll. */
132 int auto_window_vscroll_p
;
134 /* Non-zero means to use mode-line-inactive face in all windows but the
135 selected-window and the minibuffer-scroll-window when the
136 minibuffer is active. */
137 int mode_line_in_non_selected_windows
;
139 /* If a window gets smaller than either of these, it is removed. */
141 EMACS_INT window_min_height
;
142 EMACS_INT window_min_width
;
144 /* Nonzero implies Fdisplay_buffer should create windows. */
148 /* Nonzero implies make new frames for Fdisplay_buffer. */
152 /* Nonzero means reuse existing frames for displaying buffers. */
154 int display_buffer_reuse_frames
;
156 /* Non-nil means use this function instead of default */
158 Lisp_Object Vpop_up_frame_function
;
160 /* Function to call to handle Fdisplay_buffer. */
162 Lisp_Object Vdisplay_buffer_function
;
164 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
166 Lisp_Object Veven_window_heights
;
168 /* List of buffer *names* for buffers that should have their own frames. */
170 Lisp_Object Vspecial_display_buffer_names
;
172 /* List of regexps for buffer names that should have their own frames. */
174 Lisp_Object Vspecial_display_regexps
;
176 /* Function to pop up a special frame. */
178 Lisp_Object Vspecial_display_function
;
180 /* List of buffer *names* for buffers to appear in selected window. */
182 Lisp_Object Vsame_window_buffer_names
;
184 /* List of regexps for buffer names to appear in selected window. */
186 Lisp_Object Vsame_window_regexps
;
188 /* Hook run at end of temp_output_buffer_show. */
190 Lisp_Object Qtemp_buffer_show_hook
;
192 /* Fdisplay_buffer always splits the largest window
193 if that window is more than this high. */
195 EMACS_INT split_height_threshold
;
197 /* Number of lines of continuity in scrolling by screenfuls. */
199 EMACS_INT next_screen_context_lines
;
201 /* Incremented for each window created. */
203 static int sequence_number
;
205 /* Nonzero after init_window_once has finished. */
207 static int window_initialized
;
209 /* Hook to run when window config changes. */
211 Lisp_Object Qwindow_configuration_change_hook
;
212 Lisp_Object Vwindow_configuration_change_hook
;
214 /* Non-nil means scroll commands try to put point
215 at the same screen height as previously. */
217 Lisp_Object Vscroll_preserve_screen_position
;
219 #if 0 /* This isn't used anywhere. */
220 /* Nonzero means we can split a frame even if it is "unsplittable". */
221 static int inhibit_frame_unsplittable
;
224 extern EMACS_INT scroll_margin
;
226 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
228 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
229 doc
: /* Returns t if OBJECT is a window. */)
233 return WINDOWP (object
) ? Qt
: Qnil
;
236 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
237 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
241 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
248 register struct window
*p
;
250 p
= allocate_window ();
252 XSETFASTINT (p
->sequence_number
, sequence_number
);
253 XSETFASTINT (p
->left_col
, 0);
254 XSETFASTINT (p
->top_line
, 0);
255 XSETFASTINT (p
->total_lines
, 0);
256 XSETFASTINT (p
->total_cols
, 0);
257 XSETFASTINT (p
->hscroll
, 0);
258 XSETFASTINT (p
->min_hscroll
, 0);
259 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
260 p
->start
= Fmake_marker ();
261 p
->pointm
= Fmake_marker ();
262 XSETFASTINT (p
->use_time
, 0);
264 p
->display_table
= Qnil
;
266 p
->pseudo_window_p
= 0;
267 bzero (&p
->cursor
, sizeof (p
->cursor
));
268 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
269 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
270 p
->desired_matrix
= p
->current_matrix
= 0;
271 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
272 p
->phys_cursor_type
= -1;
273 p
->phys_cursor_width
= -1;
274 p
->must_be_updated_p
= 0;
275 XSETFASTINT (p
->window_end_vpos
, 0);
276 XSETFASTINT (p
->window_end_pos
, 0);
277 p
->window_end_valid
= Qnil
;
280 XSETFASTINT (p
->last_point
, 0);
281 p
->frozen_window_start_p
= 0;
282 p
->height_fixed_p
= 0;
283 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
284 p
->left_margin_cols
= Qnil
;
285 p
->right_margin_cols
= Qnil
;
286 p
->left_fringe_width
= Qnil
;
287 p
->right_fringe_width
= Qnil
;
288 p
->fringes_outside_margins
= Qnil
;
289 p
->scroll_bar_width
= Qnil
;
290 p
->vertical_scroll_bar_type
= Qt
;
291 p
->overlay_arrow_bitmap
= 0;
297 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
298 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
301 return selected_window
;
304 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
305 doc
: /* Return the window used now for minibuffers.
306 If the optional argument FRAME is specified, return the minibuffer window
307 used by that frame. */)
312 frame
= selected_frame
;
313 CHECK_LIVE_FRAME (frame
);
314 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
317 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
318 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
319 WINDOW defaults to the selected window. */)
323 struct window
*w
= decode_window (window
);
324 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
328 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
329 Spos_visible_in_window_p
, 0, 3, 0,
330 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
331 Return nil if that position is scrolled vertically out of view.
332 If a character is only partially visible, nil is returned, unless the
333 optional argument PARTIALLY is non-nil.
334 If POS is only out of view because of horizontal scrolling, return non-nil.
335 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
337 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
338 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
339 relative to the top left corner of the window. PARTIAL is nil if the character
340 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
341 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
342 (pos
, window
, partially
)
343 Lisp_Object pos
, window
, partially
;
345 register struct window
*w
;
347 register struct buffer
*buf
;
349 Lisp_Object in_window
= Qnil
;
350 int rtop
, rbot
, fully_p
= 1;
353 w
= decode_window (window
);
354 buf
= XBUFFER (w
->buffer
);
355 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
359 CHECK_NUMBER_COERCE_MARKER (pos
);
362 else if (w
== XWINDOW (selected_window
))
365 posint
= XMARKER (w
->pointm
)->charpos
;
367 /* If position is above window start or outside buffer boundaries,
368 or if window start is out of range, position is not visible. */
369 if (posint
>= CHARPOS (top
)
370 && posint
<= BUF_ZV (buf
)
371 && CHARPOS (top
) >= BUF_BEGV (buf
)
372 && CHARPOS (top
) <= BUF_ZV (buf
)
373 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
374 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
377 if (!NILP (in_window
) && !NILP (partially
))
378 in_window
= Fcons (make_number (x
),
379 Fcons (make_number (y
),
380 Fcons ((fully_p
? Qnil
381 : Fcons (make_number (rtop
),
382 make_number (rbot
))),
388 static struct window
*
389 decode_window (window
)
390 register Lisp_Object window
;
393 return XWINDOW (selected_window
);
395 CHECK_LIVE_WINDOW (window
);
396 return XWINDOW (window
);
399 static struct window
*
400 decode_any_window (window
)
401 register Lisp_Object window
;
404 return XWINDOW (selected_window
);
406 CHECK_WINDOW (window
);
407 return XWINDOW (window
);
410 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
411 doc
: /* Return the buffer that WINDOW is displaying.
412 WINDOW defaults to the selected window. */)
416 return decode_window (window
)->buffer
;
419 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
420 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
424 return decode_any_window (window
)->total_lines
;
427 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
428 doc
: /* Return the number of display columns in WINDOW.
429 This is the width that is usable columns available for text in WINDOW.
430 If you want to find out how many columns WINDOW takes up,
431 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
435 return make_number (window_box_text_cols (decode_any_window (window
)));
438 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
439 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
443 return decode_window (window
)->hscroll
;
446 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
447 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
448 Return NCOL. NCOL should be zero or positive.
450 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
451 window so that the location of point becomes invisible. */)
453 Lisp_Object window
, ncol
;
455 struct window
*w
= decode_window (window
);
459 hscroll
= max (0, XINT (ncol
));
461 /* Prevent redisplay shortcuts when changing the hscroll. */
462 if (XINT (w
->hscroll
) != hscroll
)
463 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
465 w
->hscroll
= make_number (hscroll
);
469 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
470 Swindow_redisplay_end_trigger
, 0, 1, 0,
471 doc
: /* Return WINDOW's redisplay end trigger value.
472 See `set-window-redisplay-end-trigger' for more information. */)
476 return decode_window (window
)->redisplay_end_trigger
;
479 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
480 Sset_window_redisplay_end_trigger
, 2, 2, 0,
481 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
482 VALUE should be a buffer position (typically a marker) or nil.
483 If it is a buffer position, then if redisplay in WINDOW reaches a position
484 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
485 with two arguments: WINDOW, and the end trigger value.
486 Afterwards the end-trigger value is reset to nil. */)
488 register Lisp_Object window
, value
;
490 register struct window
*w
;
492 w
= decode_window (window
);
493 w
->redisplay_end_trigger
= value
;
497 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
498 doc
: /* Return a list of the edge coordinates of WINDOW.
499 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
500 RIGHT is one more than the rightmost column occupied by WINDOW,
501 and BOTTOM is one more than the bottommost row occupied by WINDOW.
502 The edges include the space used by the window's scroll bar,
503 display margins, fringes, header line, and mode line, if it has them.
504 To get the edges of the actual text area, use `window-inside-edges'. */)
508 register struct window
*w
= decode_any_window (window
);
510 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
511 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
512 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
513 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
517 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
518 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
519 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
520 RIGHT is one more than the rightmost x position occupied by WINDOW,
521 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
522 The pixel edges include the space used by the window's scroll bar,
523 display margins, fringes, header line, and mode line, if it has them.
524 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
528 register struct window
*w
= decode_any_window (window
);
530 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
531 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
532 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
533 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
537 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
538 doc
: /* Return a list of the edge coordinates of WINDOW.
539 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
540 RIGHT is one more than the rightmost column used by text in WINDOW,
541 and BOTTOM is one more than the bottommost row used by text in WINDOW.
542 The inside edges do not include the space used by the window's scroll bar,
543 display margins, fringes, header line, and/or mode line. */)
547 register struct window
*w
= decode_any_window (window
);
549 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
550 + WINDOW_LEFT_MARGIN_COLS (w
)
551 + WINDOW_LEFT_FRINGE_COLS (w
)),
552 make_number (WINDOW_TOP_EDGE_LINE (w
)
553 + WINDOW_HEADER_LINE_LINES (w
)),
554 make_number (WINDOW_RIGHT_EDGE_COL (w
)
555 - WINDOW_RIGHT_MARGIN_COLS (w
)
556 - WINDOW_RIGHT_FRINGE_COLS (w
)),
557 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
558 - WINDOW_MODE_LINE_LINES (w
)));
561 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
562 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
563 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
564 RIGHT is one more than the rightmost x position used by text in WINDOW,
565 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
566 The inside edges do not include the space used by the window's scroll bar,
567 display margins, fringes, header line, and/or mode line. */)
571 register struct window
*w
= decode_any_window (window
);
573 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
574 + WINDOW_LEFT_MARGIN_WIDTH (w
)
575 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
576 make_number (WINDOW_TOP_EDGE_Y (w
)
577 + WINDOW_HEADER_LINE_HEIGHT (w
)),
578 make_number (WINDOW_RIGHT_EDGE_X (w
)
579 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
580 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
581 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
582 - WINDOW_MODE_LINE_HEIGHT (w
)));
585 /* Test if the character at column *X, row *Y is within window W.
586 If it is not, return ON_NOTHING;
587 if it is in the window's text area,
588 set *x and *y to its location relative to the upper left corner
591 if it is on the window's modeline, return ON_MODE_LINE;
592 if it is on the border between the window and its right sibling,
593 return ON_VERTICAL_BORDER.
594 if it is on a scroll bar,
595 return ON_SCROLL_BAR.
596 if it is on the window's top line, return ON_HEADER_LINE;
597 if it is in left or right fringe of the window,
598 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
599 to window-relative coordinates;
600 if it is in the marginal area to the left/right of the window,
601 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
602 to window-relative coordinates.
604 X and Y are frame relative pixel coordinates. */
606 static enum window_part
607 coordinates_in_window (w
, x
, y
)
608 register struct window
*w
;
611 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
612 int left_x
, right_x
, top_y
, bottom_y
;
613 enum window_part part
;
614 int ux
= FRAME_COLUMN_WIDTH (f
);
615 int x0
= WINDOW_LEFT_EDGE_X (w
);
616 int x1
= WINDOW_RIGHT_EDGE_X (w
);
617 /* The width of the area where the vertical line can be dragged.
618 (Between mode lines for instance. */
619 int grabbable_width
= ux
;
620 int lmargin_width
, rmargin_width
, text_left
, text_right
;
622 /* In what's below, we subtract 1 when computing right_x because we
623 want the rightmost pixel, which is given by left_pixel+width-1. */
624 if (w
->pseudo_window_p
)
627 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
628 top_y
= WINDOW_TOP_EDGE_Y (w
);
629 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
633 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
634 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
635 top_y
= WINDOW_TOP_EDGE_Y (w
);
636 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
639 /* Outside any interesting row? */
640 if (*y
< top_y
|| *y
>= bottom_y
)
643 /* On the mode line or header line? If it's near the start of
644 the mode or header line of window that's has a horizontal
645 sibling, say it's on the vertical line. That's to be able
646 to resize windows horizontally in case we're using toolkit
649 if (WINDOW_WANTS_MODELINE_P (w
)
650 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
654 header_vertical_border_check
:
655 /* We're somewhere on the mode line. We consider the place
656 between mode lines of horizontally adjacent mode lines
657 as the vertical border. If scroll bars on the left,
658 return the right window. */
659 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
660 || WINDOW_RIGHTMOST_P (w
))
662 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
663 return ON_VERTICAL_BORDER
;
667 if (abs (*x
- x1
) < grabbable_width
)
668 return ON_VERTICAL_BORDER
;
671 if (*x
< x0
|| *x
>= x1
)
674 /* Convert X and Y to window relative coordinates.
675 Mode line starts at left edge of window. */
681 if (WINDOW_WANTS_HEADER_LINE_P (w
)
682 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
684 part
= ON_HEADER_LINE
;
685 goto header_vertical_border_check
;
688 if (*x
< x0
|| *x
>= x1
)
691 /* Outside any interesting column? */
692 if (*x
< left_x
|| *x
> right_x
)
693 return ON_SCROLL_BAR
;
695 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
696 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
698 text_left
= window_box_left (w
, TEXT_AREA
);
699 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
701 if (FRAME_WINDOW_P (f
))
703 if (!w
->pseudo_window_p
704 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
705 && !WINDOW_RIGHTMOST_P (w
)
706 && (abs (*x
- right_x
) < grabbable_width
))
707 return ON_VERTICAL_BORDER
;
711 /* Need to say "*x > right_x" rather than >=, since on character
712 terminals, the vertical line's x coordinate is right_x. */
713 if (!w
->pseudo_window_p
714 && !WINDOW_RIGHTMOST_P (w
)
715 && *x
> right_x
- ux
)
717 /* On the border on the right side of the window? Assume that
718 this area begins at RIGHT_X minus a canonical char width. */
719 return ON_VERTICAL_BORDER
;
725 if (lmargin_width
> 0
726 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
727 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
728 : (*x
< left_x
+ lmargin_width
)))
731 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
732 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
734 return ON_LEFT_MARGIN
;
737 /* Convert X and Y to window-relative pixel coordinates. */
740 return ON_LEFT_FRINGE
;
743 if (*x
>= text_right
)
745 if (rmargin_width
> 0
746 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
747 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
748 : (*x
>= right_x
- rmargin_width
)))
751 if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
752 *x
-= WINDOW_RIGHT_FRINGE_WIDTH (w
);
754 return ON_RIGHT_MARGIN
;
757 /* Convert X and Y to window-relative pixel coordinates. */
758 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
760 return ON_RIGHT_FRINGE
;
763 /* Everything special ruled out - must be on text area */
764 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
770 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
771 Scoordinates_in_window_p
, 2, 2, 0,
772 doc
: /* Return non-nil if COORDINATES are in WINDOW.
773 COORDINATES is a cons of the form (X . Y), X and Y being distances
774 measured in characters from the upper-left corner of the frame.
775 \(0 . 0) denotes the character in the upper left corner of the
777 If COORDINATES are in the text portion of WINDOW,
778 the coordinates relative to the window are returned.
779 If they are in the mode line of WINDOW, `mode-line' is returned.
780 If they are in the top mode line of WINDOW, `header-line' is returned.
781 If they are in the left fringe of WINDOW, `left-fringe' is returned.
782 If they are in the right fringe of WINDOW, `right-fringe' is returned.
783 If they are on the border between WINDOW and its right sibling,
784 `vertical-line' is returned.
785 If they are in the windows's left or right marginal areas, `left-margin'\n\
786 or `right-margin' is returned. */)
787 (coordinates
, window
)
788 register Lisp_Object coordinates
, window
;
795 CHECK_WINDOW (window
);
796 w
= XWINDOW (window
);
797 f
= XFRAME (w
->frame
);
798 CHECK_CONS (coordinates
);
799 lx
= Fcar (coordinates
);
800 ly
= Fcdr (coordinates
);
801 CHECK_NUMBER_OR_FLOAT (lx
);
802 CHECK_NUMBER_OR_FLOAT (ly
);
803 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
804 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
806 switch (coordinates_in_window (w
, &x
, &y
))
812 /* X and Y are now window relative pixel coordinates. Convert
813 them to canonical char units before returning them. */
814 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
815 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
820 case ON_VERTICAL_BORDER
:
821 return Qvertical_line
;
829 case ON_RIGHT_FRINGE
:
830 return Qright_fringe
;
835 case ON_RIGHT_MARGIN
:
836 return Qright_margin
;
839 /* Historically we are supposed to return nil in this case. */
848 /* Callback for foreach_window, used in window_from_coordinates.
849 Check if window W contains coordinates specified by USER_DATA which
850 is actually a pointer to a struct check_window_data CW.
852 Check if window W contains coordinates *CW->x and *CW->y. If it
853 does, return W in *CW->window, as Lisp_Object, and return in
854 *CW->part the part of the window under coordinates *X,*Y. Return
855 zero from this function to stop iterating over windows. */
857 struct check_window_data
861 enum window_part
*part
;
865 check_window_containing (w
, user_data
)
869 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
870 enum window_part found
;
873 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
874 if (found
!= ON_NOTHING
)
877 XSETWINDOW (*cw
->window
, w
);
885 /* Find the window containing frame-relative pixel position X/Y and
886 return it as a Lisp_Object.
888 If X, Y is on one of the window's special `window_part' elements,
889 set *PART to the id of that element, and return X and Y converted
890 to window relative coordinates in WX and WY.
892 If there is no window under X, Y return nil and leave *PART
893 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
895 This function was previously implemented with a loop cycling over
896 windows with Fnext_window, and starting with the frame's selected
897 window. It turned out that this doesn't work with an
898 implementation of next_window using Vwindow_list, because
899 FRAME_SELECTED_WINDOW (F) is not always contained in the window
900 tree of F when this function is called asynchronously from
901 note_mouse_highlight. The original loop didn't terminate in this
905 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
908 enum window_part
*part
;
913 struct check_window_data cw
;
914 enum window_part dummy
;
920 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
921 foreach_window (f
, check_window_containing
, &cw
);
923 /* If not found above, see if it's in the tool bar window, if a tool
927 && WINDOWP (f
->tool_bar_window
)
928 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
929 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
933 window
= f
->tool_bar_window
;
942 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
943 doc
: /* Return window containing coordinates X and Y on FRAME.
944 If omitted, FRAME defaults to the currently selected frame.
945 The top left corner of the frame is considered to be row 0,
948 Lisp_Object x
, y
, frame
;
953 frame
= selected_frame
;
954 CHECK_LIVE_FRAME (frame
);
957 /* Check that arguments are integers or floats. */
958 CHECK_NUMBER_OR_FLOAT (x
);
959 CHECK_NUMBER_OR_FLOAT (y
);
961 return window_from_coordinates (f
,
962 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
963 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
964 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
965 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
969 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
970 doc
: /* Return current value of point in WINDOW.
971 For a nonselected window, this is the value point would have
972 if that window were selected.
974 Note that, when WINDOW is the selected window and its buffer
975 is also currently selected, the value returned is the same as (point).
976 It would be more strictly correct to return the `top-level' value
977 of point, outside of any save-excursion forms.
978 But that is hard to define. */)
982 register struct window
*w
= decode_window (window
);
984 if (w
== XWINDOW (selected_window
)
985 && current_buffer
== XBUFFER (w
->buffer
))
987 return Fmarker_position (w
->pointm
);
990 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
991 doc
: /* Return position at which display currently starts in WINDOW.
992 This is updated by redisplay or by calling `set-window-start'. */)
996 return Fmarker_position (decode_window (window
)->start
);
999 /* This is text temporarily removed from the doc string below.
1001 This function returns nil if the position is not currently known.
1002 That happens when redisplay is preempted and doesn't finish.
1003 If in that case you want to compute where the end of the window would
1004 have been if redisplay had finished, do this:
1006 (goto-char (window-start window))
1007 (vertical-motion (1- (window-height window)) window)
1010 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1011 doc
: /* Return position at which display currently ends in WINDOW.
1012 This is updated by redisplay, when it runs to completion.
1013 Simply changing the buffer text or setting `window-start'
1014 does not update this value.
1015 Return nil if there is no recorded value. \(This can happen if the
1016 last redisplay of WINDOW was preempted, and did not finish.)
1017 If UPDATE is non-nil, compute the up-to-date position
1018 if it isn't already recorded. */)
1020 Lisp_Object window
, update
;
1023 struct window
*w
= decode_window (window
);
1029 #if 0 /* This change broke some things. We should make it later. */
1030 /* If we don't know the end position, return nil.
1031 The user can compute it with vertical-motion if he wants to.
1032 It would be nicer to do it automatically,
1033 but that's so slow that it would probably bother people. */
1034 if (NILP (w
->window_end_valid
))
1039 && ! (! NILP (w
->window_end_valid
)
1040 && XFASTINT (w
->last_modified
) >= MODIFF
))
1042 struct text_pos startp
;
1044 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1046 /* In case W->start is out of the range, use something
1047 reasonable. This situation occurred when loading a file with
1048 `-l' containing a call to `rmail' with subsequent other
1049 commands. At the end, W->start happened to be BEG, while
1050 rmail had already narrowed the buffer. */
1051 if (XMARKER (w
->start
)->charpos
< BEGV
)
1052 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1053 else if (XMARKER (w
->start
)->charpos
> ZV
)
1054 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1056 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1058 /* Cannot use Fvertical_motion because that function doesn't
1059 cope with variable-height lines. */
1060 if (b
!= current_buffer
)
1062 old_buffer
= current_buffer
;
1063 set_buffer_internal (b
);
1066 start_display (&it
, w
, startp
);
1067 move_it_vertically (&it
, window_box_height (w
));
1068 if (it
.current_y
< it
.last_visible_y
)
1069 move_it_past_eol (&it
);
1070 value
= make_number (IT_CHARPOS (it
));
1073 set_buffer_internal (old_buffer
);
1076 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1081 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1082 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1085 Lisp_Object window
, pos
;
1087 register struct window
*w
= decode_window (window
);
1089 CHECK_NUMBER_COERCE_MARKER (pos
);
1090 if (w
== XWINDOW (selected_window
)
1091 && XBUFFER (w
->buffer
) == current_buffer
)
1094 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1096 /* We have to make sure that redisplay updates the window to show
1097 the new value of point. */
1098 if (!EQ (window
, selected_window
))
1099 ++windows_or_buffers_changed
;
1104 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1105 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1107 Optional third arg NOFORCE non-nil inhibits next redisplay
1108 from overriding motion of point in order to display at this exact start. */)
1109 (window
, pos
, noforce
)
1110 Lisp_Object window
, pos
, noforce
;
1112 register struct window
*w
= decode_window (window
);
1114 CHECK_NUMBER_COERCE_MARKER (pos
);
1115 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1116 /* this is not right, but much easier than doing what is right. */
1117 w
->start_at_line_beg
= Qnil
;
1119 w
->force_start
= Qt
;
1120 w
->update_mode_line
= Qt
;
1121 XSETFASTINT (w
->last_modified
, 0);
1122 XSETFASTINT (w
->last_overlay_modified
, 0);
1123 if (!EQ (window
, selected_window
))
1124 windows_or_buffers_changed
++;
1129 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1131 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1132 See also `set-window-dedicated-p'. */)
1136 return decode_window (window
)->dedicated
;
1139 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1140 Sset_window_dedicated_p
, 2, 2, 0,
1141 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1142 If it is dedicated, Emacs will not automatically change
1143 which buffer appears in it.
1144 The second argument is the new value for the dedication flag;
1145 non-nil means yes. */)
1147 Lisp_Object window
, arg
;
1149 register struct window
*w
= decode_window (window
);
1153 return w
->dedicated
;
1156 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1158 doc
: /* Return the display-table that WINDOW is using. */)
1162 return decode_window (window
)->display_table
;
1165 /* Get the display table for use on window W. This is either W's
1166 display table or W's buffer's display table. Ignore the specified
1167 tables if they are not valid; if no valid table is specified,
1170 struct Lisp_Char_Table
*
1171 window_display_table (w
)
1174 struct Lisp_Char_Table
*dp
= NULL
;
1176 if (DISP_TABLE_P (w
->display_table
))
1177 dp
= XCHAR_TABLE (w
->display_table
);
1178 else if (BUFFERP (w
->buffer
))
1180 struct buffer
*b
= XBUFFER (w
->buffer
);
1182 if (DISP_TABLE_P (b
->display_table
))
1183 dp
= XCHAR_TABLE (b
->display_table
);
1184 else if (DISP_TABLE_P (Vstandard_display_table
))
1185 dp
= XCHAR_TABLE (Vstandard_display_table
);
1191 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1192 doc
: /* Set WINDOW's display-table to TABLE. */)
1194 register Lisp_Object window
, table
;
1196 register struct window
*w
;
1198 w
= decode_window (window
);
1199 w
->display_table
= table
;
1203 /* Record info on buffer window w is displaying
1204 when it is about to cease to display that buffer. */
1207 register struct window
*w
;
1214 if (b
!= XMARKER (w
->pointm
)->buffer
)
1218 if (w
== XWINDOW (selected_window
)
1219 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1220 /* Do this except when the selected window's buffer
1221 is being removed from some other window. */
1223 /* last_window_start records the start position that this buffer
1224 had in the last window to be disconnected from it.
1225 Now that this statement is unconditional,
1226 it is possible for the buffer to be displayed in the
1227 selected window, while last_window_start reflects another
1228 window which was recently showing the same buffer.
1229 Some people might say that might be a good thing. Let's see. */
1230 b
->last_window_start
= marker_position (w
->start
);
1232 /* Point in the selected window's buffer
1233 is actually stored in that buffer, and the window's pointm isn't used.
1234 So don't clobber point in that buffer. */
1235 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1236 /* This line helps to fix Horsley's testbug.el bug. */
1237 && !(WINDOWP (b
->last_selected_window
)
1238 && w
!= XWINDOW (b
->last_selected_window
)
1239 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1240 temp_set_point_both (b
,
1241 clip_to_bounds (BUF_BEGV (b
),
1242 XMARKER (w
->pointm
)->charpos
,
1244 clip_to_bounds (BUF_BEGV_BYTE (b
),
1245 marker_byte_position (w
->pointm
),
1248 if (WINDOWP (b
->last_selected_window
)
1249 && w
== XWINDOW (b
->last_selected_window
))
1250 b
->last_selected_window
= Qnil
;
1253 /* Put replacement into the window structure in place of old. */
1255 replace_window (old
, replacement
)
1256 Lisp_Object old
, replacement
;
1258 register Lisp_Object tem
;
1259 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1261 /* If OLD is its frame's root_window, then replacement is the new
1262 root_window for that frame. */
1264 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1265 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1267 p
->left_col
= o
->left_col
;
1268 p
->top_line
= o
->top_line
;
1269 p
->total_cols
= o
->total_cols
;
1270 p
->total_lines
= o
->total_lines
;
1271 p
->desired_matrix
= p
->current_matrix
= 0;
1273 bzero (&p
->cursor
, sizeof (p
->cursor
));
1274 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1275 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1276 p
->phys_cursor_type
= -1;
1277 p
->phys_cursor_width
= -1;
1278 p
->must_be_updated_p
= 0;
1279 p
->pseudo_window_p
= 0;
1280 XSETFASTINT (p
->window_end_vpos
, 0);
1281 XSETFASTINT (p
->window_end_pos
, 0);
1282 p
->window_end_valid
= Qnil
;
1283 p
->frozen_window_start_p
= 0;
1284 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1286 p
->next
= tem
= o
->next
;
1288 XWINDOW (tem
)->prev
= replacement
;
1290 p
->prev
= tem
= o
->prev
;
1292 XWINDOW (tem
)->next
= replacement
;
1294 p
->parent
= tem
= o
->parent
;
1297 if (EQ (XWINDOW (tem
)->vchild
, old
))
1298 XWINDOW (tem
)->vchild
= replacement
;
1299 if (EQ (XWINDOW (tem
)->hchild
, old
))
1300 XWINDOW (tem
)->hchild
= replacement
;
1303 /*** Here, if replacement is a vertical combination
1304 and so is its new parent, we should make replacement's
1305 children be children of that parent instead. ***/
1308 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1309 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1311 register Lisp_Object window
;
1313 delete_window (window
);
1315 if (! NILP (Vwindow_configuration_change_hook
)
1316 && ! NILP (Vrun_hooks
))
1317 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1323 delete_window (window
)
1324 register Lisp_Object window
;
1326 register Lisp_Object tem
, parent
, sib
;
1327 register struct window
*p
;
1328 register struct window
*par
;
1331 /* Because this function is called by other C code on non-leaf
1332 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1333 so we can't decode_window here. */
1335 window
= selected_window
;
1337 CHECK_WINDOW (window
);
1338 p
= XWINDOW (window
);
1340 /* It's okay to delete an already-deleted window. */
1341 if (NILP (p
->buffer
)
1343 && NILP (p
->vchild
))
1348 error ("Attempt to delete minibuffer or sole ordinary window");
1349 par
= XWINDOW (parent
);
1351 windows_or_buffers_changed
++;
1352 Vwindow_list
= Qnil
;
1353 f
= XFRAME (WINDOW_FRAME (p
));
1354 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1356 /* Are we trying to delete any frame's selected window? */
1358 Lisp_Object swindow
, pwindow
;
1360 /* See if the frame's selected window is either WINDOW
1361 or any subwindow of it, by finding all that window's parents
1362 and comparing each one with WINDOW. */
1363 swindow
= FRAME_SELECTED_WINDOW (f
);
1368 while (!NILP (pwindow
))
1370 if (EQ (window
, pwindow
))
1372 pwindow
= XWINDOW (pwindow
)->parent
;
1375 /* If the window being deleted is not a parent of SWINDOW,
1376 then SWINDOW is ok as the new selected window. */
1377 if (!EQ (window
, pwindow
))
1379 /* Otherwise, try another window for SWINDOW. */
1380 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1382 /* If we get back to the frame's selected window,
1383 it means there was no acceptable alternative,
1384 so we cannot delete. */
1385 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1386 error ("Cannot delete window");
1389 /* If we need to change SWINDOW, do it. */
1390 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1392 /* If we're about to delete the selected window on the
1393 selected frame, then we should use Fselect_window to select
1394 the new window. On the other hand, if we're about to
1395 delete the selected window on any other frame, we shouldn't do
1396 anything but set the frame's selected_window slot. */
1397 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1398 Fselect_window (swindow
, Qnil
);
1400 FRAME_SELECTED_WINDOW (f
) = swindow
;
1405 /* tem is null for dummy parent windows
1406 (which have inferiors but not any contents themselves) */
1410 unchain_marker (XMARKER (p
->pointm
));
1411 unchain_marker (XMARKER (p
->start
));
1414 /* Free window glyph matrices. It is sure that they are allocated
1415 again when ADJUST_GLYPHS is called. Block input so that expose
1416 events and other events that access glyph matrices are not
1417 processed while we are changing them. */
1419 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1423 XWINDOW (tem
)->prev
= p
->prev
;
1427 XWINDOW (tem
)->next
= p
->next
;
1429 if (EQ (window
, par
->hchild
))
1430 par
->hchild
= p
->next
;
1431 if (EQ (window
, par
->vchild
))
1432 par
->vchild
= p
->next
;
1434 /* Find one of our siblings to give our space to. */
1438 /* If p gives its space to its next sibling, that sibling needs
1439 to have its top/left side pulled back to where p's is.
1440 set_window_{height,width} will re-position the sibling's
1443 XWINDOW (sib
)->top_line
= p
->top_line
;
1444 XWINDOW (sib
)->left_col
= p
->left_col
;
1447 /* Stretch that sibling. */
1448 if (!NILP (par
->vchild
))
1449 set_window_height (sib
,
1450 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1452 if (!NILP (par
->hchild
))
1453 set_window_width (sib
,
1454 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1457 /* If parent now has only one child,
1458 put the child into the parent's place. */
1462 if (NILP (XWINDOW (tem
)->next
))
1463 replace_window (parent
, tem
);
1465 /* Since we may be deleting combination windows, we must make sure that
1466 not only p but all its children have been marked as deleted. */
1467 if (! NILP (p
->hchild
))
1468 delete_all_subwindows (XWINDOW (p
->hchild
));
1469 else if (! NILP (p
->vchild
))
1470 delete_all_subwindows (XWINDOW (p
->vchild
));
1472 /* Mark this window as deleted. */
1473 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1475 /* Adjust glyph matrices. */
1482 /***********************************************************************
1484 ***********************************************************************/
1486 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1487 pointer. This is a callback function for foreach_window, used in
1488 function window_list. */
1491 add_window_to_list (w
, user_data
)
1495 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1497 XSETWINDOW (window
, w
);
1498 *list
= Fcons (window
, *list
);
1503 /* Return a list of all windows, for use by next_window. If
1504 Vwindow_list is a list, return that list. Otherwise, build a new
1505 list, cache it in Vwindow_list, and return that. */
1510 if (!CONSP (Vwindow_list
))
1514 Vwindow_list
= Qnil
;
1515 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1517 Lisp_Object args
[2];
1519 /* We are visiting windows in canonical order, and add
1520 new windows at the front of args[1], which means we
1521 have to reverse this list at the end. */
1523 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1524 args
[0] = Vwindow_list
;
1525 args
[1] = Fnreverse (args
[1]);
1526 Vwindow_list
= Fnconc (2, args
);
1530 return Vwindow_list
;
1534 /* Value is non-zero if WINDOW satisfies the constraints given by
1535 OWINDOW, MINIBUF and ALL_FRAMES.
1537 MINIBUF t means WINDOW may be minibuffer windows.
1538 `lambda' means WINDOW may not be a minibuffer window.
1539 a window means a specific minibuffer window
1541 ALL_FRAMES t means search all frames,
1542 nil means search just current frame,
1543 `visible' means search just visible frames,
1544 0 means search visible and iconified frames,
1545 a window means search the frame that window belongs to,
1546 a frame means consider windows on that frame, only. */
1549 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1550 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1552 struct window
*w
= XWINDOW (window
);
1553 struct frame
*f
= XFRAME (w
->frame
);
1554 int candidate_p
= 1;
1556 if (!BUFFERP (w
->buffer
))
1558 else if (MINI_WINDOW_P (w
)
1559 && (EQ (minibuf
, Qlambda
)
1560 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1562 /* If MINIBUF is `lambda' don't consider any mini-windows.
1563 If it is a window, consider only that one. */
1566 else if (EQ (all_frames
, Qt
))
1568 else if (NILP (all_frames
))
1570 xassert (WINDOWP (owindow
));
1571 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1573 else if (EQ (all_frames
, Qvisible
))
1575 FRAME_SAMPLE_VISIBILITY (f
);
1576 candidate_p
= FRAME_VISIBLE_P (f
);
1578 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1580 FRAME_SAMPLE_VISIBILITY (f
);
1581 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1583 else if (WINDOWP (all_frames
))
1584 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1585 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1586 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1587 else if (FRAMEP (all_frames
))
1588 candidate_p
= EQ (all_frames
, w
->frame
);
1594 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1595 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1599 decode_next_window_args (window
, minibuf
, all_frames
)
1600 Lisp_Object
*window
, *minibuf
, *all_frames
;
1603 *window
= selected_window
;
1605 CHECK_LIVE_WINDOW (*window
);
1607 /* MINIBUF nil may or may not include minibuffers. Decide if it
1609 if (NILP (*minibuf
))
1610 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1611 else if (!EQ (*minibuf
, Qt
))
1614 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1615 => count none of them, or a specific minibuffer window (the
1616 active one) to count. */
1618 /* ALL_FRAMES nil doesn't specify which frames to include. */
1619 if (NILP (*all_frames
))
1620 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1621 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1623 else if (EQ (*all_frames
, Qvisible
))
1625 else if (EQ (*all_frames
, make_number (0)))
1627 else if (FRAMEP (*all_frames
))
1629 else if (!EQ (*all_frames
, Qt
))
1632 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1633 search just current frame, `visible' meaning search just visible
1634 frames, 0 meaning search visible and iconified frames, or a
1635 window, meaning search the frame that window belongs to, or a
1636 frame, meaning consider windows on that frame, only. */
1640 /* Return the next or previous window of WINDOW in canonical ordering
1641 of windows. NEXT_P non-zero means return the next window. See the
1642 documentation string of next-window for the meaning of MINIBUF and
1646 next_window (window
, minibuf
, all_frames
, next_p
)
1647 Lisp_Object window
, minibuf
, all_frames
;
1650 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1652 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1653 return the first window on the frame. */
1654 if (FRAMEP (all_frames
)
1655 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1656 return Fframe_first_window (all_frames
);
1662 /* Find WINDOW in the list of all windows. */
1663 list
= Fmemq (window
, window_list ());
1665 /* Scan forward from WINDOW to the end of the window list. */
1667 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1668 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1671 /* Scan from the start of the window list up to WINDOW. */
1673 for (list
= Vwindow_list
;
1674 CONSP (list
) && !EQ (XCAR (list
), window
);
1676 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1680 window
= XCAR (list
);
1684 Lisp_Object candidate
, list
;
1686 /* Scan through the list of windows for candidates. If there are
1687 candidate windows in front of WINDOW, the last one of these
1688 is the one we want. If there are candidates following WINDOW
1689 in the list, again the last one of these is the one we want. */
1691 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1693 if (EQ (XCAR (list
), window
))
1695 if (WINDOWP (candidate
))
1698 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1700 candidate
= XCAR (list
);
1703 if (WINDOWP (candidate
))
1711 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1712 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1713 If omitted, WINDOW defaults to the selected window.
1715 Optional second arg MINIBUF t means count the minibuffer window even
1716 if not active. MINIBUF nil or omitted means count the minibuffer iff
1717 it is active. MINIBUF neither t nor nil means not to count the
1718 minibuffer even if it is active.
1720 Several frames may share a single minibuffer; if the minibuffer
1721 counts, all windows on all frames that share that minibuffer count
1722 too. Therefore, `next-window' can be used to iterate through the
1723 set of windows even when the minibuffer is on another frame. If the
1724 minibuffer does not count, only windows from WINDOW's frame count.
1726 Optional third arg ALL-FRAMES t means include windows on all frames.
1727 ALL-FRAMES nil or omitted means cycle within the frames as specified
1728 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1729 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1730 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1731 Anything else means restrict to WINDOW's frame.
1733 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1734 `next-window' to iterate through the entire cycle of acceptable
1735 windows, eventually ending up back at the window you started with.
1736 `previous-window' traverses the same cycle, in the reverse order. */)
1737 (window
, minibuf
, all_frames
)
1738 Lisp_Object window
, minibuf
, all_frames
;
1740 return next_window (window
, minibuf
, all_frames
, 1);
1744 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1745 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1746 If omitted, WINDOW defaults to the selected window.
1748 Optional second arg MINIBUF t means count the minibuffer window even
1749 if not active. MINIBUF nil or omitted means count the minibuffer iff
1750 it is active. MINIBUF neither t nor nil means not to count the
1751 minibuffer even if it is active.
1753 Several frames may share a single minibuffer; if the minibuffer
1754 counts, all windows on all frames that share that minibuffer count
1755 too. Therefore, `previous-window' can be used to iterate through
1756 the set of windows even when the minibuffer is on another frame. If
1757 the minibuffer does not count, only windows from WINDOW's frame count
1759 Optional third arg ALL-FRAMES t means include windows on all frames.
1760 ALL-FRAMES nil or omitted means cycle within the frames as specified
1761 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1762 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1763 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1764 Anything else means restrict to WINDOW's frame.
1766 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1767 `previous-window' to iterate through the entire cycle of acceptable
1768 windows, eventually ending up back at the window you started with.
1769 `next-window' traverses the same cycle, in the reverse order. */)
1770 (window
, minibuf
, all_frames
)
1771 Lisp_Object window
, minibuf
, all_frames
;
1773 return next_window (window
, minibuf
, all_frames
, 0);
1777 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1778 doc
: /* Select the ARG'th different window on this frame.
1779 All windows on current frame are arranged in a cyclic order.
1780 This command selects the window ARG steps away in that order.
1781 A negative ARG moves in the opposite order. The optional second
1782 argument ALL_FRAMES has the same meaning as in `next-window', which see. */)
1784 Lisp_Object arg
, all_frames
;
1790 window
= selected_window
;
1792 for (i
= XINT (arg
); i
> 0; --i
)
1793 window
= Fnext_window (window
, Qnil
, all_frames
);
1795 window
= Fprevious_window (window
, Qnil
, all_frames
);
1797 Fselect_window (window
, Qnil
);
1802 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1803 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1804 FRAME nil or omitted means use the selected frame.
1805 WINDOW nil or omitted means use the selected window.
1806 MINIBUF t means include the minibuffer window, even if it isn't active.
1807 MINIBUF nil or omitted means include the minibuffer window only
1809 MINIBUF neither nil nor t means never include the minibuffer window. */)
1810 (frame
, minibuf
, window
)
1811 Lisp_Object frame
, minibuf
, window
;
1814 window
= selected_window
;
1816 frame
= selected_frame
;
1818 if (!EQ (frame
, XWINDOW (window
)->frame
))
1819 error ("Window is on a different frame");
1821 return window_list_1 (window
, minibuf
, frame
);
1825 /* Return a list of windows in canonical ordering. Arguments are like
1826 for `next-window'. */
1829 window_list_1 (window
, minibuf
, all_frames
)
1830 Lisp_Object window
, minibuf
, all_frames
;
1832 Lisp_Object tail
, list
, rest
;
1834 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1837 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1838 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1839 list
= Fcons (XCAR (tail
), list
);
1841 /* Rotate the list to start with WINDOW. */
1842 list
= Fnreverse (list
);
1843 rest
= Fmemq (window
, list
);
1844 if (!NILP (rest
) && !EQ (rest
, list
))
1846 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1848 XSETCDR (tail
, Qnil
);
1849 list
= nconc2 (rest
, list
);
1856 /* Look at all windows, performing an operation specified by TYPE
1858 If FRAMES is Qt, look at all frames;
1859 Qnil, look at just the selected frame;
1860 Qvisible, look at visible frames;
1861 a frame, just look at windows on that frame.
1862 If MINI is non-zero, perform the operation on minibuffer windows too. */
1867 GET_BUFFER_WINDOW
, /* Arg is buffer */
1868 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1869 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1870 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1872 UNSHOW_BUFFER
, /* Arg is buffer */
1873 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1878 window_loop (type
, obj
, mini
, frames
)
1879 enum window_loop type
;
1880 Lisp_Object obj
, frames
;
1883 Lisp_Object window
, windows
, best_window
, frame_arg
;
1885 struct gcpro gcpro1
;
1887 /* If we're only looping through windows on a particular frame,
1888 frame points to that frame. If we're looping through windows
1889 on all frames, frame is 0. */
1890 if (FRAMEP (frames
))
1891 f
= XFRAME (frames
);
1892 else if (NILP (frames
))
1893 f
= SELECTED_FRAME ();
1898 frame_arg
= Qlambda
;
1899 else if (EQ (frames
, make_number (0)))
1901 else if (EQ (frames
, Qvisible
))
1906 /* frame_arg is Qlambda to stick to one frame,
1907 Qvisible to consider all visible frames,
1910 /* Pick a window to start with. */
1914 window
= FRAME_SELECTED_WINDOW (f
);
1916 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1918 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1922 for (; CONSP (windows
); windows
= CDR (windows
))
1926 window
= XCAR (windows
);
1927 w
= XWINDOW (window
);
1929 /* Note that we do not pay attention here to whether the frame
1930 is visible, since Fwindow_list skips non-visible frames if
1931 that is desired, under the control of frame_arg. */
1932 if (!MINI_WINDOW_P (w
)
1933 /* For UNSHOW_BUFFER, we must always consider all windows. */
1934 || type
== UNSHOW_BUFFER
1935 || (mini
&& minibuf_level
> 0))
1938 case GET_BUFFER_WINDOW
:
1939 if (EQ (w
->buffer
, obj
)
1940 /* Don't find any minibuffer window
1941 except the one that is currently in use. */
1942 && (MINI_WINDOW_P (w
)
1943 ? EQ (window
, minibuf_window
)
1946 if (NILP (best_window
))
1947 best_window
= window
;
1948 else if (EQ (window
, selected_window
))
1949 /* For compatibility with 20.x, prefer to return
1951 best_window
= window
;
1955 case GET_LRU_WINDOW
:
1956 /* t as arg means consider only full-width windows */
1957 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1959 /* Ignore dedicated windows and minibuffers. */
1960 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
1962 if (NILP (best_window
)
1963 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1964 > XFASTINT (w
->use_time
)))
1965 best_window
= window
;
1968 case DELETE_OTHER_WINDOWS
:
1969 if (!EQ (window
, obj
))
1970 Fdelete_window (window
);
1973 case DELETE_BUFFER_WINDOWS
:
1974 if (EQ (w
->buffer
, obj
))
1976 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1978 /* If this window is dedicated, and in a frame of its own,
1980 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1981 && !NILP (w
->dedicated
)
1982 && other_visible_frames (f
))
1984 /* Skip the other windows on this frame.
1985 There might be one, the minibuffer! */
1986 while (CONSP (XCDR (windows
))
1987 && EQ (XWINDOW (XCAR (windows
))->frame
,
1988 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1989 windows
= XCDR (windows
);
1991 /* Now we can safely delete the frame. */
1992 Fdelete_frame (w
->frame
, Qnil
);
1994 else if (NILP (w
->parent
))
1996 /* If we're deleting the buffer displayed in the
1997 only window on the frame, find a new buffer to
2000 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2001 Fset_window_buffer (window
, buffer
, Qnil
);
2002 if (EQ (window
, selected_window
))
2003 Fset_buffer (w
->buffer
);
2006 Fdelete_window (window
);
2010 case GET_LARGEST_WINDOW
:
2012 /* Ignore dedicated windows and minibuffers. */
2013 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
2016 if (NILP (best_window
))
2017 best_window
= window
;
2020 struct window
*b
= XWINDOW (best_window
);
2021 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2022 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2023 best_window
= window
;
2029 if (EQ (w
->buffer
, obj
))
2032 struct frame
*f
= XFRAME (w
->frame
);
2034 /* Find another buffer to show in this window. */
2035 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2037 /* If this window is dedicated, and in a frame of its own,
2039 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2040 && !NILP (w
->dedicated
)
2041 && other_visible_frames (f
))
2043 /* Skip the other windows on this frame.
2044 There might be one, the minibuffer! */
2045 while (CONSP (XCDR (windows
))
2046 && EQ (XWINDOW (XCAR (windows
))->frame
,
2047 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2048 windows
= XCDR (windows
);
2050 /* Now we can safely delete the frame. */
2051 Fdelete_frame (w
->frame
, Qnil
);
2053 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2056 XSETWINDOW (window
, w
);
2057 /* If this window is dedicated and not the only window
2058 in its frame, then kill it. */
2059 Fdelete_window (window
);
2063 /* Otherwise show a different buffer in the window. */
2064 w
->dedicated
= Qnil
;
2065 Fset_window_buffer (window
, buffer
, Qnil
);
2066 if (EQ (window
, selected_window
))
2067 Fset_buffer (w
->buffer
);
2072 case REDISPLAY_BUFFER_WINDOWS
:
2073 if (EQ (w
->buffer
, obj
))
2075 mark_window_display_accurate (window
, 0);
2076 w
->update_mode_line
= Qt
;
2077 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2078 ++update_mode_lines
;
2079 best_window
= window
;
2083 /* Check for a window that has a killed buffer. */
2084 case CHECK_ALL_WINDOWS
:
2085 if (! NILP (w
->buffer
)
2086 && NILP (XBUFFER (w
->buffer
)->name
))
2090 case WINDOW_LOOP_UNUSED
:
2099 /* Used for debugging. Abort if any window has a dead buffer. */
2102 check_all_windows ()
2104 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2107 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
2108 doc
: /* Return the window least recently selected or used for display.
2109 Return a full-width window if possible.
2110 A minibuffer window is never a candidate.
2111 A dedicated window is never a candidate, so if all windows are dedicated,
2113 If optional argument FRAME is `visible', search all visible frames.
2114 If FRAME is 0, search all visible and iconified frames.
2115 If FRAME is t, search all frames.
2116 If FRAME is nil, search only the selected frame.
2117 If FRAME is a frame, search only that frame. */)
2121 register Lisp_Object w
;
2122 /* First try for a window that is full-width */
2123 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
2124 if (!NILP (w
) && !EQ (w
, selected_window
))
2126 /* If none of them, try the rest */
2127 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
2130 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
2131 doc
: /* Return the largest window in area.
2132 A minibuffer window is never a candidate.
2133 A dedicated window is never a candidate, so if all windows are dedicated,
2135 If optional argument FRAME is `visible', search all visible frames.
2136 If FRAME is 0, search all visible and iconified frames.
2137 If FRAME is t, search all frames.
2138 If FRAME is nil, search only the selected frame.
2139 If FRAME is a frame, search only that frame. */)
2143 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
2147 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2148 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2149 BUFFER can be a buffer or a buffer name.
2150 If optional argument FRAME is `visible', search all visible frames.
2151 If optional argument FRAME is 0, search all visible and iconified frames.
2152 If FRAME is t, search all frames.
2153 If FRAME is nil, search only the selected frame.
2154 If FRAME is a frame, search only that frame. */)
2156 Lisp_Object buffer
, frame
;
2158 buffer
= Fget_buffer (buffer
);
2159 if (BUFFERP (buffer
))
2160 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2165 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2167 doc
: /* Make WINDOW (or the selected window) fill its frame.
2168 Only the frame WINDOW is on is affected.
2169 This function tries to reduce display jumps
2170 by keeping the text previously visible in WINDOW
2171 in the same place on the frame. Doing this depends on
2172 the value of (window-start WINDOW), so if calling this function
2173 in a program gives strange scrolling, make sure the window-start
2174 value is reasonable when this function is called. */)
2183 window
= selected_window
;
2185 CHECK_LIVE_WINDOW (window
);
2186 w
= XWINDOW (window
);
2188 startpos
= marker_position (w
->start
);
2189 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2191 if (MINI_WINDOW_P (w
) && top
> 0)
2192 error ("Can't expand minibuffer to full frame");
2194 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2196 /* Try to minimize scrolling, by setting the window start to the point
2197 will cause the text at the old window start to be at the same place
2198 on the frame. But don't try to do this if the window start is
2199 outside the visible portion (as might happen when the display is
2200 not current, due to typeahead). */
2201 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2203 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2204 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2206 struct position pos
;
2207 struct buffer
*obuf
= current_buffer
;
2209 Fset_buffer (w
->buffer
);
2210 /* This computation used to temporarily move point, but that can
2211 have unwanted side effects due to text properties. */
2212 pos
= *vmotion (startpos
, -top
, w
);
2214 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2215 w
->window_end_valid
= Qnil
;
2216 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2217 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2219 /* We need to do this, so that the window-scroll-functions
2221 w
->optional_new_start
= Qt
;
2223 set_buffer_internal (obuf
);
2229 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2230 1, 2, "bDelete windows on (buffer): ",
2231 doc
: /* Delete all windows showing BUFFER.
2232 BUFFER must be a buffer or the name of an existing buffer.
2233 Optional second argument FRAME controls which frames are affected.
2234 If optional argument FRAME is `visible', search all visible frames.
2235 If FRAME is 0, search all visible and iconified frames.
2236 If FRAME is nil, search all frames.
2237 If FRAME is t, search only the selected frame.
2238 If FRAME is a frame, search only that frame. */)
2240 Lisp_Object buffer
, frame
;
2242 /* FRAME uses t and nil to mean the opposite of what window_loop
2246 else if (EQ (frame
, Qt
))
2251 buffer
= Fget_buffer (buffer
);
2252 CHECK_BUFFER (buffer
);
2253 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2259 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2260 Sreplace_buffer_in_windows
,
2261 1, 1, "bReplace buffer in windows: ",
2262 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2263 BUFFER may be a buffer or the name of an existing buffer. */)
2269 buffer
= Fget_buffer (buffer
);
2270 CHECK_BUFFER (buffer
);
2271 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2276 /* Replace BUFFER with some other buffer in all windows
2277 of all frames, even those on other keyboards. */
2280 replace_buffer_in_all_windows (buffer
)
2284 Lisp_Object tail
, frame
;
2286 /* A single call to window_loop won't do the job
2287 because it only considers frames on the current keyboard.
2288 So loop manually over frames, and handle each one. */
2289 FOR_EACH_FRAME (tail
, frame
)
2290 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2292 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2296 /* Set the height of WINDOW and all its inferiors. */
2298 /* The smallest acceptable dimensions for a window. Anything smaller
2299 might crash Emacs. */
2301 #define MIN_SAFE_WINDOW_WIDTH (2)
2302 #define MIN_SAFE_WINDOW_HEIGHT (1)
2304 /* Make sure that window_min_height and window_min_width are
2305 not too small; if they are, set them to safe minima. */
2308 check_min_window_sizes ()
2310 /* Smaller values might permit a crash. */
2311 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2312 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2313 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2314 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2317 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2318 minimum allowable size. */
2321 check_frame_size (frame
, rows
, cols
)
2325 /* For height, we have to see:
2326 how many windows the frame has at minimum (one or two),
2327 and whether it has a menu bar or other special stuff at the top. */
2329 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2330 ? MIN_SAFE_WINDOW_HEIGHT
2331 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2333 if (FRAME_TOP_MARGIN (frame
) > 0)
2334 min_height
+= FRAME_TOP_MARGIN (frame
);
2336 if (*rows
< min_height
)
2338 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2339 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2343 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2344 check if W's width can be changed, otherwise check W's height.
2345 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2346 siblings, too. If none of the siblings is resizable, WINDOW isn't
2350 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2352 int width_p
, check_siblings_p
;
2357 if (!NILP (w
->hchild
))
2359 c
= XWINDOW (w
->hchild
);
2363 /* A horiz. combination is fixed-width if all of if its
2365 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2366 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2367 fixed_p
= c
== NULL
;
2371 /* A horiz. combination is fixed-height if one of if its
2373 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2374 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2375 fixed_p
= c
!= NULL
;
2378 else if (!NILP (w
->vchild
))
2380 c
= XWINDOW (w
->vchild
);
2384 /* A vert. combination is fixed-width if one of if its
2386 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2387 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2388 fixed_p
= c
!= NULL
;
2392 /* A vert. combination is fixed-height if all of if its
2394 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2395 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2396 fixed_p
= c
== NULL
;
2399 else if (BUFFERP (w
->buffer
))
2401 if (w
->height_fixed_p
&& !width_p
)
2405 struct buffer
*old
= current_buffer
;
2408 current_buffer
= XBUFFER (w
->buffer
);
2409 val
= find_symbol_value (Qwindow_size_fixed
);
2410 current_buffer
= old
;
2413 if (!EQ (val
, Qunbound
))
2415 fixed_p
= !NILP (val
);
2418 && ((EQ (val
, Qheight
) && width_p
)
2419 || (EQ (val
, Qwidth
) && !width_p
)))
2424 /* Can't tell if this one is resizable without looking at
2425 siblings. If all siblings are fixed-size this one is too. */
2426 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2430 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2431 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2435 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2436 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2450 /* Return the minimum size of window W, not taking fixed-width windows
2451 into account. WIDTH_P non-zero means return the minimum width,
2452 otherwise return the minimum height. If W is a combination window,
2453 compute the minimum size from the minimum sizes of W's children. */
2456 window_min_size_1 (w
, width_p
)
2463 if (!NILP (w
->hchild
))
2465 c
= XWINDOW (w
->hchild
);
2470 /* The min width of a horizontal combination is
2471 the sum of the min widths of its children. */
2474 size
+= window_min_size_1 (c
, width_p
);
2475 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2480 /* The min height a horizontal combination equals
2481 the maximum of all min height of its children. */
2484 int min_size
= window_min_size_1 (c
, width_p
);
2485 size
= max (min_size
, size
);
2486 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2490 else if (!NILP (w
->vchild
))
2492 c
= XWINDOW (w
->vchild
);
2497 /* The min width of a vertical combination is
2498 the maximum of the min widths of its children. */
2501 int min_size
= window_min_size_1 (c
, width_p
);
2502 size
= max (min_size
, size
);
2503 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2508 /* The min height of a vertical combination equals
2509 the sum of the min height of its children. */
2512 size
+= window_min_size_1 (c
, width_p
);
2513 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2520 size
= window_min_width
;
2523 if (MINI_WINDOW_P (w
)
2524 || (!WINDOW_WANTS_MODELINE_P (w
)
2525 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2528 size
= window_min_height
;
2536 /* Return the minimum size of window W, taking fixed-size windows into
2537 account. WIDTH_P non-zero means return the minimum width,
2538 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2539 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2540 unless FIXED is null. */
2543 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2545 int width_p
, ignore_fixed_p
, *fixed
;
2552 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2558 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2560 size
= window_min_size_1 (w
, width_p
);
2566 /* Adjust the margins of window W if text area is too small.
2567 Return 1 if window width is ok after adjustment; 0 if window
2568 is still too narrow. */
2571 adjust_window_margins (w
)
2574 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2575 - WINDOW_FRINGE_COLS (w
)
2576 - WINDOW_SCROLL_BAR_COLS (w
));
2577 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2578 + WINDOW_RIGHT_MARGIN_COLS (w
));
2580 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2583 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2586 /* Window's text area is too narrow, but reducing the window
2587 margins will fix that. */
2588 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2589 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2591 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2592 w
->left_margin_cols
= w
->right_margin_cols
2593 = make_number (margin_cols
/2);
2595 w
->right_margin_cols
= make_number (margin_cols
);
2598 w
->left_margin_cols
= make_number (margin_cols
);
2602 /* Calculate new sizes for windows in the list FORWARD when the window size
2603 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2604 The number of windows in FORWARD is NCHILDREN, and the number that
2605 can shrink is SHRINKABLE.
2606 The minimum size a window can have is MIN_SIZE.
2607 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2608 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2611 This function returns an allocated array of new sizes that the caller
2612 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2613 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2614 the second, and so on.
2616 This function tries to keep windows at least at the minimum size
2617 and resize other windows before it resizes any window to zero (i.e.
2618 delete that window).
2620 Windows are resized proportional to their size, so bigger windows
2621 shrink more than smaller windows. */
2623 shrink_windows (total
, size
, nchildren
, shrinkable
,
2624 min_size
, resize_fixed_p
, forward
, width_p
)
2625 int total
, size
, nchildren
, shrinkable
, min_size
;
2626 int resize_fixed_p
, width_p
;
2627 Lisp_Object forward
;
2629 int available_resize
= 0;
2633 int smallest
= total
;
2634 int total_removed
= 0;
2635 int total_shrink
= total
- size
;
2638 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2640 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2644 c
= XWINDOW (child
);
2645 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2647 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2651 new_sizes
[i
] = child_size
;
2652 if (child_size
> min_size
)
2653 available_resize
+= child_size
- min_size
;
2656 /* We might need to shrink some windows to zero. Find the smallest
2657 windows and set them to 0 until we can fulfil the new size. */
2659 while (shrinkable
> 1 && size
+ available_resize
< total
)
2661 for (i
= 0; i
< nchildren
; ++i
)
2662 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2663 smallest
= new_sizes
[i
];
2665 for (i
= 0; i
< nchildren
; ++i
)
2666 if (new_sizes
[i
] == smallest
)
2668 /* Resize this window down to zero. */
2670 if (smallest
> min_size
)
2671 available_resize
-= smallest
- min_size
;
2672 available_resize
+= smallest
;
2674 total_removed
+= smallest
;
2676 /* We don't know what the smallest is now. */
2679 /* Out of for, just remove one window at the time and
2680 check again if we have enough space. */
2685 /* Now, calculate the new sizes. Try to shrink each window
2686 proportional to its size. */
2687 for (i
= 0; i
< nchildren
; ++i
)
2689 if (new_sizes
[i
] > min_size
)
2691 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2692 if (new_sizes
[i
] - to_shrink
< min_size
)
2693 to_shrink
= new_sizes
[i
] - min_size
;
2694 new_sizes
[i
] -= to_shrink
;
2695 total_removed
+= to_shrink
;
2699 /* Any reminder due to rounding, we just subtract from windows
2700 that are left and still can be shrunk. */
2701 while (total_shrink
> total_removed
)
2703 int nonzero_sizes
= 0;
2704 int nonzero_idx
= -1;
2706 for (i
= 0; i
< nchildren
; ++i
)
2707 if (new_sizes
[i
] > 0)
2713 for (i
= 0; i
< nchildren
; ++i
)
2714 if (new_sizes
[i
] > min_size
)
2719 /* Out of for, just shrink one window at the time and
2720 check again if we have enough space. */
2725 /* Special case, only one window left. */
2726 if (nonzero_sizes
== 1)
2730 /* Any surplus due to rounding, we add to windows that are left. */
2731 while (total_shrink
< total_removed
)
2733 for (i
= 0; i
< nchildren
; ++i
)
2735 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2747 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2748 WINDOW's width. Resize WINDOW's children, if any, so that they
2749 keep their proportionate size relative to WINDOW. Propagate
2750 WINDOW's top or left edge position to children. Delete windows
2751 that become too small unless NODELETE_P is non-zero.
2753 If NODELETE_P is 2, that means we do delete windows that are
2754 too small, even if they were too small before! */
2757 size_window (window
, size
, width_p
, nodelete_p
)
2759 int size
, width_p
, nodelete_p
;
2761 struct window
*w
= XWINDOW (window
);
2763 Lisp_Object child
, *forward
, *sideward
;
2764 int old_size
, min_size
, safe_min_size
;
2766 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2767 seems like it's too soon to do this here. ++KFS. */
2768 if (nodelete_p
== 2)
2771 check_min_window_sizes ();
2772 size
= max (0, size
);
2774 /* If the window has been "too small" at one point,
2775 don't delete it for being "too small" in the future.
2776 Preserve it as long as that is at all possible. */
2779 old_size
= WINDOW_TOTAL_COLS (w
);
2780 min_size
= window_min_width
;
2781 /* Ensure that there is room for the scroll bar and fringes!
2782 We may reduce display margins though. */
2783 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2784 + WINDOW_FRINGE_COLS (w
)
2785 + WINDOW_SCROLL_BAR_COLS (w
));
2789 old_size
= XINT (w
->total_lines
);
2790 min_size
= window_min_height
;
2791 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2794 if (old_size
< min_size
&& nodelete_p
!= 2)
2795 w
->too_small_ok
= Qt
;
2797 /* Maybe delete WINDOW if it's too small. */
2798 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2800 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2801 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2802 if (min_size
< safe_min_size
)
2803 min_size
= safe_min_size
;
2804 if (size
< min_size
)
2806 delete_window (window
);
2811 /* Set redisplay hints. */
2812 w
->last_modified
= make_number (0);
2813 w
->last_overlay_modified
= make_number (0);
2814 windows_or_buffers_changed
++;
2815 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2819 sideward
= &w
->vchild
;
2820 forward
= &w
->hchild
;
2821 w
->total_cols
= make_number (size
);
2822 adjust_window_margins (w
);
2826 sideward
= &w
->hchild
;
2827 forward
= &w
->vchild
;
2828 w
->total_lines
= make_number (size
);
2829 w
->orig_total_lines
= Qnil
;
2832 if (!NILP (*sideward
))
2834 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2836 c
= XWINDOW (child
);
2838 c
->left_col
= w
->left_col
;
2840 c
->top_line
= w
->top_line
;
2841 size_window (child
, size
, width_p
, nodelete_p
);
2844 else if (!NILP (*forward
))
2846 int fixed_size
, each
, extra
, n
;
2847 int resize_fixed_p
, nfixed
;
2848 int last_pos
, first_pos
, nchildren
, total
;
2849 int *new_sizes
= NULL
;
2851 /* Determine the fixed-size portion of the this window, and the
2852 number of child windows. */
2853 fixed_size
= nchildren
= nfixed
= total
= 0;
2854 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2858 c
= XWINDOW (child
);
2859 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2860 total
+= child_size
;
2862 if (window_fixed_size_p (c
, width_p
, 0))
2864 fixed_size
+= child_size
;
2869 /* If the new size is smaller than fixed_size, or if there
2870 aren't any resizable windows, allow resizing fixed-size
2872 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2874 /* Compute how many lines/columns to add/remove to each child. The
2875 value of extra takes care of rounding errors. */
2876 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2877 if (size
< total
&& n
> 1)
2878 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2879 resize_fixed_p
, *forward
, width_p
);
2882 each
= (size
- total
) / n
;
2883 extra
= (size
- total
) - n
* each
;
2886 /* Compute new children heights and edge positions. */
2887 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2888 last_pos
= first_pos
;
2889 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2891 int new_size
, old_size
;
2893 c
= XWINDOW (child
);
2894 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2895 new_size
= old_size
;
2897 /* The top or left edge position of this child equals the
2898 bottom or right edge of its predecessor. */
2900 c
->left_col
= make_number (last_pos
);
2902 c
->top_line
= make_number (last_pos
);
2904 /* If this child can be resized, do it. */
2905 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2907 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2911 /* Set new height. Note that size_window also propagates
2912 edge positions to children, so it's not a no-op if we
2913 didn't change the child's size. */
2914 size_window (child
, new_size
, width_p
, 1);
2916 /* Remember the bottom/right edge position of this child; it
2917 will be used to set the top/left edge of the next child. */
2918 last_pos
+= new_size
;
2921 if (new_sizes
) xfree (new_sizes
);
2923 /* We should have covered the parent exactly with child windows. */
2924 xassert (size
== last_pos
- first_pos
);
2926 /* Now delete any children that became too small. */
2928 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2931 c
= XWINDOW (child
);
2932 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2933 size_window (child
, child_size
, width_p
, 2);
2938 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2939 WINDOW's children. NODELETE non-zero means don't delete windows
2940 that become too small in the process. (The caller should check
2941 later and do so if appropriate.) */
2944 set_window_height (window
, height
, nodelete
)
2949 size_window (window
, height
, 0, nodelete
);
2953 /* Set WINDOW's width to WIDTH, and recursively change the width of
2954 WINDOW's children. NODELETE non-zero means don't delete windows
2955 that become too small in the process. (The caller should check
2956 later and do so if appropriate.) */
2959 set_window_width (window
, width
, nodelete
)
2964 size_window (window
, width
, 1, nodelete
);
2967 /* Change window heights in windows rooted in WINDOW by N lines. */
2970 change_window_heights (window
, n
)
2974 struct window
*w
= XWINDOW (window
);
2976 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
2977 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
2979 if (INTEGERP (w
->orig_top_line
))
2980 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
2981 if (INTEGERP (w
->orig_total_lines
))
2982 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
2984 /* Handle just the top child in a vertical split. */
2985 if (!NILP (w
->vchild
))
2986 change_window_heights (w
->vchild
, n
);
2988 /* Adjust all children in a horizontal split. */
2989 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
2991 w
= XWINDOW (window
);
2992 change_window_heights (window
, n
);
2997 int window_select_count
;
3000 Fset_window_buffer_unwind (obuf
)
3007 EXFUN (Fset_window_fringes
, 4);
3008 EXFUN (Fset_window_scroll_bars
, 4);
3010 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3011 means it's allowed to run hooks. See make_frame for a case where
3012 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3013 margins, fringes, and scroll-bar settings of the window are not
3014 reset from the buffer's local settings. */
3017 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3018 Lisp_Object window
, buffer
;
3019 int run_hooks_p
, keep_margins_p
;
3021 struct window
*w
= XWINDOW (window
);
3022 struct buffer
*b
= XBUFFER (buffer
);
3023 int count
= SPECPDL_INDEX ();
3027 if (EQ (window
, selected_window
))
3028 b
->last_selected_window
= window
;
3030 /* Let redisplay errors through. */
3031 b
->display_error_modiff
= 0;
3033 /* Update time stamps of buffer display. */
3034 if (INTEGERP (b
->display_count
))
3035 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3036 b
->display_time
= Fcurrent_time ();
3038 XSETFASTINT (w
->window_end_pos
, 0);
3039 XSETFASTINT (w
->window_end_vpos
, 0);
3040 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3041 w
->window_end_valid
= Qnil
;
3042 w
->hscroll
= w
->min_hscroll
= make_number (0);
3044 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3045 set_marker_restricted (w
->start
,
3046 make_number (b
->last_window_start
),
3048 w
->start_at_line_beg
= Qnil
;
3049 w
->force_start
= Qnil
;
3050 XSETFASTINT (w
->last_modified
, 0);
3051 XSETFASTINT (w
->last_overlay_modified
, 0);
3052 windows_or_buffers_changed
++;
3054 /* We must select BUFFER for running the window-scroll-functions.
3055 If WINDOW is selected, switch permanently.
3056 Otherwise, switch but go back to the ambient buffer afterward. */
3057 if (EQ (window
, selected_window
))
3058 Fset_buffer (buffer
);
3059 /* We can't check ! NILP (Vwindow_scroll_functions) here
3060 because that might itself be a local variable. */
3061 else if (window_initialized
)
3063 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3064 Fset_buffer (buffer
);
3067 if (!keep_margins_p
)
3069 /* Set left and right marginal area width etc. from buffer. */
3071 /* This may call adjust_window_margins three times, so
3072 temporarily disable window margins. */
3073 Lisp_Object save_left
= w
->left_margin_cols
;
3074 Lisp_Object save_right
= w
->right_margin_cols
;
3076 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3078 Fset_window_fringes (window
,
3079 b
->left_fringe_width
, b
->right_fringe_width
,
3080 b
->fringes_outside_margins
);
3082 Fset_window_scroll_bars (window
,
3083 b
->scroll_bar_width
,
3084 b
->vertical_scroll_bar_type
, Qnil
);
3086 w
->left_margin_cols
= save_left
;
3087 w
->right_margin_cols
= save_right
;
3089 Fset_window_margins (window
,
3090 b
->left_margin_cols
, b
->right_margin_cols
);
3095 if (! NILP (Vwindow_scroll_functions
))
3096 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3097 Fmarker_position (w
->start
));
3099 if (! NILP (Vwindow_configuration_change_hook
)
3100 && ! NILP (Vrun_hooks
))
3101 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3104 unbind_to (count
, Qnil
);
3108 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3109 doc
: /* Make WINDOW display BUFFER as its contents.
3110 BUFFER can be a buffer or the name of an existing buffer.
3111 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3112 display margins, fringe widths, and scroll bar settings are maintained;
3113 the default is to reset these from BUFFER's local settings or the frame
3116 This function runs the hook `window-scroll-functions'. */)
3117 (window
, buffer
, keep_margins
)
3118 register Lisp_Object window
, buffer
, keep_margins
;
3120 register Lisp_Object tem
;
3121 register struct window
*w
= decode_window (window
);
3123 XSETWINDOW (window
, w
);
3124 buffer
= Fget_buffer (buffer
);
3125 CHECK_BUFFER (buffer
);
3127 if (NILP (XBUFFER (buffer
)->name
))
3128 error ("Attempt to display deleted buffer");
3132 error ("Window is deleted");
3133 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3134 is first being set up. */
3136 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3137 error ("Window is dedicated to `%s'",
3138 SDATA (XBUFFER (tem
)->name
));
3143 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3147 /* Note that selected_window can be nil
3148 when this is called from Fset_window_configuration. */
3150 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3151 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3152 If WINDOW is not already selected, make WINDOW's buffer current
3153 and make WINDOW the frame's selected window. Return WINDOW.
3154 Optional second arg NORECORD non-nil means
3155 do not put this buffer at the front of the list of recently selected ones.
3157 Note that the main editor command loop
3158 selects the buffer of the selected window before each command. */)
3160 register Lisp_Object window
, norecord
;
3162 register struct window
*w
;
3163 register struct window
*ow
;
3166 CHECK_LIVE_WINDOW (window
);
3168 w
= XWINDOW (window
);
3169 w
->frozen_window_start_p
= 0;
3171 ++window_select_count
;
3172 XSETFASTINT (w
->use_time
, window_select_count
);
3173 if (EQ (window
, selected_window
))
3176 if (!NILP (selected_window
))
3178 ow
= XWINDOW (selected_window
);
3179 if (! NILP (ow
->buffer
))
3180 set_marker_both (ow
->pointm
, ow
->buffer
,
3181 BUF_PT (XBUFFER (ow
->buffer
)),
3182 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3185 selected_window
= window
;
3186 sf
= SELECTED_FRAME ();
3187 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3189 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3190 /* Use this rather than Fhandle_switch_frame
3191 so that FRAME_FOCUS_FRAME is moved appropriately as we
3192 move around in the state where a minibuffer in a separate
3194 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
3197 sf
->selected_window
= window
;
3199 if (NILP (norecord
))
3200 record_buffer (w
->buffer
);
3201 Fset_buffer (w
->buffer
);
3203 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3205 /* Go to the point recorded in the window.
3206 This is important when the buffer is in more
3207 than one window. It also matters when
3208 redisplay_window has altered point after scrolling,
3209 because it makes the change only in the window. */
3211 register int new_point
= marker_position (w
->pointm
);
3212 if (new_point
< BEGV
)
3214 else if (new_point
> ZV
)
3220 windows_or_buffers_changed
++;
3225 select_window_norecord (window
)
3228 return Fselect_window (window
, Qt
);
3231 /* Deiconify the frame containing the window WINDOW,
3232 unless it is the selected frame;
3235 The reason for the exception for the selected frame
3236 is that it seems better not to change the selected frames visibility
3237 merely because of displaying a different buffer in it.
3238 The deiconification is useful when a buffer gets shown in
3239 another frame that you were not using lately. */
3242 display_buffer_1 (window
)
3245 Lisp_Object frame
= XWINDOW (window
)->frame
;
3246 FRAME_PTR f
= XFRAME (frame
);
3248 FRAME_SAMPLE_VISIBILITY (f
);
3250 if (EQ (frame
, selected_frame
))
3251 ; /* Assume the selected frame is already visible enough. */
3252 else if (minibuf_level
> 0
3253 && MINI_WINDOW_P (XWINDOW (selected_window
))
3254 && WINDOW_LIVE_P (minibuf_selected_window
)
3255 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3256 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3259 if (FRAME_ICONIFIED_P (f
))
3260 Fmake_frame_visible (frame
);
3261 else if (FRAME_VISIBLE_P (f
))
3262 Fraise_frame (frame
);
3268 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3269 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3270 If the value is t, a frame would be created for that buffer
3271 using the default frame parameters. If the value is a list,
3272 it is a list of frame parameters that would be used
3273 to make a frame for that buffer.
3274 The variables `special-display-buffer-names'
3275 and `special-display-regexps' control this. */)
3277 Lisp_Object buffer_name
;
3281 CHECK_STRING (buffer_name
);
3283 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3287 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3291 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3293 Lisp_Object car
= XCAR (tem
);
3295 && fast_string_match (car
, buffer_name
) >= 0)
3297 else if (CONSP (car
)
3298 && STRINGP (XCAR (car
))
3299 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3305 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3306 doc
: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
3307 See `same-window-buffer-names' and `same-window-regexps'. */)
3309 Lisp_Object buffer_name
;
3313 CHECK_STRING (buffer_name
);
3315 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3319 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3323 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3325 Lisp_Object car
= XCAR (tem
);
3327 && fast_string_match (car
, buffer_name
) >= 0)
3329 else if (CONSP (car
)
3330 && STRINGP (XCAR (car
))
3331 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3337 /* Use B so the default is (other-buffer). */
3338 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3339 "BDisplay buffer: \nP",
3340 doc
: /* Make BUFFER appear in some window but don't select it.
3341 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3343 If BUFFER is shown already in some window, just use that one,
3344 unless the window is the selected window and the optional second
3345 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3346 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3347 Returns the window displaying BUFFER.
3348 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3349 displaying BUFFER, then simply raise that frame.
3351 The variables `special-display-buffer-names',
3352 `special-display-regexps', `same-window-buffer-names', and
3353 `same-window-regexps' customize how certain buffer names are handled.
3354 The latter two take effect only if NOT-THIS-WINDOW is t.
3356 If optional argument FRAME is `visible', search all visible frames.
3357 If FRAME is 0, search all visible and iconified frames.
3358 If FRAME is t, search all frames.
3359 If FRAME is a frame, search only that frame.
3360 If FRAME is nil, search only the selected frame
3361 (actually the last nonminibuffer frame),
3362 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3363 which means search visible and iconified frames.
3365 If a full-width window on a splittable frame is available to display
3366 the buffer, it may be split, subject to the value of the variable
3367 `split-height-threshold'.
3369 If `even-window-heights' is non-nil, window heights will be evened out
3370 if displaying the buffer causes two vertically adjacent windows to be
3372 (buffer
, not_this_window
, frame
)
3373 register Lisp_Object buffer
, not_this_window
, frame
;
3375 register Lisp_Object window
, tem
, swp
;
3379 buffer
= Fget_buffer (buffer
);
3380 CHECK_BUFFER (buffer
);
3382 if (!NILP (Vdisplay_buffer_function
))
3383 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3385 if (NILP (not_this_window
)
3386 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3387 return display_buffer_1 (selected_window
);
3389 /* See if the user has specified this buffer should appear
3390 in the selected window. */
3391 if (NILP (not_this_window
))
3393 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3394 if (!NILP (swp
) && !no_switch_window (selected_window
))
3396 Fswitch_to_buffer (buffer
, Qnil
);
3397 return display_buffer_1 (selected_window
);
3401 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3402 look for a window showing BUFFER on any visible or iconified frame.
3403 Otherwise search only the current frame. */
3406 else if (pop_up_frames
3407 || display_buffer_reuse_frames
3408 || last_nonminibuf_frame
== 0)
3409 XSETFASTINT (tem
, 0);
3411 XSETFRAME (tem
, last_nonminibuf_frame
);
3413 window
= Fget_buffer_window (buffer
, tem
);
3415 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3416 return display_buffer_1 (window
);
3418 /* Certain buffer names get special handling. */
3419 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3421 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3423 return call1 (Vspecial_display_function
, buffer
);
3425 return call2 (Vspecial_display_function
, buffer
, tem
);
3428 /* If there are no frames open that have more than a minibuffer,
3429 we need to create a new frame. */
3430 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3432 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3433 Fset_window_buffer (window
, buffer
, Qnil
);
3434 return display_buffer_1 (window
);
3437 f
= SELECTED_FRAME ();
3439 || FRAME_MINIBUF_ONLY_P (f
)
3440 /* If the current frame is a special display frame,
3441 don't try to reuse its windows. */
3442 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3447 if (FRAME_MINIBUF_ONLY_P (f
))
3448 XSETFRAME (frames
, last_nonminibuf_frame
);
3449 /* Don't try to create a window if we would get an error. */
3450 if (split_height_threshold
< window_min_height
<< 1)
3451 split_height_threshold
= window_min_height
<< 1;
3453 /* Note that both Fget_largest_window and Fget_lru_window
3454 ignore minibuffers and dedicated windows.
3455 This means they can return nil. */
3457 /* If the frame we would try to split cannot be split,
3458 try other frames. */
3459 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3461 /* Try visible frames first. */
3462 window
= Fget_largest_window (Qvisible
);
3463 /* If that didn't work, try iconified frames. */
3465 window
= Fget_largest_window (make_number (0));
3467 window
= Fget_largest_window (Qt
);
3470 window
= Fget_largest_window (frames
);
3472 /* If we got a tall enough full-width window that can be split,
3475 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3476 && window_height (window
) >= split_height_threshold
3477 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3478 window
= Fsplit_window (window
, Qnil
, Qnil
);
3481 Lisp_Object upper
, lower
, other
;
3483 window
= Fget_lru_window (frames
);
3484 /* If the LRU window is selected, and big enough,
3485 and can be split, split it. */
3487 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3488 && (EQ (window
, selected_window
)
3489 || EQ (XWINDOW (window
)->parent
, Qnil
))
3490 && window_height (window
) >= window_min_height
<< 1)
3491 window
= Fsplit_window (window
, Qnil
, Qnil
);
3492 /* If Fget_lru_window returned nil, try other approaches. */
3494 /* Try visible frames first. */
3496 window
= Fget_buffer_window (buffer
, Qvisible
);
3498 window
= Fget_largest_window (Qvisible
);
3499 /* If that didn't work, try iconified frames. */
3501 window
= Fget_buffer_window (buffer
, make_number (0));
3503 window
= Fget_largest_window (make_number (0));
3504 /* Try invisible frames. */
3506 window
= Fget_buffer_window (buffer
, Qt
);
3508 window
= Fget_largest_window (Qt
);
3509 /* As a last resort, make a new frame. */
3511 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3512 /* If window appears above or below another,
3513 even out their heights. */
3514 other
= upper
= lower
= Qnil
;
3515 if (!NILP (XWINDOW (window
)->prev
))
3516 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3517 if (!NILP (XWINDOW (window
)->next
))
3518 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3520 && !NILP (Veven_window_heights
)
3521 /* Check that OTHER and WINDOW are vertically arrayed. */
3522 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3523 && (XFASTINT (XWINDOW (other
)->total_lines
)
3524 > XFASTINT (XWINDOW (window
)->total_lines
)))
3526 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3527 + XFASTINT (XWINDOW (window
)->total_lines
));
3528 enlarge_window (upper
,
3529 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3535 window
= Fget_lru_window (Qnil
);
3537 Fset_window_buffer (window
, buffer
, Qnil
);
3538 return display_buffer_1 (window
);
3542 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3544 doc
: /* Force redisplay of all windows.
3545 If optional arg OBJECT is a window, force redisplay of that window only.
3546 If OBJECT is a buffer or buffer name, force redisplay of all windows
3547 displaying that buffer. */)
3553 windows_or_buffers_changed
++;
3554 update_mode_lines
++;
3558 if (WINDOWP (object
))
3560 struct window
*w
= XWINDOW (object
);
3561 mark_window_display_accurate (object
, 0);
3562 w
->update_mode_line
= Qt
;
3563 if (BUFFERP (w
->buffer
))
3564 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3565 ++update_mode_lines
;
3569 if (STRINGP (object
))
3570 object
= Fget_buffer (object
);
3571 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3573 /* Walk all windows looking for buffer, and force update
3574 of each of those windows. */
3576 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3577 return NILP (object
) ? Qnil
: Qt
;
3580 /* If nothing suitable was found, just return.
3581 We could signal an error, but this feature will typically be used
3582 asynchronously in timers or process sentinels, so we don't. */
3588 temp_output_buffer_show (buf
)
3589 register Lisp_Object buf
;
3591 register struct buffer
*old
= current_buffer
;
3592 register Lisp_Object window
;
3593 register struct window
*w
;
3595 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3598 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3602 #if 0 /* rms: there should be no reason for this. */
3603 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3605 set_buffer_internal (old
);
3607 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3608 call1 (Vtemp_buffer_show_function
, buf
);
3611 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3613 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3614 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3615 Vminibuf_scroll_window
= window
;
3616 w
= XWINDOW (window
);
3617 XSETFASTINT (w
->hscroll
, 0);
3618 XSETFASTINT (w
->min_hscroll
, 0);
3619 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3620 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3622 /* Run temp-buffer-show-hook, with the chosen window selected
3623 and its buffer current. */
3625 if (!NILP (Vrun_hooks
)
3626 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3627 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3629 int count
= SPECPDL_INDEX ();
3630 Lisp_Object prev_window
, prev_buffer
;
3631 prev_window
= selected_window
;
3632 XSETBUFFER (prev_buffer
, old
);
3634 /* Select the window that was chosen, for running the hook.
3635 Note: Both Fselect_window and select_window_norecord may
3636 set-buffer to the buffer displayed in the window,
3637 so we need to save the current buffer. --stef */
3638 record_unwind_protect (Fset_buffer
, prev_buffer
);
3639 record_unwind_protect (select_window_norecord
, prev_window
);
3640 Fselect_window (window
, Qt
);
3641 Fset_buffer (w
->buffer
);
3642 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3643 unbind_to (count
, Qnil
);
3649 make_dummy_parent (window
)
3653 register struct window
*o
, *p
;
3656 o
= XWINDOW (window
);
3657 p
= allocate_window ();
3658 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3659 ((struct Lisp_Vector
*) p
)->contents
[i
]
3660 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3661 XSETWINDOW (new, p
);
3664 XSETFASTINT (p
->sequence_number
, sequence_number
);
3666 /* Put new into window structure in place of window */
3667 replace_window (window
, new);
3680 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3681 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3682 WINDOW defaults to selected one and SIZE to half its size.
3683 If optional third arg HORFLAG is non-nil, split side by side
3684 and put SIZE columns in the first of the pair. In that case,
3685 SIZE includes that window's scroll bar, or the divider column to its right.
3686 Interactively, all arguments are nil.
3688 Returns the newly created window (which is the lower or rightmost one).
3689 The upper or leftmost window is the original one and remains selected.
3690 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3691 (window
, size
, horflag
)
3692 Lisp_Object window
, size
, horflag
;
3694 register Lisp_Object
new;
3695 register struct window
*o
, *p
;
3697 register int size_int
;
3700 window
= selected_window
;
3702 CHECK_LIVE_WINDOW (window
);
3704 o
= XWINDOW (window
);
3705 fo
= XFRAME (WINDOW_FRAME (o
));
3709 if (!NILP (horflag
))
3710 /* Calculate the size of the left-hand window, by dividing
3711 the usable space in columns by two.
3712 We round up, since the left-hand window may include
3713 a dividing line, while the right-hand may not. */
3714 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3716 size_int
= XFASTINT (o
->total_lines
) >> 1;
3720 CHECK_NUMBER (size
);
3721 size_int
= XINT (size
);
3724 if (MINI_WINDOW_P (o
))
3725 error ("Attempt to split minibuffer window");
3726 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3727 error ("Attempt to split fixed-size window");
3729 check_min_window_sizes ();
3733 if (size_int
< window_min_height
)
3734 error ("Window height %d too small (after splitting)", size_int
);
3735 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3736 error ("Window height %d too small (after splitting)",
3737 XFASTINT (o
->total_lines
) - size_int
);
3738 if (NILP (o
->parent
)
3739 || NILP (XWINDOW (o
->parent
)->vchild
))
3741 make_dummy_parent (window
);
3743 XWINDOW (new)->vchild
= window
;
3748 if (size_int
< window_min_width
)
3749 error ("Window width %d too small (after splitting)", size_int
);
3751 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3752 error ("Window width %d too small (after splitting)",
3753 XFASTINT (o
->total_cols
) - size_int
);
3754 if (NILP (o
->parent
)
3755 || NILP (XWINDOW (o
->parent
)->hchild
))
3757 make_dummy_parent (window
);
3759 XWINDOW (new)->hchild
= window
;
3763 /* Now we know that window's parent is a vertical combination
3764 if we are dividing vertically, or a horizontal combination
3765 if we are making side-by-side windows */
3767 windows_or_buffers_changed
++;
3768 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3769 new = make_window ();
3772 p
->frame
= o
->frame
;
3774 if (!NILP (p
->next
))
3775 XWINDOW (p
->next
)->prev
= new;
3778 p
->parent
= o
->parent
;
3780 p
->window_end_valid
= Qnil
;
3781 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3783 /* Duplicate special geometry settings. */
3785 p
->left_margin_cols
= o
->left_margin_cols
;
3786 p
->right_margin_cols
= o
->right_margin_cols
;
3787 p
->left_fringe_width
= o
->left_fringe_width
;
3788 p
->right_fringe_width
= o
->right_fringe_width
;
3789 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3790 p
->scroll_bar_width
= o
->scroll_bar_width
;
3791 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3793 /* Apportion the available frame space among the two new windows */
3795 if (!NILP (horflag
))
3797 p
->total_lines
= o
->total_lines
;
3798 p
->top_line
= o
->top_line
;
3799 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3800 XSETFASTINT (o
->total_cols
, size_int
);
3801 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3802 adjust_window_margins (p
);
3803 adjust_window_margins (o
);
3807 p
->left_col
= o
->left_col
;
3808 p
->total_cols
= o
->total_cols
;
3809 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3810 XSETFASTINT (o
->total_lines
, size_int
);
3811 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3814 /* Adjust glyph matrices. */
3817 Fset_window_buffer (new, o
->buffer
, Qt
);
3821 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 3, "p",
3822 doc
: /* Make current window ARG lines bigger.
3823 From program, optional second arg non-nil means grow sideways ARG columns.
3824 Interactively, if an argument is not given, make the window one line bigger.
3826 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3827 of the siblings above or to the left of the selected window. Only
3828 siblings to the right or below are changed. */)
3829 (arg
, side
, preserve_before
)
3830 register Lisp_Object arg
, side
, preserve_before
;
3833 enlarge_window (selected_window
, XINT (arg
), !NILP (side
),
3834 !NILP (preserve_before
));
3836 if (! NILP (Vwindow_configuration_change_hook
))
3837 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3842 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3843 doc
: /* Make current window ARG lines smaller.
3844 From program, optional second arg non-nil means shrink sideways arg columns.
3845 Interactively, if an argument is not given, make the window one line smaller.
3847 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3848 of the siblings above or to the left of the selected window. Only
3849 siblings to the right or below are changed. */)
3850 (arg
, side
, preserve_before
)
3851 register Lisp_Object arg
, side
, preserve_before
;
3854 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3855 !NILP (preserve_before
));
3857 if (! NILP (Vwindow_configuration_change_hook
))
3858 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3864 window_height (window
)
3867 register struct window
*p
= XWINDOW (window
);
3868 return WINDOW_TOTAL_LINES (p
);
3872 window_width (window
)
3875 register struct window
*p
= XWINDOW (window
);
3876 return WINDOW_TOTAL_COLS (p
);
3881 *(widthflag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3883 #define CURSIZE(w) \
3884 *(widthflag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3887 /* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
3888 increase its width. Siblings of the selected window are resized to
3889 fulfill the size request. If they become too small in the process,
3890 they will be deleted.
3892 If PRESERVE_BEFORE is nonzero, that means don't alter
3893 the siblings to the left or above WINDOW. */
3896 enlarge_window (window
, delta
, widthflag
, preserve_before
)
3898 int delta
, widthflag
, preserve_before
;
3900 Lisp_Object parent
, next
, prev
;
3904 int (*sizefun
) P_ ((Lisp_Object
))
3905 = widthflag
? window_width
: window_height
;
3906 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3907 = (widthflag
? set_window_width
: set_window_height
);
3909 /* Check values of window_min_width and window_min_height for
3911 check_min_window_sizes ();
3913 /* Give up if this window cannot be resized. */
3914 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3915 error ("Window is not resizable");
3917 /* Find the parent of the selected window. */
3920 p
= XWINDOW (window
);
3926 error ("No other window to side of this one");
3931 ? !NILP (XWINDOW (parent
)->hchild
)
3932 : !NILP (XWINDOW (parent
)->vchild
))
3938 sizep
= &CURSIZE (window
);
3941 register int maxdelta
;
3943 /* Compute the maximum size increment this window can have. */
3945 if (preserve_before
)
3949 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
3950 /* Subtract size of siblings before, since we can't take that. */
3951 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
3954 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3955 - window_min_size (XWINDOW (p
->next
),
3960 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3961 /* This is a main window followed by a minibuffer. */
3962 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3963 - window_min_size (XWINDOW (p
->next
),
3965 /* This is a minibuffer following a main window. */
3966 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3967 - window_min_size (XWINDOW (p
->prev
),
3969 /* This is a frame with only one window, a minibuffer-only
3970 or a minibufferless frame. */
3973 if (delta
> maxdelta
)
3974 /* This case traps trying to make the minibuffer
3975 the full frame, or make the only window aside from the
3976 minibuffer the full frame. */
3980 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3982 delete_window (window
);
3989 /* Find the total we can get from other siblings without deleting them. */
3991 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3992 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3994 if (! preserve_before
)
3995 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3996 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3999 /* If we can get it all from them without deleting them, do so. */
4000 if (delta
<= maximum
)
4002 Lisp_Object first_unaffected
;
4003 Lisp_Object first_affected
;
4008 first_affected
= window
;
4009 /* Look at one sibling at a time,
4010 moving away from this window in both directions alternately,
4011 and take as much as we can get without deleting that sibling. */
4013 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
4017 int this_one
= ((*sizefun
) (next
)
4018 - window_min_size (XWINDOW (next
),
4019 widthflag
, 0, &fixed_p
));
4022 if (this_one
> delta
)
4025 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4026 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4031 next
= XWINDOW (next
)->next
;
4037 if (!preserve_before
&& ! NILP (prev
))
4039 int this_one
= ((*sizefun
) (prev
)
4040 - window_min_size (XWINDOW (prev
),
4041 widthflag
, 0, &fixed_p
));
4044 if (this_one
> delta
)
4047 first_affected
= prev
;
4049 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4050 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4055 prev
= XWINDOW (prev
)->prev
;
4059 xassert (delta
== 0);
4061 /* Now recalculate the edge positions of all the windows affected,
4062 based on the new sizes. */
4063 first_unaffected
= next
;
4064 prev
= first_affected
;
4065 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4066 prev
= next
, next
= XWINDOW (next
)->next
)
4068 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4069 /* This does not change size of NEXT,
4070 but it propagates the new top edge to its children */
4071 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4076 register int delta1
;
4077 register int opht
= (*sizefun
) (parent
);
4079 if (opht
<= XINT (*sizep
) + delta
)
4081 /* If trying to grow this window to or beyond size of the parent,
4082 just delete all the sibling windows. */
4083 Lisp_Object start
, tem
, next
;
4085 start
= XWINDOW (parent
)->vchild
;
4087 start
= XWINDOW (parent
)->hchild
;
4089 /* Delete any siblings that come after WINDOW. */
4090 tem
= XWINDOW (window
)->next
;
4091 while (! NILP (tem
))
4093 next
= XWINDOW (tem
)->next
;
4094 delete_window (tem
);
4098 /* Delete any siblings that come after WINDOW.
4099 Note that if START is not WINDOW, then WINDOW still
4100 Fhas siblings, so WINDOW has not yet replaced its parent. */
4102 while (! EQ (tem
, window
))
4104 next
= XWINDOW (tem
)->next
;
4105 delete_window (tem
);
4111 /* Otherwise, make delta1 just right so that if we add
4112 delta1 lines to this window and to the parent, and then
4113 shrink the parent back to its original size, the new
4114 proportional size of this window will increase by delta.
4116 The function size_window will compute the new height h'
4117 of the window from delta1 as:
4120 x = delta1 - delta1/n * n for the 1st resizable child
4123 where n is the number of children that can be resized.
4124 We can ignore x by choosing a delta1 that is a multiple of
4125 n. We want the height of this window to come out as
4135 The number of children n equals the number of resizable
4136 children of this window + 1 because we know window itself
4137 is resizable (otherwise we would have signalled an error. */
4139 struct window
*w
= XWINDOW (window
);
4143 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4144 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4146 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4147 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4152 /* Add delta1 lines or columns to this window, and to the parent,
4153 keeping things consistent while not affecting siblings. */
4154 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4155 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4157 /* Squeeze out delta1 lines or columns from our parent,
4158 shriking this window and siblings proportionately.
4159 This brings parent back to correct size.
4160 Delta1 was calculated so this makes this window the desired size,
4161 taking it all out of the siblings. */
4162 (*setsizefun
) (parent
, opht
, 0);
4167 XSETFASTINT (p
->last_modified
, 0);
4168 XSETFASTINT (p
->last_overlay_modified
, 0);
4170 /* Adjust glyph matrices. */
4171 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4179 /***********************************************************************
4180 Resizing Mini-Windows
4181 ***********************************************************************/
4183 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4185 enum save_restore_action
4192 static int save_restore_orig_size
P_ ((struct window
*,
4193 enum save_restore_action
));
4195 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4196 from lowest windows first. */
4199 shrink_window_lowest_first (w
, height
)
4207 xassert (!MINI_WINDOW_P (w
));
4209 /* Set redisplay hints. */
4210 XSETFASTINT (w
->last_modified
, 0);
4211 XSETFASTINT (w
->last_overlay_modified
, 0);
4212 windows_or_buffers_changed
++;
4213 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4215 old_height
= XFASTINT (w
->total_lines
);
4216 XSETFASTINT (w
->total_lines
, height
);
4218 if (!NILP (w
->hchild
))
4220 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4222 c
= XWINDOW (child
);
4223 c
->top_line
= w
->top_line
;
4224 shrink_window_lowest_first (c
, height
);
4227 else if (!NILP (w
->vchild
))
4229 Lisp_Object last_child
;
4230 int delta
= old_height
- height
;
4235 /* Find the last child. We are taking space from lowest windows
4236 first, so we iterate over children from the last child
4238 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4241 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4242 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4246 c
= XWINDOW (child
);
4247 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4249 if (this_one
> delta
)
4252 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4256 /* Compute new positions. */
4257 last_top
= XINT (w
->top_line
);
4258 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4260 c
= XWINDOW (child
);
4261 c
->top_line
= make_number (last_top
);
4262 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4263 last_top
+= XFASTINT (c
->total_lines
);
4269 /* Save, restore, or check positions and sizes in the window tree
4270 rooted at W. ACTION says what to do.
4272 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4273 orig_total_lines members are valid for all windows in the window
4274 tree. Value is non-zero if they are valid.
4276 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4277 orig_top_line and orig_total_lines for all windows in the tree.
4279 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4280 stored in orig_top_line and orig_total_lines for all windows. */
4283 save_restore_orig_size (w
, action
)
4285 enum save_restore_action action
;
4291 if (!NILP (w
->hchild
))
4293 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4296 else if (!NILP (w
->vchild
))
4298 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4304 case CHECK_ORIG_SIZES
:
4305 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4309 case SAVE_ORIG_SIZES
:
4310 w
->orig_top_line
= w
->top_line
;
4311 w
->orig_total_lines
= w
->total_lines
;
4312 XSETFASTINT (w
->last_modified
, 0);
4313 XSETFASTINT (w
->last_overlay_modified
, 0);
4316 case RESTORE_ORIG_SIZES
:
4317 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4318 w
->top_line
= w
->orig_top_line
;
4319 w
->total_lines
= w
->orig_total_lines
;
4320 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4321 XSETFASTINT (w
->last_modified
, 0);
4322 XSETFASTINT (w
->last_overlay_modified
, 0);
4329 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4336 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4337 without deleting other windows. */
4340 grow_mini_window (w
, delta
)
4344 struct frame
*f
= XFRAME (w
->frame
);
4345 struct window
*root
;
4347 xassert (MINI_WINDOW_P (w
));
4348 xassert (delta
>= 0);
4350 /* Check values of window_min_width and window_min_height for
4352 check_min_window_sizes ();
4354 /* Compute how much we can enlarge the mini-window without deleting
4356 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4359 int min_height
= window_min_size (root
, 0, 0, 0);
4360 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4361 /* Note that the root window may already be smaller than
4363 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4368 /* Save original window sizes and positions, if not already done. */
4369 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4370 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4372 /* Shrink other windows. */
4373 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4375 /* Grow the mini-window. */
4376 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4377 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4378 XSETFASTINT (w
->last_modified
, 0);
4379 XSETFASTINT (w
->last_overlay_modified
, 0);
4386 /* Shrink mini-window W. If there is recorded info about window sizes
4387 before a call to grow_mini_window, restore recorded window sizes.
4388 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4392 shrink_mini_window (w
)
4395 struct frame
*f
= XFRAME (w
->frame
);
4396 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4398 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4400 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4402 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4403 windows_or_buffers_changed
= 1;
4405 else if (XFASTINT (w
->total_lines
) > 1)
4407 /* Distribute the additional lines of the mini-window
4408 among the other windows. */
4410 XSETWINDOW (window
, w
);
4411 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0, 0);
4417 /* Mark window cursors off for all windows in the window tree rooted
4418 at W by setting their phys_cursor_on_p flag to zero. Called from
4419 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4420 the frame are cleared. */
4423 mark_window_cursors_off (w
)
4428 if (!NILP (w
->hchild
))
4429 mark_window_cursors_off (XWINDOW (w
->hchild
));
4430 else if (!NILP (w
->vchild
))
4431 mark_window_cursors_off (XWINDOW (w
->vchild
));
4433 w
->phys_cursor_on_p
= 0;
4435 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4440 /* Return number of lines of text (not counting mode lines) in W. */
4443 window_internal_height (w
)
4446 int ht
= XFASTINT (w
->total_lines
);
4448 if (!MINI_WINDOW_P (w
))
4450 if (!NILP (w
->parent
)
4451 || !NILP (w
->vchild
)
4452 || !NILP (w
->hchild
)
4455 || WINDOW_WANTS_MODELINE_P (w
))
4458 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4466 /* Return the number of columns in W.
4467 Don't count columns occupied by scroll bars or the vertical bar
4468 separating W from the sibling to its right. */
4471 window_box_text_cols (w
)
4474 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4475 int width
= XINT (w
->total_cols
);
4477 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4478 /* Scroll bars occupy a few columns. */
4479 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4480 else if (!FRAME_WINDOW_P (f
)
4481 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4482 /* The column of `|' characters separating side-by-side windows
4483 occupies one column only. */
4486 if (FRAME_WINDOW_P (f
))
4487 /* On window-systems, fringes and display margins cannot be
4488 used for normal text. */
4489 width
-= (WINDOW_FRINGE_COLS (w
)
4490 + WINDOW_LEFT_MARGIN_COLS (w
)
4491 + WINDOW_RIGHT_MARGIN_COLS (w
));
4497 /************************************************************************
4499 ***********************************************************************/
4501 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4502 N screen-fulls, which is defined as the height of the window minus
4503 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4504 instead. Negative values of N mean scroll down. NOERROR non-zero
4505 means don't signal an error if we try to move over BEGV or ZV,
4509 window_scroll (window
, n
, whole
, noerror
)
4517 /* If we must, use the pixel-based version which is much slower than
4518 the line-based one but can handle varying line heights. */
4519 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4520 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4522 window_scroll_line_based (window
, n
, whole
, noerror
);
4528 /* Implementation of window_scroll that works based on pixel line
4529 heights. See the comment of window_scroll for parameter
4533 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4540 struct window
*w
= XWINDOW (window
);
4541 struct text_pos start
;
4543 int this_scroll_margin
;
4545 /* True if we fiddled the window vscroll field without really scrolling. */
4548 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4550 /* If PT is not visible in WINDOW, move back one half of
4551 the screen. Allow PT to be partially visible, otherwise
4552 something like (scroll-down 1) with PT in the line before
4553 the partially visible one would recenter. */
4554 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4557 /* Move backward half the height of the window. Performance note:
4558 vmotion used here is about 10% faster, but would give wrong
4559 results for variable height lines. */
4560 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4561 it
.current_y
= it
.last_visible_y
;
4562 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4564 /* The function move_iterator_vertically may move over more than
4565 the specified y-distance. If it->w is small, e.g. a
4566 mini-buffer window, we may end up in front of the window's
4567 display area. This is the case when Start displaying at the
4568 start of the line containing PT in this case. */
4569 if (it
.current_y
<= 0)
4571 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4572 move_it_vertically_backward (&it
, 0);
4576 start
= it
.current
.pos
;
4578 else if (auto_window_vscroll_p
)
4580 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4583 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4585 dy
= max ((window_box_height (w
)
4586 - next_screen_context_lines
* dy
),
4590 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4592 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4593 Fset_window_vscroll (window
, make_number (px
), Qt
);
4596 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4598 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4599 Fset_window_vscroll (window
, make_number (px
), Qt
);
4603 Fset_window_vscroll (window
, make_number (0), Qt
);
4606 /* If scroll_preserve_screen_position is non-nil, we try to set
4607 point in the same window line as it is now, so get that line. */
4608 if (!NILP (Vscroll_preserve_screen_position
))
4610 start_display (&it
, w
, start
);
4611 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4612 preserve_y
= it
.current_y
;
4617 /* Move iterator it from start the specified distance forward or
4618 backward. The result is the new window start. */
4619 start_display (&it
, w
, start
);
4622 int start_pos
= IT_CHARPOS (it
);
4623 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4624 dy
= max ((window_box_height (w
)
4625 - next_screen_context_lines
* dy
),
4628 /* Note that move_it_vertically always moves the iterator to the
4629 start of a line. So, if the last line doesn't have a newline,
4630 we would end up at the start of the line ending at ZV. */
4633 move_it_vertically_backward (&it
, -dy
);
4634 /* Ensure we actually does move, e.g. in case we are currently
4635 looking at an image that is taller that the window height. */
4636 while (start_pos
== IT_CHARPOS (it
)
4637 && start_pos
> BEGV
)
4638 move_it_by_lines (&it
, -1, 1);
4642 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4643 MOVE_TO_POS
| MOVE_TO_Y
);
4644 /* Ensure we actually does move, e.g. in case we are currently
4645 looking at an image that is taller that the window height. */
4646 while (start_pos
== IT_CHARPOS (it
)
4648 move_it_by_lines (&it
, 1, 1);
4652 move_it_by_lines (&it
, n
, 1);
4654 /* We failed if we find ZV is already on the screen (scrolling up,
4655 means there's nothing past the end), or if we can't start any
4656 earlier (scrolling down, means there's nothing past the top). */
4657 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4658 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4660 if (IT_CHARPOS (it
) == ZV
)
4662 if (it
.current_y
< it
.last_visible_y
4663 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4664 >= it
.last_visible_y
))
4666 /* The last line was only partially visible, make it fully
4668 w
->vscroll
= (it
.last_visible_y
4669 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4670 adjust_glyphs (it
.f
);
4675 Fsignal (Qend_of_buffer
, Qnil
);
4679 if (w
->vscroll
!= 0)
4680 /* The first line was only partially visible, make it fully
4686 Fsignal (Qbeginning_of_buffer
, Qnil
);
4689 /* If control gets here, then we vscrolled. */
4691 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4693 /* Don't try to change the window start below. */
4699 int pos
= IT_CHARPOS (it
);
4702 /* If in the middle of a multi-glyph character move forward to
4703 the next character. */
4704 if (in_display_vector_p (&it
))
4707 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4710 /* Set the window start, and set up the window for redisplay. */
4711 set_marker_restricted (w
->start
, make_number (pos
),
4713 bytepos
= XMARKER (w
->start
)->bytepos
;
4714 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4716 w
->update_mode_line
= Qt
;
4717 XSETFASTINT (w
->last_modified
, 0);
4718 XSETFASTINT (w
->last_overlay_modified
, 0);
4719 /* Set force_start so that redisplay_window will run the
4720 window-scroll-functions. */
4721 w
->force_start
= Qt
;
4724 /* The rest of this function uses current_y in a nonstandard way,
4725 not including the height of the header line if any. */
4726 it
.current_y
= it
.vpos
= 0;
4728 /* Move PT out of scroll margins.
4729 This code wants current_y to be zero at the window start position
4730 even if there is a header line. */
4731 this_scroll_margin
= max (0, scroll_margin
);
4732 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4733 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4737 /* We moved the window start towards ZV, so PT may be now
4738 in the scroll margin at the top. */
4739 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4740 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
)
4741 /* We found PT at a legitimate height. Leave it alone. */
4743 else if (preserve_y
>= 0)
4745 /* If we have a header line, take account of it.
4746 This is necessary because we set it.current_y to 0, above. */
4747 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4748 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4750 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4751 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4755 while (it
.current_y
< this_scroll_margin
)
4757 int prev
= it
.current_y
;
4758 move_it_by_lines (&it
, 1, 1);
4759 if (prev
== it
.current_y
)
4762 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4767 int charpos
, bytepos
;
4770 /* Save our position, for the preserve_y case. */
4771 charpos
= IT_CHARPOS (it
);
4772 bytepos
= IT_BYTEPOS (it
);
4774 /* We moved the window start towards BEGV, so PT may be now
4775 in the scroll margin at the bottom. */
4776 move_it_to (&it
, PT
, -1,
4777 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4778 MOVE_TO_POS
| MOVE_TO_Y
);
4780 /* Save our position, in case it's correct. */
4781 charpos
= IT_CHARPOS (it
);
4782 bytepos
= IT_BYTEPOS (it
);
4784 /* See if point is on a partially visible line at the end. */
4785 if (it
.what
== IT_EOB
)
4786 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4789 move_it_by_lines (&it
, 1, 1);
4790 partial_p
= it
.current_y
> it
.last_visible_y
;
4793 if (charpos
== PT
&& !partial_p
)
4794 /* We found PT before we found the display margin, so PT is ok. */
4796 else if (preserve_y
>= 0)
4798 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4799 start_display (&it
, w
, start
);
4800 #if 0 /* It's wrong to subtract this here
4801 because we called start_display again
4802 and did not alter it.current_y this time. */
4804 /* If we have a header line, take account of it. */
4805 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4806 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4809 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4810 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4815 /* The last line was only partially visible, so back up two
4816 lines to make sure we're on a fully visible line. */
4818 move_it_by_lines (&it
, -2, 0);
4819 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4822 /* No, the position we saved is OK, so use it. */
4823 SET_PT_BOTH (charpos
, bytepos
);
4829 /* Implementation of window_scroll that works based on screen lines.
4830 See the comment of window_scroll for parameter descriptions. */
4833 window_scroll_line_based (window
, n
, whole
, noerror
)
4839 register struct window
*w
= XWINDOW (window
);
4840 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4841 register int pos
, pos_byte
;
4842 register int ht
= window_internal_height (w
);
4843 register Lisp_Object tem
;
4847 struct position posit
;
4850 /* If scrolling screen-fulls, compute the number of lines to
4851 scroll from the window's height. */
4853 n
*= max (1, ht
- next_screen_context_lines
);
4855 startpos
= marker_position (w
->start
);
4857 posit
= *compute_motion (startpos
, 0, 0, 0,
4859 -1, XINT (w
->hscroll
),
4861 original_vpos
= posit
.vpos
;
4863 XSETFASTINT (tem
, PT
);
4864 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4868 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4873 lose
= n
< 0 && PT
== BEGV
;
4874 Fvertical_motion (make_number (n
), window
);
4878 SET_PT_BOTH (opoint
, opoint_byte
);
4885 Fsignal (Qbeginning_of_buffer
, Qnil
);
4890 int this_scroll_margin
= scroll_margin
;
4892 /* Don't use a scroll margin that is negative or too large. */
4893 if (this_scroll_margin
< 0)
4894 this_scroll_margin
= 0;
4896 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
4897 this_scroll_margin
= XINT (w
->total_lines
) / 4;
4899 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4900 w
->start_at_line_beg
= bolp
;
4901 w
->update_mode_line
= Qt
;
4902 XSETFASTINT (w
->last_modified
, 0);
4903 XSETFASTINT (w
->last_overlay_modified
, 0);
4904 /* Set force_start so that redisplay_window will run
4905 the window-scroll-functions. */
4906 w
->force_start
= Qt
;
4908 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4910 SET_PT_BOTH (pos
, pos_byte
);
4911 Fvertical_motion (make_number (original_vpos
), window
);
4913 /* If we scrolled forward, put point enough lines down
4914 that it is outside the scroll margin. */
4919 if (this_scroll_margin
> 0)
4921 SET_PT_BOTH (pos
, pos_byte
);
4922 Fvertical_motion (make_number (this_scroll_margin
), window
);
4928 if (top_margin
<= opoint
)
4929 SET_PT_BOTH (opoint
, opoint_byte
);
4930 else if (!NILP (Vscroll_preserve_screen_position
))
4932 SET_PT_BOTH (pos
, pos_byte
);
4933 Fvertical_motion (make_number (original_vpos
), window
);
4936 SET_PT (top_margin
);
4942 /* If we scrolled backward, put point near the end of the window
4943 but not within the scroll margin. */
4944 SET_PT_BOTH (pos
, pos_byte
);
4945 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4946 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4949 bottom_margin
= PT
+ 1;
4951 if (bottom_margin
> opoint
)
4952 SET_PT_BOTH (opoint
, opoint_byte
);
4955 if (!NILP (Vscroll_preserve_screen_position
))
4957 SET_PT_BOTH (pos
, pos_byte
);
4958 Fvertical_motion (make_number (original_vpos
), window
);
4961 Fvertical_motion (make_number (-1), window
);
4970 Fsignal (Qend_of_buffer
, Qnil
);
4975 /* Scroll selected_window up or down. If N is nil, scroll a
4976 screen-full which is defined as the height of the window minus
4977 next_screen_context_lines. If N is the symbol `-', scroll.
4978 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4979 up. This is the guts of Fscroll_up and Fscroll_down. */
4982 scroll_command (n
, direction
)
4986 int count
= SPECPDL_INDEX ();
4988 xassert (abs (direction
) == 1);
4990 /* If selected window's buffer isn't current, make it current for
4991 the moment. But don't screw up if window_scroll gets an error. */
4992 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4994 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4995 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4997 /* Make redisplay consider other windows than just selected_window. */
4998 ++windows_or_buffers_changed
;
5002 window_scroll (selected_window
, direction
, 1, 0);
5003 else if (EQ (n
, Qminus
))
5004 window_scroll (selected_window
, -direction
, 1, 0);
5007 n
= Fprefix_numeric_value (n
);
5008 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5011 unbind_to (count
, Qnil
);
5014 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5015 doc
: /* Scroll text of current window upward ARG lines.
5016 If ARG is omitted or nil, scroll upward by a near full screen.
5017 A near full screen is `next-screen-context-lines' less than a full screen.
5018 Negative ARG means scroll downward.
5019 If ARG is the atom `-', scroll downward by nearly full screen.
5020 When calling from a program, supply as argument a number, nil, or `-'. */)
5024 scroll_command (arg
, 1);
5028 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5029 doc
: /* Scroll text of current window down ARG lines.
5030 If ARG is omitted or nil, scroll down by a near full screen.
5031 A near full screen is `next-screen-context-lines' less than a full screen.
5032 Negative ARG means scroll upward.
5033 If ARG is the atom `-', scroll upward by nearly full screen.
5034 When calling from a program, supply as argument a number, nil, or `-'. */)
5038 scroll_command (arg
, -1);
5042 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5043 doc
: /* Return the other window for \"other window scroll\" commands.
5044 If `other-window-scroll-buffer' is non-nil, a window
5045 showing that buffer is used.
5046 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5047 specifies the window. This takes precedence over
5048 `other-window-scroll-buffer'. */)
5053 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5054 && !NILP (Vminibuf_scroll_window
))
5055 window
= Vminibuf_scroll_window
;
5056 /* If buffer is specified, scroll that buffer. */
5057 else if (!NILP (Vother_window_scroll_buffer
))
5059 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5061 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5065 /* Nothing specified; look for a neighboring window on the same
5067 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5069 if (EQ (window
, selected_window
))
5070 /* That didn't get us anywhere; look for a window on another
5073 window
= Fnext_window (window
, Qnil
, Qt
);
5074 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5075 && ! EQ (window
, selected_window
));
5078 CHECK_LIVE_WINDOW (window
);
5080 if (EQ (window
, selected_window
))
5081 error ("There is no other window");
5086 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5087 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5088 A near full screen is `next-screen-context-lines' less than a full screen.
5089 The next window is the one below the current one; or the one at the top
5090 if the current one is at the bottom. Negative ARG means scroll downward.
5091 If ARG is the atom `-', scroll downward by nearly full screen.
5092 When calling from a program, supply as argument a number, nil, or `-'.
5094 If `other-window-scroll-buffer' is non-nil, scroll the window
5095 showing that buffer, popping the buffer up if necessary.
5096 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5097 specifies the window to scroll. This takes precedence over
5098 `other-window-scroll-buffer'. */)
5104 int count
= SPECPDL_INDEX ();
5106 window
= Fother_window_for_scrolling ();
5107 w
= XWINDOW (window
);
5109 /* Don't screw up if window_scroll gets an error. */
5110 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5111 ++windows_or_buffers_changed
;
5113 Fset_buffer (w
->buffer
);
5114 SET_PT (marker_position (w
->pointm
));
5117 window_scroll (window
, 1, 1, 1);
5118 else if (EQ (arg
, Qminus
))
5119 window_scroll (window
, -1, 1, 1);
5125 window_scroll (window
, XINT (arg
), 0, 1);
5128 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5129 unbind_to (count
, Qnil
);
5134 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5135 doc
: /* Scroll selected window display ARG columns left.
5136 Default for ARG is window width minus 2.
5137 Value is the total amount of leftward horizontal scrolling in
5138 effect after the change.
5139 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5140 lower bound for automatic scrolling, i.e. automatic scrolling
5141 will not scroll a window to a column less than the value returned
5142 by this function. This happens in an interactive call. */)
5144 register Lisp_Object arg
, set_minimum
;
5148 struct window
*w
= XWINDOW (selected_window
);
5151 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5153 arg
= Fprefix_numeric_value (arg
);
5155 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5156 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5158 if (!NILP (set_minimum
))
5159 w
->min_hscroll
= w
->hscroll
;
5164 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5165 doc
: /* Scroll selected window display ARG columns right.
5166 Default for ARG is window width minus 2.
5167 Value is the total amount of leftward horizontal scrolling in
5168 effect after the change.
5169 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5170 lower bound for automatic scrolling, i.e. automatic scrolling
5171 will not scroll a window to a column less than the value returned
5172 by this function. This happens in an interactive call. */)
5174 register Lisp_Object arg
, set_minimum
;
5178 struct window
*w
= XWINDOW (selected_window
);
5181 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5183 arg
= Fprefix_numeric_value (arg
);
5185 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5186 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5188 if (!NILP (set_minimum
))
5189 w
->min_hscroll
= w
->hscroll
;
5194 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5195 doc
: /* Return the window which was selected when entering the minibuffer.
5196 Returns nil, if current window is not a minibuffer window. */)
5199 if (minibuf_level
> 0
5200 && MINI_WINDOW_P (XWINDOW (selected_window
))
5201 && WINDOW_LIVE_P (minibuf_selected_window
))
5202 return minibuf_selected_window
;
5207 /* Value is the number of lines actually displayed in window W,
5208 as opposed to its height. */
5211 displayed_window_lines (w
)
5215 struct text_pos start
;
5216 int height
= window_box_height (w
);
5217 struct buffer
*old_buffer
;
5220 if (XBUFFER (w
->buffer
) != current_buffer
)
5222 old_buffer
= current_buffer
;
5223 set_buffer_internal (XBUFFER (w
->buffer
));
5228 /* In case W->start is out of the accessible range, do something
5229 reasonable. This happens in Info mode when Info-scroll-down
5230 calls (recenter -1) while W->start is 1. */
5231 if (XMARKER (w
->start
)->charpos
< BEGV
)
5232 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5233 else if (XMARKER (w
->start
)->charpos
> ZV
)
5234 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5236 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5238 start_display (&it
, w
, start
);
5239 move_it_vertically (&it
, height
);
5240 bottom_y
= line_bottom_y (&it
);
5242 /* rms: On a non-window display,
5243 the value of it.vpos at the bottom of the screen
5244 seems to be 1 larger than window_box_height (w).
5245 This kludge fixes a bug whereby (move-to-window-line -1)
5246 when ZV is on the last screen line
5247 moves to the previous screen line instead of the last one. */
5248 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5251 /* Add in empty lines at the bottom of the window. */
5252 if (bottom_y
< height
)
5254 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5255 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5259 set_buffer_internal (old_buffer
);
5265 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5266 doc
: /* Center point in window and redisplay frame.
5267 With prefix argument ARG, recenter putting point on screen line ARG
5268 relative to the current window. If ARG is negative, it counts up from the
5269 bottom of the window. (ARG should be less than the height of the window.)
5271 If ARG is omitted or nil, erase the entire frame and then
5272 redraw with point in the center of the current window.
5273 Just C-u as prefix means put point in the center of the window
5274 and redisplay normally--don't erase and redraw the frame. */)
5276 register Lisp_Object arg
;
5278 struct window
*w
= XWINDOW (selected_window
);
5279 struct buffer
*buf
= XBUFFER (w
->buffer
);
5280 struct buffer
*obuf
= current_buffer
;
5282 int charpos
, bytepos
;
5284 /* If redisplay is suppressed due to an error, try again. */
5285 obuf
->display_error_modiff
= 0;
5291 /* Invalidate pixel data calculated for all compositions. */
5292 for (i
= 0; i
< n_compositions
; i
++)
5293 composition_table
[i
]->font
= NULL
;
5295 Fredraw_frame (w
->frame
);
5296 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5299 else if (CONSP (arg
)) /* Just C-u. */
5303 arg
= Fprefix_numeric_value (arg
);
5307 set_buffer_internal (buf
);
5309 /* Handle centering on a graphical frame specially. Such frames can
5310 have variable-height lines and centering point on the basis of
5311 line counts would lead to strange effects. */
5312 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5319 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5320 start_display (&it
, w
, pt
);
5321 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5322 charpos
= IT_CHARPOS (it
);
5323 bytepos
= IT_BYTEPOS (it
);
5325 else if (XINT (arg
) < 0)
5329 int nlines
= - XINT (arg
);
5330 int extra_line_spacing
;
5331 int h
= window_box_height (w
);
5333 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5334 start_display (&it
, w
, pt
);
5336 /* Be sure we have the exact height of the full line containing PT. */
5337 move_it_by_lines (&it
, 0, 1);
5339 /* The amount of pixels we have to move back is the window
5340 height minus what's displayed in the line containing PT,
5341 and the lines below. */
5344 move_it_by_lines (&it
, nlines
, 1);
5346 if (it
.vpos
== nlines
)
5350 /* Last line has no newline */
5351 h
-= line_bottom_y (&it
);
5355 /* Don't reserve space for extra line spacing of last line. */
5356 extra_line_spacing
= it
.max_extra_line_spacing
;
5358 /* If we can't move down NLINES lines because we hit
5359 the end of the buffer, count in some empty lines. */
5360 if (it
.vpos
< nlines
)
5363 extra_line_spacing
= it
.extra_line_spacing
;
5364 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5369 /* Now find the new top line (starting position) of the window. */
5370 start_display (&it
, w
, pt
);
5372 move_it_vertically_backward (&it
, h
);
5374 /* If extra line spacing is present, we may move too far
5375 back. This causes the last line to be only partially
5376 visible (which triggers redisplay to recenter that line
5377 in the middle), so move forward.
5378 But ignore extra line spacing on last line, as it is not
5379 considered to be part of the visible height of the line.
5381 h
+= extra_line_spacing
;
5382 while (-it
.current_y
> h
)
5383 move_it_by_lines (&it
, 1, 1);
5385 charpos
= IT_CHARPOS (it
);
5386 bytepos
= IT_BYTEPOS (it
);
5390 struct position pos
;
5391 pos
= *vmotion (PT
, - XINT (arg
), w
);
5392 charpos
= pos
.bufpos
;
5393 bytepos
= pos
.bytepos
;
5398 struct position pos
;
5399 int ht
= window_internal_height (w
);
5402 arg
= make_number (ht
/ 2);
5403 else if (XINT (arg
) < 0)
5404 arg
= make_number (XINT (arg
) + ht
);
5406 pos
= *vmotion (PT
, - XINT (arg
), w
);
5407 charpos
= pos
.bufpos
;
5408 bytepos
= pos
.bytepos
;
5411 /* Set the new window start. */
5412 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5413 w
->window_end_valid
= Qnil
;
5415 w
->optional_new_start
= Qt
;
5417 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5418 w
->start_at_line_beg
= Qt
;
5420 w
->start_at_line_beg
= Qnil
;
5422 set_buffer_internal (obuf
);
5427 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5429 doc
: /* Return the height in lines of the text display area of WINDOW.
5430 This doesn't include the mode-line (or header-line if any) or any
5431 partial-height lines in the text display area. */)
5435 struct window
*w
= decode_window (window
);
5436 int pixel_height
= window_box_height (w
);
5437 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5438 return make_number (line_height
);
5443 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5445 doc
: /* Position point relative to window.
5446 With no argument, position point at center of window.
5447 An argument specifies vertical position within the window;
5448 zero means top of window, negative means relative to bottom of window. */)
5452 struct window
*w
= XWINDOW (selected_window
);
5456 window
= selected_window
;
5457 start
= marker_position (w
->start
);
5458 if (start
< BEGV
|| start
> ZV
)
5460 int height
= window_internal_height (w
);
5461 Fvertical_motion (make_number (- (height
/ 2)), window
);
5462 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5463 w
->start_at_line_beg
= Fbolp ();
5464 w
->force_start
= Qt
;
5467 Fgoto_char (w
->start
);
5469 lines
= displayed_window_lines (w
);
5471 XSETFASTINT (arg
, lines
/ 2);
5474 arg
= Fprefix_numeric_value (arg
);
5476 XSETINT (arg
, XINT (arg
) + lines
);
5479 /* Skip past a partially visible first line. */
5481 XSETINT (arg
, XINT (arg
) + 1);
5483 return Fvertical_motion (arg
, window
);
5488 /***********************************************************************
5489 Window Configuration
5490 ***********************************************************************/
5492 struct save_window_data
5494 EMACS_INT size_from_Lisp_Vector_struct
;
5495 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5496 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5497 Lisp_Object frame_tool_bar_lines
;
5498 Lisp_Object selected_frame
;
5499 Lisp_Object current_window
;
5500 Lisp_Object current_buffer
;
5501 Lisp_Object minibuf_scroll_window
;
5502 Lisp_Object minibuf_selected_window
;
5503 Lisp_Object root_window
;
5504 Lisp_Object focus_frame
;
5505 /* Record the values of window-min-width and window-min-height
5506 so that window sizes remain consistent with them. */
5507 Lisp_Object min_width
, min_height
;
5508 /* A vector, each of whose elements is a struct saved_window
5510 Lisp_Object saved_windows
;
5513 /* This is saved as a Lisp_Vector */
5516 /* these first two must agree with struct Lisp_Vector in lisp.h */
5517 EMACS_INT size_from_Lisp_Vector_struct
;
5518 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5521 Lisp_Object buffer
, start
, pointm
, mark
;
5522 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5523 Lisp_Object hscroll
, min_hscroll
;
5524 Lisp_Object parent
, prev
;
5525 Lisp_Object start_at_line_beg
;
5526 Lisp_Object display_table
;
5527 Lisp_Object orig_top_line
, orig_total_lines
;
5528 Lisp_Object left_margin_cols
, right_margin_cols
;
5529 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5530 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5533 #define SAVED_WINDOW_VECTOR_SIZE 24 /* Arg to Fmake_vector */
5535 #define SAVED_WINDOW_N(swv,n) \
5536 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5538 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5539 doc
: /* Return t if OBJECT is a window-configuration object. */)
5543 if (WINDOW_CONFIGURATIONP (object
))
5548 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5549 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5553 register struct save_window_data
*data
;
5554 struct Lisp_Vector
*saved_windows
;
5556 if (! WINDOW_CONFIGURATIONP (config
))
5557 wrong_type_argument (Qwindow_configuration_p
, config
);
5559 data
= (struct save_window_data
*) XVECTOR (config
);
5560 saved_windows
= XVECTOR (data
->saved_windows
);
5561 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5564 DEFUN ("set-window-configuration", Fset_window_configuration
,
5565 Sset_window_configuration
, 1, 1, 0,
5566 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5567 CONFIGURATION must be a value previously returned
5568 by `current-window-configuration' (which see).
5569 If CONFIGURATION was made from a frame that is now deleted,
5570 only frame-independent values can be restored. In this case,
5571 the return value is nil. Otherwise the value is t. */)
5573 Lisp_Object configuration
;
5575 register struct save_window_data
*data
;
5576 struct Lisp_Vector
*saved_windows
;
5577 Lisp_Object new_current_buffer
;
5582 while (!WINDOW_CONFIGURATIONP (configuration
))
5583 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5585 data
= (struct save_window_data
*) XVECTOR (configuration
);
5586 saved_windows
= XVECTOR (data
->saved_windows
);
5588 new_current_buffer
= data
->current_buffer
;
5589 if (NILP (XBUFFER (new_current_buffer
)->name
))
5590 new_current_buffer
= Qnil
;
5593 if (XBUFFER (new_current_buffer
) == current_buffer
)
5596 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5599 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5602 /* If f is a dead frame, don't bother rebuilding its window tree.
5603 However, there is other stuff we should still try to do below. */
5604 if (FRAME_LIVE_P (f
))
5606 register struct window
*w
;
5607 register struct saved_window
*p
;
5608 struct window
*root_window
;
5609 struct window
**leaf_windows
;
5613 /* If the frame has been resized since this window configuration was
5614 made, we change the frame to the size specified in the
5615 configuration, restore the configuration, and then resize it
5616 back. We keep track of the prevailing height in these variables. */
5617 int previous_frame_lines
= FRAME_LINES (f
);
5618 int previous_frame_cols
= FRAME_COLS (f
);
5619 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5620 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5622 /* The mouse highlighting code could get screwed up
5623 if it runs during this. */
5626 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5627 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5628 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5629 XFASTINT (data
->frame_cols
), 0, 0, 0);
5630 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5631 if (XFASTINT (data
->frame_menu_bar_lines
)
5632 != previous_frame_menu_bar_lines
)
5633 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5634 #ifdef HAVE_WINDOW_SYSTEM
5635 if (XFASTINT (data
->frame_tool_bar_lines
)
5636 != previous_frame_tool_bar_lines
)
5637 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5641 /* "Swap out" point from the selected window
5642 into its buffer. We do this now, before
5643 restoring the window contents, and prevent it from
5644 being done later on when we select a new window. */
5645 if (! NILP (XWINDOW (selected_window
)->buffer
))
5647 w
= XWINDOW (selected_window
);
5648 set_marker_both (w
->pointm
,
5650 BUF_PT (XBUFFER (w
->buffer
)),
5651 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5654 windows_or_buffers_changed
++;
5655 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5657 /* Problem: Freeing all matrices and later allocating them again
5658 is a serious redisplay flickering problem. What we would
5659 really like to do is to free only those matrices not reused
5661 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5663 = (struct window
**) alloca (count_windows (root_window
)
5664 * sizeof (struct window
*));
5665 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5667 /* Temporarily avoid any problems with windows that are smaller
5668 than they are supposed to be. */
5669 window_min_height
= 1;
5670 window_min_width
= 1;
5673 Mark all windows now on frame as "deleted".
5674 Restoring the new configuration "undeletes" any that are in it.
5676 Save their current buffers in their height fields, since we may
5677 need it later, if a buffer saved in the configuration is now
5679 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5681 for (k
= 0; k
< saved_windows
->size
; k
++)
5683 p
= SAVED_WINDOW_N (saved_windows
, k
);
5684 w
= XWINDOW (p
->window
);
5687 if (!NILP (p
->parent
))
5688 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5689 XFASTINT (p
->parent
))->window
;
5693 if (!NILP (p
->prev
))
5695 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5696 XFASTINT (p
->prev
))->window
;
5697 XWINDOW (w
->prev
)->next
= p
->window
;
5702 if (!NILP (w
->parent
))
5704 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5706 XWINDOW (w
->parent
)->vchild
= p
->window
;
5707 XWINDOW (w
->parent
)->hchild
= Qnil
;
5711 XWINDOW (w
->parent
)->hchild
= p
->window
;
5712 XWINDOW (w
->parent
)->vchild
= Qnil
;
5717 /* If we squirreled away the buffer in the window's height,
5719 if (BUFFERP (w
->total_lines
))
5720 w
->buffer
= w
->total_lines
;
5721 w
->left_col
= p
->left_col
;
5722 w
->top_line
= p
->top_line
;
5723 w
->total_cols
= p
->total_cols
;
5724 w
->total_lines
= p
->total_lines
;
5725 w
->hscroll
= p
->hscroll
;
5726 w
->min_hscroll
= p
->min_hscroll
;
5727 w
->display_table
= p
->display_table
;
5728 w
->orig_top_line
= p
->orig_top_line
;
5729 w
->orig_total_lines
= p
->orig_total_lines
;
5730 w
->left_margin_cols
= p
->left_margin_cols
;
5731 w
->right_margin_cols
= p
->right_margin_cols
;
5732 w
->left_fringe_width
= p
->left_fringe_width
;
5733 w
->right_fringe_width
= p
->right_fringe_width
;
5734 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5735 w
->scroll_bar_width
= p
->scroll_bar_width
;
5736 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5737 XSETFASTINT (w
->last_modified
, 0);
5738 XSETFASTINT (w
->last_overlay_modified
, 0);
5740 /* Reinstall the saved buffer and pointers into it. */
5741 if (NILP (p
->buffer
))
5742 w
->buffer
= p
->buffer
;
5745 if (!NILP (XBUFFER (p
->buffer
)->name
))
5746 /* If saved buffer is alive, install it. */
5748 w
->buffer
= p
->buffer
;
5749 w
->start_at_line_beg
= p
->start_at_line_beg
;
5750 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5751 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5752 Fset_marker (XBUFFER (w
->buffer
)->mark
,
5753 p
->mark
, w
->buffer
);
5755 /* As documented in Fcurrent_window_configuration, don't
5756 restore the location of point in the buffer which was
5757 current when the window configuration was recorded. */
5758 if (!EQ (p
->buffer
, new_current_buffer
)
5759 && XBUFFER (p
->buffer
) == current_buffer
)
5760 Fgoto_char (w
->pointm
);
5762 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
5763 /* Else unless window has a live buffer, get one. */
5765 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5766 /* This will set the markers to beginning of visible
5768 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5769 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5770 w
->start_at_line_beg
= Qt
;
5773 /* Keeping window's old buffer; make sure the markers
5776 /* Set window markers at start of visible range. */
5777 if (XMARKER (w
->start
)->buffer
== 0)
5778 set_marker_restricted (w
->start
, make_number (0),
5780 if (XMARKER (w
->pointm
)->buffer
== 0)
5781 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5782 BUF_PT (XBUFFER (w
->buffer
)),
5783 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5784 w
->start_at_line_beg
= Qt
;
5789 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5790 /* Prevent "swapping out point" in the old selected window
5791 using the buffer that has been restored into it.
5792 Use the point value from the beginning of this function
5793 since unshow_buffer (called from delete_all_subwindows)
5794 could have altered it. */
5795 selected_window
= Qnil
;
5796 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5797 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5798 make_number (old_point
),
5799 XWINDOW (data
->current_window
)->buffer
);
5801 Fselect_window (data
->current_window
, Qnil
);
5802 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
5805 if (NILP (data
->focus_frame
)
5806 || (FRAMEP (data
->focus_frame
)
5807 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5808 Fredirect_frame_focus (frame
, data
->focus_frame
);
5810 #if 0 /* I don't understand why this is needed, and it causes problems
5811 when the frame's old selected window has been deleted. */
5812 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
5813 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5817 /* Set the screen height to the value it had before this function. */
5818 if (previous_frame_lines
!= FRAME_LINES (f
)
5819 || previous_frame_cols
!= FRAME_COLS (f
))
5820 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5822 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5823 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5824 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5826 #ifdef HAVE_WINDOW_SYSTEM
5827 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5828 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5833 /* Now, free glyph matrices in windows that were not reused. */
5834 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5836 if (NILP (leaf_windows
[i
]->buffer
))
5838 /* Assert it's not reused as a combination. */
5839 xassert (NILP (leaf_windows
[i
]->hchild
)
5840 && NILP (leaf_windows
[i
]->vchild
));
5841 free_window_matrices (leaf_windows
[i
]);
5843 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5851 /* Fselect_window will have made f the selected frame, so we
5852 reselect the proper frame here. Fhandle_switch_frame will change the
5853 selected window too, but that doesn't make the call to
5854 Fselect_window above totally superfluous; it still sets f's
5856 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5857 do_switch_frame (data
->selected_frame
, 0, 0);
5859 if (! NILP (Vwindow_configuration_change_hook
)
5860 && ! NILP (Vrun_hooks
))
5861 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5864 if (!NILP (new_current_buffer
))
5865 Fset_buffer (new_current_buffer
);
5867 /* Restore the minimum heights recorded in the configuration. */
5868 window_min_height
= XINT (data
->min_height
);
5869 window_min_width
= XINT (data
->min_width
);
5871 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5872 minibuf_selected_window
= data
->minibuf_selected_window
;
5874 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5877 /* Mark all windows now on frame as deleted
5878 by setting their buffers to nil. */
5881 delete_all_subwindows (w
)
5882 register struct window
*w
;
5884 if (!NILP (w
->next
))
5885 delete_all_subwindows (XWINDOW (w
->next
));
5886 if (!NILP (w
->vchild
))
5887 delete_all_subwindows (XWINDOW (w
->vchild
));
5888 if (!NILP (w
->hchild
))
5889 delete_all_subwindows (XWINDOW (w
->hchild
));
5891 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5893 if (!NILP (w
->buffer
))
5896 /* We set all three of these fields to nil, to make sure that we can
5897 distinguish this dead window from any live window. Live leaf
5898 windows will have buffer set, and combination windows will have
5899 vchild or hchild set. */
5904 Vwindow_list
= Qnil
;
5908 count_windows (window
)
5909 register struct window
*window
;
5911 register int count
= 1;
5912 if (!NILP (window
->next
))
5913 count
+= count_windows (XWINDOW (window
->next
));
5914 if (!NILP (window
->vchild
))
5915 count
+= count_windows (XWINDOW (window
->vchild
));
5916 if (!NILP (window
->hchild
))
5917 count
+= count_windows (XWINDOW (window
->hchild
));
5922 /* Fill vector FLAT with leaf windows under W, starting at index I.
5923 Value is last index + 1. */
5926 get_leaf_windows (w
, flat
, i
)
5928 struct window
**flat
;
5933 if (!NILP (w
->hchild
))
5934 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5935 else if (!NILP (w
->vchild
))
5936 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5940 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5947 /* Return a pointer to the glyph W's physical cursor is on. Value is
5948 null if W's current matrix is invalid, so that no meaningfull glyph
5952 get_phys_cursor_glyph (w
)
5955 struct glyph_row
*row
;
5956 struct glyph
*glyph
;
5958 if (w
->phys_cursor
.vpos
>= 0
5959 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5960 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5962 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5963 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5972 save_window_save (window
, vector
, i
)
5974 struct Lisp_Vector
*vector
;
5977 register struct saved_window
*p
;
5978 register struct window
*w
;
5979 register Lisp_Object tem
;
5981 for (;!NILP (window
); window
= w
->next
)
5983 p
= SAVED_WINDOW_N (vector
, i
);
5984 w
= XWINDOW (window
);
5986 XSETFASTINT (w
->temslot
, i
); i
++;
5988 p
->buffer
= w
->buffer
;
5989 p
->left_col
= w
->left_col
;
5990 p
->top_line
= w
->top_line
;
5991 p
->total_cols
= w
->total_cols
;
5992 p
->total_lines
= w
->total_lines
;
5993 p
->hscroll
= w
->hscroll
;
5994 p
->min_hscroll
= w
->min_hscroll
;
5995 p
->display_table
= w
->display_table
;
5996 p
->orig_top_line
= w
->orig_top_line
;
5997 p
->orig_total_lines
= w
->orig_total_lines
;
5998 p
->left_margin_cols
= w
->left_margin_cols
;
5999 p
->right_margin_cols
= w
->right_margin_cols
;
6000 p
->left_fringe_width
= w
->left_fringe_width
;
6001 p
->right_fringe_width
= w
->right_fringe_width
;
6002 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6003 p
->scroll_bar_width
= w
->scroll_bar_width
;
6004 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6005 if (!NILP (w
->buffer
))
6007 /* Save w's value of point in the window configuration.
6008 If w is the selected window, then get the value of point
6009 from the buffer; pointm is garbage in the selected window. */
6010 if (EQ (window
, selected_window
))
6012 p
->pointm
= Fmake_marker ();
6013 set_marker_both (p
->pointm
, w
->buffer
,
6014 BUF_PT (XBUFFER (w
->buffer
)),
6015 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6018 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6020 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6021 p
->start_at_line_beg
= w
->start_at_line_beg
;
6023 tem
= XBUFFER (w
->buffer
)->mark
;
6024 p
->mark
= Fcopy_marker (tem
, Qnil
);
6031 p
->start_at_line_beg
= Qnil
;
6034 if (NILP (w
->parent
))
6037 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6042 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6044 if (!NILP (w
->vchild
))
6045 i
= save_window_save (w
->vchild
, vector
, i
);
6046 if (!NILP (w
->hchild
))
6047 i
= save_window_save (w
->hchild
, vector
, i
);
6053 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6054 Scurrent_window_configuration
, 0, 1, 0,
6055 doc
: /* Return an object representing the current window configuration of FRAME.
6056 If FRAME is nil or omitted, use the selected frame.
6057 This describes the number of windows, their sizes and current buffers,
6058 and for each displayed buffer, where display starts, and the positions of
6059 point and mark. An exception is made for point in the current buffer:
6060 its value is -not- saved.
6061 This also records the currently selected frame, and FRAME's focus
6062 redirection (see `redirect-frame-focus'). */)
6066 register Lisp_Object tem
;
6067 register int n_windows
;
6068 register struct save_window_data
*data
;
6069 register struct Lisp_Vector
*vec
;
6074 frame
= selected_frame
;
6075 CHECK_LIVE_FRAME (frame
);
6078 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6079 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6080 data
= (struct save_window_data
*)vec
;
6082 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6083 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6084 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6085 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6086 data
->selected_frame
= selected_frame
;
6087 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6088 XSETBUFFER (data
->current_buffer
, current_buffer
);
6089 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6090 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6091 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6092 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6093 XSETINT (data
->min_height
, window_min_height
);
6094 XSETINT (data
->min_width
, window_min_width
);
6095 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6096 data
->saved_windows
= tem
;
6097 for (i
= 0; i
< n_windows
; i
++)
6098 XVECTOR (tem
)->contents
[i
]
6099 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
6100 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6101 XSETWINDOW_CONFIGURATION (tem
, data
);
6105 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6107 doc
: /* Execute BODY, preserving window sizes and contents.
6108 Return the value of the last form in BODY.
6109 Restore which buffer appears in which window, where display starts,
6110 and the value of point and mark for each window.
6111 Also restore the choice of selected window.
6112 Also restore which buffer is current.
6113 Does not restore the value of point in current buffer.
6114 usage: (save-window-excursion BODY ...) */)
6118 register Lisp_Object val
;
6119 register int count
= SPECPDL_INDEX ();
6121 record_unwind_protect (Fset_window_configuration
,
6122 Fcurrent_window_configuration (Qnil
));
6123 val
= Fprogn (args
);
6124 return unbind_to (count
, val
);
6128 /***********************************************************************
6130 ***********************************************************************/
6132 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6134 doc
: /* Set width of marginal areas of window WINDOW.
6135 If WINDOW is nil, set margins of the currently selected window.
6136 Second arg LEFT-WIDTH specifies the number of character cells to
6137 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6138 does the same for the right marginal area. A nil width parameter
6139 means no margin. */)
6140 (window
, left
, right
)
6141 Lisp_Object window
, left
, right
;
6143 struct window
*w
= decode_window (window
);
6145 /* Translate negative or zero widths to nil.
6146 Margins that are too wide have to be checked elsewhere. */
6150 CHECK_NUMBER (left
);
6151 if (XINT (left
) <= 0)
6157 CHECK_NUMBER (right
);
6158 if (XINT (right
) <= 0)
6162 if (!EQ (w
->left_margin_cols
, left
)
6163 || !EQ (w
->right_margin_cols
, right
))
6165 w
->left_margin_cols
= left
;
6166 w
->right_margin_cols
= right
;
6168 adjust_window_margins (w
);
6170 ++windows_or_buffers_changed
;
6171 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6178 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6180 doc
: /* Get width of marginal areas of window WINDOW.
6181 If WINDOW is omitted or nil, use the currently selected window.
6182 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6183 If a marginal area does not exist, its width will be returned
6188 struct window
*w
= decode_window (window
);
6189 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6194 /***********************************************************************
6196 ***********************************************************************/
6198 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6200 doc
: /* Set the fringe widths of window WINDOW.
6201 If WINDOW is nil, set the fringe widths of the currently selected
6203 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6204 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6205 fringe width. If a fringe width arg is nil, that means to use the
6206 frame's default fringe width. Default fringe widths can be set with
6207 the command `set-fringe-style'.
6208 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6209 outside of the display margins. By default, fringes are drawn between
6210 display marginal areas and the text area. */)
6211 (window
, left
, right
, outside_margins
)
6212 Lisp_Object window
, left
, right
, outside_margins
;
6214 struct window
*w
= decode_window (window
);
6217 CHECK_NATNUM (left
);
6219 CHECK_NATNUM (right
);
6221 if (!EQ (w
->left_fringe_width
, left
)
6222 || !EQ (w
->right_fringe_width
, right
)
6223 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6225 w
->left_fringe_width
= left
;
6226 w
->right_fringe_width
= right
;
6227 w
->fringes_outside_margins
= outside_margins
;
6229 adjust_window_margins (w
);
6231 clear_glyph_matrix (w
->current_matrix
);
6232 w
->window_end_valid
= Qnil
;
6234 ++windows_or_buffers_changed
;
6235 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6242 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6244 doc
: /* Get width of fringes of window WINDOW.
6245 If WINDOW is omitted or nil, use the currently selected window.
6246 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6250 struct window
*w
= decode_window (window
);
6251 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6252 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6253 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6254 Qt
: Qnil
), Qnil
)));
6259 /***********************************************************************
6261 ***********************************************************************/
6263 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6265 doc
: /* Set width and type of scroll bars of window WINDOW.
6266 If window is nil, set scroll bars of the currently selected window.
6267 Second parameter WIDTH specifies the pixel width for the scroll bar;
6268 this is automatically adjusted to a multiple of the frame column width.
6269 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6270 bar: left, right, or nil.
6271 If WIDTH is nil, use the frame's scroll-bar width.
6272 If TYPE is t, use the frame's scroll-bar type. */)
6273 (window
, width
, vertical_type
, horizontal_type
)
6274 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6276 struct window
*w
= decode_window (window
);
6280 CHECK_NATNUM (width
);
6282 if (XINT (width
) == 0)
6283 vertical_type
= Qnil
;
6286 if (!(EQ (vertical_type
, Qnil
)
6287 || EQ (vertical_type
, Qleft
)
6288 || EQ (vertical_type
, Qright
)
6289 || EQ (vertical_type
, Qt
)))
6290 error ("Invalid type of vertical scroll bar");
6292 if (!EQ (w
->scroll_bar_width
, width
)
6293 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6295 w
->scroll_bar_width
= width
;
6296 w
->vertical_scroll_bar_type
= vertical_type
;
6298 adjust_window_margins (w
);
6300 clear_glyph_matrix (w
->current_matrix
);
6301 w
->window_end_valid
= Qnil
;
6303 ++windows_or_buffers_changed
;
6304 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6311 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6313 doc
: /* Get width and type of scroll bars of window WINDOW.
6314 If WINDOW is omitted or nil, use the currently selected window.
6315 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6316 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6321 struct window
*w
= decode_window (window
);
6322 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6323 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6324 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6325 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6326 Fcons (w
->vertical_scroll_bar_type
,
6327 Fcons (Qnil
, Qnil
))));
6332 /***********************************************************************
6334 ***********************************************************************/
6336 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6337 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6338 Use the selected window if WINDOW is nil or omitted.
6339 Normally, value is a multiple of the canonical character height of WINDOW;
6340 optional second arg PIXELS_P means value is measured in pixels. */)
6342 Lisp_Object window
, pixels_p
;
6349 window
= selected_window
;
6351 CHECK_WINDOW (window
);
6352 w
= XWINDOW (window
);
6353 f
= XFRAME (w
->frame
);
6355 if (FRAME_WINDOW_P (f
))
6356 result
= (NILP (pixels_p
)
6357 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6358 : make_number (-w
->vscroll
));
6360 result
= make_number (0);
6365 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6367 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6368 WINDOW nil means use the selected window. Normally, VSCROLL is a
6369 non-negative multiple of the canonical character height of WINDOW;
6370 optional third arg PIXELS_P non-nil means that VSCROLL is in pixels.
6371 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6372 corresponds to an integral number of pixels. The return value is the
6373 result of this rounding.
6374 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6375 (window
, vscroll
, pixels_p
)
6376 Lisp_Object window
, vscroll
, pixels_p
;
6382 window
= selected_window
;
6384 CHECK_WINDOW (window
);
6385 CHECK_NUMBER_OR_FLOAT (vscroll
);
6387 w
= XWINDOW (window
);
6388 f
= XFRAME (w
->frame
);
6390 if (FRAME_WINDOW_P (f
))
6392 int old_dy
= w
->vscroll
;
6394 w
->vscroll
= - (NILP (pixels_p
)
6395 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6396 : XFLOATINT (vscroll
));
6397 w
->vscroll
= min (w
->vscroll
, 0);
6399 if (w
->vscroll
!= old_dy
)
6401 /* Adjust glyph matrix of the frame if the virtual display
6402 area becomes larger than before. */
6403 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6406 /* Prevent redisplay shortcuts. */
6407 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6411 return Fwindow_vscroll (window
, pixels_p
);
6415 /* Call FN for all leaf windows on frame F. FN is called with the
6416 first argument being a pointer to the leaf window, and with
6417 additional argument USER_DATA. Stops when FN returns 0. */
6420 foreach_window (f
, fn
, user_data
)
6422 int (* fn
) P_ ((struct window
*, void *));
6425 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6429 /* Helper function for foreach_window. Call FN for all leaf windows
6430 reachable from W. FN is called with the first argument being a
6431 pointer to the leaf window, and with additional argument USER_DATA.
6432 Stop when FN returns 0. Value is 0 if stopped by FN. */
6435 foreach_window_1 (w
, fn
, user_data
)
6437 int (* fn
) P_ ((struct window
*, void *));
6442 for (cont
= 1; w
&& cont
;)
6444 if (!NILP (w
->hchild
))
6445 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6446 else if (!NILP (w
->vchild
))
6447 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6449 cont
= fn (w
, user_data
);
6451 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6458 /* Freeze or unfreeze the window start of W unless it is a
6459 mini-window or the selected window. FREEZE_P non-null means freeze
6460 the window start. */
6463 freeze_window_start (w
, freeze_p
)
6467 if (w
== XWINDOW (selected_window
)
6468 || MINI_WINDOW_P (w
)
6469 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6470 && ! NILP (Vminibuf_scroll_window
)
6471 && w
== XWINDOW (Vminibuf_scroll_window
)))
6474 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6479 /* Freeze or unfreeze the window starts of all leaf windows on frame
6480 F, except the selected window and a mini-window. FREEZE_P non-zero
6481 means freeze the window start. */
6484 freeze_window_starts (f
, freeze_p
)
6488 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6492 /***********************************************************************
6494 ***********************************************************************/
6496 /* Return 1 if window configurations C1 and C2
6497 describe the same state of affairs. This is used by Fequal. */
6500 compare_window_configurations (c1
, c2
, ignore_positions
)
6502 int ignore_positions
;
6504 register struct save_window_data
*d1
, *d2
;
6505 struct Lisp_Vector
*sw1
, *sw2
;
6508 if (!WINDOW_CONFIGURATIONP (c1
))
6509 wrong_type_argument (Qwindow_configuration_p
, c1
);
6510 if (!WINDOW_CONFIGURATIONP (c2
))
6511 wrong_type_argument (Qwindow_configuration_p
, c2
);
6513 d1
= (struct save_window_data
*) XVECTOR (c1
);
6514 d2
= (struct save_window_data
*) XVECTOR (c2
);
6515 sw1
= XVECTOR (d1
->saved_windows
);
6516 sw2
= XVECTOR (d2
->saved_windows
);
6518 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6520 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6522 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6524 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6526 /* Don't compare the current_window field directly.
6527 Instead see w1_is_current and w2_is_current, below. */
6528 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6530 if (! ignore_positions
)
6532 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6534 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6537 /* Don't compare the root_window field.
6538 We don't require the two configurations
6539 to use the same window object,
6540 and the two root windows must be equivalent
6541 if everything else compares equal. */
6542 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6544 if (! EQ (d1
->min_width
, d2
->min_width
))
6546 if (! EQ (d1
->min_height
, d2
->min_height
))
6549 /* Verify that the two confis have the same number of windows. */
6550 if (sw1
->size
!= sw2
->size
)
6553 for (i
= 0; i
< sw1
->size
; i
++)
6555 struct saved_window
*p1
, *p2
;
6556 int w1_is_current
, w2_is_current
;
6558 p1
= SAVED_WINDOW_N (sw1
, i
);
6559 p2
= SAVED_WINDOW_N (sw2
, i
);
6561 /* Verify that the current windows in the two
6562 configurations correspond to each other. */
6563 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6564 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6566 if (w1_is_current
!= w2_is_current
)
6569 /* Verify that the corresponding windows do match. */
6570 if (! EQ (p1
->buffer
, p2
->buffer
))
6572 if (! EQ (p1
->left_col
, p2
->left_col
))
6574 if (! EQ (p1
->top_line
, p2
->top_line
))
6576 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6578 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6580 if (! EQ (p1
->display_table
, p2
->display_table
))
6582 if (! EQ (p1
->parent
, p2
->parent
))
6584 if (! EQ (p1
->prev
, p2
->prev
))
6586 if (! ignore_positions
)
6588 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6590 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6592 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6594 if (NILP (Fequal (p1
->start
, p2
->start
)))
6596 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6598 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6601 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6603 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6605 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6607 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6609 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6611 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6613 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6620 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6621 Scompare_window_configurations
, 2, 2, 0,
6622 doc
: /* Compare two window configurations as regards the structure of windows.
6623 This function ignores details such as the values of point and mark
6624 and scrolling positions. */)
6628 if (compare_window_configurations (x
, y
, 1))
6636 struct frame
*f
= make_initial_frame ();
6637 XSETFRAME (selected_frame
, f
);
6638 Vterminal_frame
= selected_frame
;
6639 minibuf_window
= f
->minibuffer_window
;
6640 selected_window
= f
->selected_window
;
6641 last_nonminibuf_frame
= f
;
6643 window_initialized
= 1;
6649 Vwindow_list
= Qnil
;
6655 Qwindow_size_fixed
= intern ("window-size-fixed");
6656 staticpro (&Qwindow_size_fixed
);
6658 staticpro (&Qwindow_configuration_change_hook
);
6659 Qwindow_configuration_change_hook
6660 = intern ("window-configuration-change-hook");
6662 Qwindowp
= intern ("windowp");
6663 staticpro (&Qwindowp
);
6665 Qwindow_configuration_p
= intern ("window-configuration-p");
6666 staticpro (&Qwindow_configuration_p
);
6668 Qwindow_live_p
= intern ("window-live-p");
6669 staticpro (&Qwindow_live_p
);
6671 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
6672 staticpro (&Qtemp_buffer_show_hook
);
6674 staticpro (&Vwindow_list
);
6676 minibuf_selected_window
= Qnil
;
6677 staticpro (&minibuf_selected_window
);
6679 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
6680 doc
: /* Non-nil means call as function to display a help buffer.
6681 The function is called with one argument, the buffer to be displayed.
6682 Used by `with-output-to-temp-buffer'.
6683 If this function is used, then it must do the entire job of showing
6684 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6685 Vtemp_buffer_show_function
= Qnil
;
6687 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
6688 doc
: /* If non-nil, function to call to handle `display-buffer'.
6689 It will receive two args, the buffer and a flag which if non-nil means
6690 that the currently selected window is not acceptable.
6691 It should choose or create a window, display the specified buffer in it,
6692 and return the window.
6693 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
6694 work using this function. */);
6695 Vdisplay_buffer_function
= Qnil
;
6697 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
6698 doc
: /* *If non-nil, `display-buffer' should even the window heights.
6699 If nil, `display-buffer' will leave the window configuration alone. */);
6700 Veven_window_heights
= Qt
;
6702 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
6703 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6704 Vminibuf_scroll_window
= Qnil
;
6706 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
6707 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6708 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6709 is displayed in the `mode-line' face. */);
6710 mode_line_in_non_selected_windows
= 1;
6712 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
6713 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6714 Vother_window_scroll_buffer
= Qnil
;
6716 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
6717 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
6720 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
6721 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6722 auto_window_vscroll_p
= 1;
6724 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
6725 doc
: /* *Non-nil means `display-buffer' should reuse frames.
6726 If the buffer in question is already displayed in a frame, raise that frame. */);
6727 display_buffer_reuse_frames
= 0;
6729 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
6730 doc
: /* Function to call to handle automatic new frame creation.
6731 It is called with no arguments and should return a newly created frame.
6733 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
6734 where `pop-up-frame-alist' would hold the default frame parameters. */);
6735 Vpop_up_frame_function
= Qnil
;
6737 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
6738 doc
: /* *List of buffer names that should have their own special frames.
6739 Displaying a buffer whose name is in this list makes a special frame for it
6740 using `special-display-function'. See also `special-display-regexps'.
6742 An element of the list can be a list instead of just a string.
6743 There are two ways to use a list as an element:
6744 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
6745 In the first case, the FRAME-PARAMETERS are pairs of the form
6746 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6747 In the second case, FUNCTION is called with BUFFER as the first argument,
6748 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
6749 All this is done by the function found in `special-display-function'.
6751 If the specified frame parameters include (same-buffer . t), the
6752 buffer is displayed in the currently selected window. Otherwise, if
6753 they include (same-frame . t), the buffer is displayed in a new window
6754 in the currently selected frame.
6756 If this variable appears \"not to work\", because you add a name to it
6757 but that buffer still appears in the selected window, look at the
6758 values of `same-window-buffer-names' and `same-window-regexps'.
6759 Those variables take precedence over this one. */);
6760 Vspecial_display_buffer_names
= Qnil
;
6762 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
6763 doc
: /* *List of regexps saying which buffers should have their own special frames.
6764 If a buffer name matches one of these regexps, it gets its own frame.
6765 Displaying a buffer whose name is in this list makes a special frame for it
6766 using `special-display-function'.
6768 An element of the list can be a list instead of just a string.
6769 There are two ways to use a list as an element:
6770 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
6771 In the first case, the FRAME-PARAMETERS are pairs of the form
6772 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6773 In the second case, FUNCTION is called with BUFFER as the first argument,
6774 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
6775 All this is done by the function found in `special-display-function'.
6777 If the specified frame parameters include (same-buffer . t), the
6778 buffer is displayed in the currently selected window. Otherwise, if
6779 they include (same-frame . t), the buffer is displayed in a new window
6780 in the currently selected frame.
6782 If this variable appears \"not to work\", because you add a regexp to it
6783 but the matching buffers still appear in the selected window, look at the
6784 values of `same-window-buffer-names' and `same-window-regexps'.
6785 Those variables take precedence over this one. */);
6786 Vspecial_display_regexps
= Qnil
;
6788 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
6789 doc
: /* Function to call to make a new frame for a special buffer.
6790 It is called with two arguments, the buffer and optional buffer specific
6791 data, and should return a window displaying that buffer.
6792 The default value normally makes a separate frame for the buffer,
6793 using `special-display-frame-alist' to specify the frame parameters.
6794 But if the buffer specific data includes (same-buffer . t) then the
6795 buffer is displayed in the current selected window.
6796 Otherwise if it includes (same-frame . t) then the buffer is displayed in
6797 a new window in the currently selected frame.
6799 A buffer is special if it is listed in `special-display-buffer-names'
6800 or matches a regexp in `special-display-regexps'. */);
6801 Vspecial_display_function
= Qnil
;
6803 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
6804 doc
: /* *List of buffer names that should appear in the selected window.
6805 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
6806 switches to it in the selected window, rather than making it appear
6807 in some other window.
6809 An element of the list can be a cons cell instead of just a string.
6810 Then the car must be a string, which specifies the buffer name.
6811 This is for compatibility with `special-display-buffer-names';
6812 the cdr of the cons cell is ignored.
6814 See also `same-window-regexps'. */);
6815 Vsame_window_buffer_names
= Qnil
;
6817 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
6818 doc
: /* *List of regexps saying which buffers should appear in the selected window.
6819 If a buffer name matches one of these regexps, then displaying it
6820 using `display-buffer' or `pop-to-buffer' switches to it
6821 in the selected window, rather than making it appear in some other window.
6823 An element of the list can be a cons cell instead of just a string.
6824 Then the car must be a string, which specifies the buffer name.
6825 This is for compatibility with `special-display-buffer-names';
6826 the cdr of the cons cell is ignored.
6828 See also `same-window-buffer-names'. */);
6829 Vsame_window_regexps
= Qnil
;
6831 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
6832 doc
: /* *Non-nil means display-buffer should make new windows. */);
6835 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
6836 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
6837 next_screen_context_lines
= 2;
6839 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
6840 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
6841 If there is only one window, it is split regardless of this value. */);
6842 split_height_threshold
= 500;
6844 DEFVAR_INT ("window-min-height", &window_min_height
,
6845 doc
: /* *Delete any window less than this tall (including its mode line). */);
6846 window_min_height
= 4;
6848 DEFVAR_INT ("window-min-width", &window_min_width
,
6849 doc
: /* *Delete any window less than this wide. */);
6850 window_min_width
= 10;
6852 DEFVAR_LISP ("scroll-preserve-screen-position",
6853 &Vscroll_preserve_screen_position
,
6854 doc
: /* *Non-nil means scroll commands move point to keep its screen line unchanged.
6855 This is only when it is impossible to keep point fixed and still
6856 scroll as specified. */);
6857 Vscroll_preserve_screen_position
= Qnil
;
6859 DEFVAR_LISP ("window-configuration-change-hook",
6860 &Vwindow_configuration_change_hook
,
6861 doc
: /* Functions to call when window configuration changes.
6862 The selected frame is the one whose configuration has changed. */);
6863 Vwindow_configuration_change_hook
= Qnil
;
6865 DEFVAR_BOOL ("window-size-fixed", &window_size_fixed
,
6866 doc
: /* Non-nil in a buffer means windows displaying the buffer are fixed-size.
6867 If the value is`height', then only the window's height is fixed.
6868 If the value is `width', then only the window's width is fixed.
6869 Any other non-nil value fixes both the width and the height.
6870 Emacs won't change the size of any window displaying that buffer,
6871 unless you explicitly change the size, or Emacs has no other choice. */);
6872 Fmake_variable_buffer_local (Qwindow_size_fixed
);
6873 window_size_fixed
= 0;
6875 defsubr (&Sselected_window
);
6876 defsubr (&Sminibuffer_window
);
6877 defsubr (&Swindow_minibuffer_p
);
6878 defsubr (&Swindowp
);
6879 defsubr (&Swindow_live_p
);
6880 defsubr (&Spos_visible_in_window_p
);
6881 defsubr (&Swindow_buffer
);
6882 defsubr (&Swindow_height
);
6883 defsubr (&Swindow_width
);
6884 defsubr (&Swindow_hscroll
);
6885 defsubr (&Sset_window_hscroll
);
6886 defsubr (&Swindow_redisplay_end_trigger
);
6887 defsubr (&Sset_window_redisplay_end_trigger
);
6888 defsubr (&Swindow_edges
);
6889 defsubr (&Swindow_pixel_edges
);
6890 defsubr (&Swindow_inside_edges
);
6891 defsubr (&Swindow_inside_pixel_edges
);
6892 defsubr (&Scoordinates_in_window_p
);
6893 defsubr (&Swindow_at
);
6894 defsubr (&Swindow_point
);
6895 defsubr (&Swindow_start
);
6896 defsubr (&Swindow_end
);
6897 defsubr (&Sset_window_point
);
6898 defsubr (&Sset_window_start
);
6899 defsubr (&Swindow_dedicated_p
);
6900 defsubr (&Sset_window_dedicated_p
);
6901 defsubr (&Swindow_display_table
);
6902 defsubr (&Sset_window_display_table
);
6903 defsubr (&Snext_window
);
6904 defsubr (&Sprevious_window
);
6905 defsubr (&Sother_window
);
6906 defsubr (&Sget_lru_window
);
6907 defsubr (&Sget_largest_window
);
6908 defsubr (&Sget_buffer_window
);
6909 defsubr (&Sdelete_other_windows
);
6910 defsubr (&Sdelete_windows_on
);
6911 defsubr (&Sreplace_buffer_in_windows
);
6912 defsubr (&Sdelete_window
);
6913 defsubr (&Sset_window_buffer
);
6914 defsubr (&Sselect_window
);
6915 defsubr (&Sspecial_display_p
);
6916 defsubr (&Ssame_window_p
);
6917 defsubr (&Sdisplay_buffer
);
6918 defsubr (&Sforce_window_update
);
6919 defsubr (&Ssplit_window
);
6920 defsubr (&Senlarge_window
);
6921 defsubr (&Sshrink_window
);
6922 defsubr (&Sscroll_up
);
6923 defsubr (&Sscroll_down
);
6924 defsubr (&Sscroll_left
);
6925 defsubr (&Sscroll_right
);
6926 defsubr (&Sother_window_for_scrolling
);
6927 defsubr (&Sscroll_other_window
);
6928 defsubr (&Sminibuffer_selected_window
);
6929 defsubr (&Srecenter
);
6930 defsubr (&Swindow_text_height
);
6931 defsubr (&Smove_to_window_line
);
6932 defsubr (&Swindow_configuration_p
);
6933 defsubr (&Swindow_configuration_frame
);
6934 defsubr (&Sset_window_configuration
);
6935 defsubr (&Scurrent_window_configuration
);
6936 defsubr (&Ssave_window_excursion
);
6937 defsubr (&Sset_window_margins
);
6938 defsubr (&Swindow_margins
);
6939 defsubr (&Sset_window_fringes
);
6940 defsubr (&Swindow_fringes
);
6941 defsubr (&Sset_window_scroll_bars
);
6942 defsubr (&Swindow_scroll_bars
);
6943 defsubr (&Swindow_vscroll
);
6944 defsubr (&Sset_window_vscroll
);
6945 defsubr (&Scompare_window_configurations
);
6946 defsubr (&Swindow_list
);
6952 initial_define_key (control_x_map
, '1', "delete-other-windows");
6953 initial_define_key (control_x_map
, '2', "split-window");
6954 initial_define_key (control_x_map
, '0', "delete-window");
6955 initial_define_key (control_x_map
, 'o', "other-window");
6956 initial_define_key (control_x_map
, '^', "enlarge-window");
6957 initial_define_key (control_x_map
, '<', "scroll-left");
6958 initial_define_key (control_x_map
, '>', "scroll-right");
6960 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
6961 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6962 initial_define_key (meta_map
, 'v', "scroll-down");
6964 initial_define_key (global_map
, Ctl('L'), "recenter");
6965 initial_define_key (meta_map
, 'r', "move-to-window-line");
6968 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
6969 (do not change this comment) */