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 to use mode-line-inactive face in all windows but the
130 selected-window and the minibuffer-scroll-window when the
131 minibuffer is active. */
132 int mode_line_in_non_selected_windows
;
134 /* If a window gets smaller than either of these, it is removed. */
136 EMACS_INT window_min_height
;
137 EMACS_INT window_min_width
;
139 /* Nonzero implies Fdisplay_buffer should create windows. */
143 /* Nonzero implies make new frames for Fdisplay_buffer. */
147 /* Nonzero means reuse existing frames for displaying buffers. */
149 int display_buffer_reuse_frames
;
151 /* Non-nil means use this function instead of default */
153 Lisp_Object Vpop_up_frame_function
;
155 /* Function to call to handle Fdisplay_buffer. */
157 Lisp_Object Vdisplay_buffer_function
;
159 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
161 Lisp_Object Veven_window_heights
;
163 /* List of buffer *names* for buffers that should have their own frames. */
165 Lisp_Object Vspecial_display_buffer_names
;
167 /* List of regexps for buffer names that should have their own frames. */
169 Lisp_Object Vspecial_display_regexps
;
171 /* Function to pop up a special frame. */
173 Lisp_Object Vspecial_display_function
;
175 /* List of buffer *names* for buffers to appear in selected window. */
177 Lisp_Object Vsame_window_buffer_names
;
179 /* List of regexps for buffer names to appear in selected window. */
181 Lisp_Object Vsame_window_regexps
;
183 /* Hook run at end of temp_output_buffer_show. */
185 Lisp_Object Qtemp_buffer_show_hook
;
187 /* Fdisplay_buffer always splits the largest window
188 if that window is more than this high. */
190 EMACS_INT split_height_threshold
;
192 /* Number of lines of continuity in scrolling by screenfuls. */
194 EMACS_INT next_screen_context_lines
;
196 /* Incremented for each window created. */
198 static int sequence_number
;
200 /* Nonzero after init_window_once has finished. */
202 static int window_initialized
;
204 /* Hook to run when window config changes. */
206 Lisp_Object Qwindow_configuration_change_hook
;
207 Lisp_Object Vwindow_configuration_change_hook
;
209 /* Nonzero means scroll commands try to put point
210 at the same screen height as previously. */
212 Lisp_Object Vscroll_preserve_screen_position
;
214 #if 0 /* This isn't used anywhere. */
215 /* Nonzero means we can split a frame even if it is "unsplittable". */
216 static int inhibit_frame_unsplittable
;
219 extern EMACS_INT scroll_margin
;
221 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
223 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
224 doc
: /* Returns t if OBJECT is a window. */)
228 return WINDOWP (object
) ? Qt
: Qnil
;
231 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
232 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
236 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
243 register struct window
*p
;
245 p
= allocate_window ();
246 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
247 XSETFASTINT (p
->left_col
, 0);
248 XSETFASTINT (p
->top_line
, 0);
249 XSETFASTINT (p
->total_lines
, 0);
250 XSETFASTINT (p
->total_cols
, 0);
251 XSETFASTINT (p
->hscroll
, 0);
252 XSETFASTINT (p
->min_hscroll
, 0);
253 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
254 p
->start
= Fmake_marker ();
255 p
->pointm
= Fmake_marker ();
256 XSETFASTINT (p
->use_time
, 0);
258 p
->display_table
= Qnil
;
260 p
->pseudo_window_p
= 0;
261 bzero (&p
->cursor
, sizeof (p
->cursor
));
262 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
263 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
264 p
->desired_matrix
= p
->current_matrix
= 0;
265 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
266 p
->phys_cursor_type
= -1;
267 p
->phys_cursor_width
= -1;
268 p
->must_be_updated_p
= 0;
269 XSETFASTINT (p
->window_end_vpos
, 0);
270 XSETFASTINT (p
->window_end_pos
, 0);
271 p
->window_end_valid
= Qnil
;
274 XSETFASTINT (p
->last_point
, 0);
275 p
->frozen_window_start_p
= 0;
276 p
->height_fixed_p
= 0;
277 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
278 p
->left_margin_cols
= Qnil
;
279 p
->right_margin_cols
= Qnil
;
280 p
->left_fringe_width
= Qnil
;
281 p
->right_fringe_width
= Qnil
;
282 p
->fringes_outside_margins
= Qnil
;
283 p
->scroll_bar_width
= Qnil
;
284 p
->vertical_scroll_bar_type
= Qt
;
285 p
->overlay_arrow_bitmap
= 0;
291 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
292 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
295 return selected_window
;
298 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
299 doc
: /* Return the window used now for minibuffers.
300 If the optional argument FRAME is specified, return the minibuffer window
301 used by that frame. */)
306 frame
= selected_frame
;
307 CHECK_LIVE_FRAME (frame
);
308 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
311 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
312 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
313 WINDOW defaults to the selected window. */)
317 struct window
*w
= decode_window (window
);
318 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
322 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
323 Spos_visible_in_window_p
, 0, 3, 0,
324 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
325 Return nil if that position is scrolled vertically out of view.
326 If a character is only partially visible, nil is returned, unless the
327 optional argument PARTIALLY is non-nil.
328 If POS is only out of view because of horizontal scrolling, return non-nil.
329 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
331 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
332 return value is a list (X Y FULLY) where X and Y are the pixel coordinates
333 relative to the top left corner of the window, and FULLY is t if the
334 character after POS is fully visible and nil otherwise. */)
335 (pos
, window
, partially
)
336 Lisp_Object pos
, window
, partially
;
338 register struct window
*w
;
340 register struct buffer
*buf
;
342 Lisp_Object in_window
= Qnil
;
346 w
= decode_window (window
);
347 buf
= XBUFFER (w
->buffer
);
348 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
352 CHECK_NUMBER_COERCE_MARKER (pos
);
355 else if (w
== XWINDOW (selected_window
))
358 posint
= XMARKER (w
->pointm
)->charpos
;
360 /* If position is above window start or outside buffer boundaries,
361 or if window start is out of range, position is not visible. */
362 if (posint
>= CHARPOS (top
)
363 && posint
<= BUF_ZV (buf
)
364 && CHARPOS (top
) >= BUF_BEGV (buf
)
365 && CHARPOS (top
) <= BUF_ZV (buf
)
366 && pos_visible_p (w
, posint
, &fully_p
, &x
, &y
, NILP (partially
))
367 && (!NILP (partially
) || fully_p
))
370 if (!NILP (in_window
) && !NILP (partially
))
371 in_window
= Fcons (make_number (x
),
372 Fcons (make_number (y
),
373 Fcons (fully_p
? Qt
: Qnil
, Qnil
)));
378 static struct window
*
379 decode_window (window
)
380 register Lisp_Object window
;
383 return XWINDOW (selected_window
);
385 CHECK_LIVE_WINDOW (window
);
386 return XWINDOW (window
);
389 static struct window
*
390 decode_any_window (window
)
391 register Lisp_Object window
;
394 return XWINDOW (selected_window
);
396 CHECK_WINDOW (window
);
397 return XWINDOW (window
);
400 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
401 doc
: /* Return the buffer that WINDOW is displaying.
402 WINDOW defaults to the selected window. */)
406 return decode_window (window
)->buffer
;
409 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
410 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
414 return decode_any_window (window
)->total_lines
;
417 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
418 doc
: /* Return the number of display columns in WINDOW.
419 This is the width that is usable columns available for text in WINDOW.
420 If you want to find out how many columns WINDOW takes up,
421 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
425 return make_number (window_box_text_cols (decode_any_window (window
)));
428 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
429 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
433 return decode_window (window
)->hscroll
;
436 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
437 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
438 Return NCOL. NCOL should be zero or positive.
440 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
441 window so that the location of point becomes invisible. */)
443 Lisp_Object window
, ncol
;
445 struct window
*w
= decode_window (window
);
449 hscroll
= max (0, XINT (ncol
));
451 /* Prevent redisplay shortcuts when changing the hscroll. */
452 if (XINT (w
->hscroll
) != hscroll
)
453 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
455 w
->hscroll
= make_number (hscroll
);
459 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
460 Swindow_redisplay_end_trigger
, 0, 1, 0,
461 doc
: /* Return WINDOW's redisplay end trigger value.
462 See `set-window-redisplay-end-trigger' for more information. */)
466 return decode_window (window
)->redisplay_end_trigger
;
469 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
470 Sset_window_redisplay_end_trigger
, 2, 2, 0,
471 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
472 VALUE should be a buffer position (typically a marker) or nil.
473 If it is a buffer position, then if redisplay in WINDOW reaches a position
474 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
475 with two arguments: WINDOW, and the end trigger value.
476 Afterwards the end-trigger value is reset to nil. */)
478 register Lisp_Object window
, value
;
480 register struct window
*w
;
482 w
= decode_window (window
);
483 w
->redisplay_end_trigger
= value
;
487 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
488 doc
: /* Return a list of the edge coordinates of WINDOW.
489 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
490 RIGHT is one more than the rightmost column occupied by WINDOW,
491 and BOTTOM is one more than the bottommost row occupied by WINDOW.
492 The edges include the space used by the window's scroll bar,
493 display margins, fringes, header line, and mode line, if it has them.
494 To get the edges of the actual text area, use `window-inside-edges'. */)
498 register struct window
*w
= decode_any_window (window
);
500 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
501 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
502 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
503 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
507 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
508 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
509 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
510 RIGHT is one more than the rightmost x position occupied by WINDOW,
511 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
512 The pixel edges include the space used by the window's scroll bar,
513 display margins, fringes, header line, and mode line, if it has them.
514 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
518 register struct window
*w
= decode_any_window (window
);
520 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
521 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
522 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
523 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
527 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
528 doc
: /* Return a list of the edge coordinates of WINDOW.
529 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
530 RIGHT is one more than the rightmost column used by text in WINDOW,
531 and BOTTOM is one more than the bottommost row used by text in WINDOW.
532 The inside edges do not include the space used by the window's scroll bar,
533 display margins, fringes, header line, and/or mode line. */)
537 register struct window
*w
= decode_any_window (window
);
539 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
540 + WINDOW_LEFT_MARGIN_COLS (w
)
541 + WINDOW_LEFT_FRINGE_COLS (w
)),
542 make_number (WINDOW_TOP_EDGE_LINE (w
)
543 + WINDOW_HEADER_LINE_LINES (w
)),
544 make_number (WINDOW_RIGHT_EDGE_COL (w
)
545 - WINDOW_RIGHT_MARGIN_COLS (w
)
546 - WINDOW_RIGHT_FRINGE_COLS (w
)),
547 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
548 - WINDOW_MODE_LINE_LINES (w
)));
551 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
552 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
553 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
554 RIGHT is one more than the rightmost x position used by text in WINDOW,
555 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
556 The inside edges do not include the space used by the window's scroll bar,
557 display margins, fringes, header line, and/or mode line. */)
561 register struct window
*w
= decode_any_window (window
);
563 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
564 + WINDOW_LEFT_MARGIN_WIDTH (w
)
565 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
566 make_number (WINDOW_TOP_EDGE_Y (w
)
567 + WINDOW_HEADER_LINE_HEIGHT (w
)),
568 make_number (WINDOW_RIGHT_EDGE_X (w
)
569 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
570 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
571 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
572 - WINDOW_MODE_LINE_HEIGHT (w
)));
575 /* Test if the character at column *X, row *Y is within window W.
576 If it is not, return ON_NOTHING;
577 if it is in the window's text area,
578 set *x and *y to its location relative to the upper left corner
581 if it is on the window's modeline, return ON_MODE_LINE;
582 if it is on the border between the window and its right sibling,
583 return ON_VERTICAL_BORDER.
584 if it is on a scroll bar,
585 return ON_SCROLL_BAR.
586 if it is on the window's top line, return ON_HEADER_LINE;
587 if it is in left or right fringe of the window,
588 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
589 to window-relative coordinates;
590 if it is in the marginal area to the left/right of the window,
591 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
592 to window-relative coordinates.
594 X and Y are frame relative pixel coordinates. */
596 static enum window_part
597 coordinates_in_window (w
, x
, y
)
598 register struct window
*w
;
601 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
602 int left_x
, right_x
, top_y
, bottom_y
;
603 enum window_part part
;
604 int ux
= FRAME_COLUMN_WIDTH (f
);
605 int x0
= WINDOW_LEFT_EDGE_X (w
);
606 int x1
= WINDOW_RIGHT_EDGE_X (w
);
607 /* The width of the area where the vertical line can be dragged.
608 (Between mode lines for instance. */
609 int grabbable_width
= ux
;
610 int lmargin_width
, rmargin_width
, text_left
, text_right
;
612 if (*x
< x0
|| *x
>= x1
)
615 /* In what's below, we subtract 1 when computing right_x because we
616 want the rightmost pixel, which is given by left_pixel+width-1. */
617 if (w
->pseudo_window_p
)
620 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
621 top_y
= WINDOW_TOP_EDGE_Y (w
);
622 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
626 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
627 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
628 top_y
= WINDOW_TOP_EDGE_Y (w
);
629 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
632 /* Outside any interesting row? */
633 if (*y
< top_y
|| *y
>= bottom_y
)
636 /* On the mode line or header line? If it's near the start of
637 the mode or header line of window that's has a horizontal
638 sibling, say it's on the vertical line. That's to be able
639 to resize windows horizontally in case we're using toolkit
642 if (WINDOW_WANTS_MODELINE_P (w
)
643 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
647 header_vertical_border_check
:
648 /* We're somewhere on the mode line. We consider the place
649 between mode lines of horizontally adjacent mode lines
650 as the vertical border. If scroll bars on the left,
651 return the right window. */
652 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
653 || WINDOW_RIGHTMOST_P (w
))
655 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
656 return ON_VERTICAL_BORDER
;
660 if (abs (*x
- x1
) < grabbable_width
)
661 return ON_VERTICAL_BORDER
;
664 /* Convert X and Y to window relative coordinates.
665 Mode line starts at left edge of window. */
671 if (WINDOW_WANTS_HEADER_LINE_P (w
)
672 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
674 part
= ON_HEADER_LINE
;
675 goto header_vertical_border_check
;
678 /* Outside any interesting column? */
679 if (*x
< left_x
|| *x
> right_x
)
680 return ON_SCROLL_BAR
;
682 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
683 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
685 text_left
= window_box_left (w
, TEXT_AREA
);
686 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
688 if (FRAME_WINDOW_P (f
))
690 if (!w
->pseudo_window_p
691 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
692 && !WINDOW_RIGHTMOST_P (w
)
693 && (abs (*x
- right_x
) < grabbable_width
))
694 return ON_VERTICAL_BORDER
;
698 /* Need to say "*x > right_x" rather than >=, since on character
699 terminals, the vertical line's x coordinate is right_x. */
700 if (!w
->pseudo_window_p
701 && !WINDOW_RIGHTMOST_P (w
)
702 && *x
> right_x
- ux
)
704 /* On the border on the right side of the window? Assume that
705 this area begins at RIGHT_X minus a canonical char width. */
706 return ON_VERTICAL_BORDER
;
712 if (lmargin_width
> 0
713 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
714 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
715 : (*x
< left_x
+ lmargin_width
)))
718 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
719 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
721 return ON_LEFT_MARGIN
;
724 /* Convert X and Y to window-relative pixel coordinates. */
727 return ON_LEFT_FRINGE
;
730 if (*x
>= text_right
)
732 if (rmargin_width
> 0
733 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
734 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
735 : (*x
>= right_x
- rmargin_width
)))
738 if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
739 *x
-= WINDOW_RIGHT_FRINGE_WIDTH (w
);
741 return ON_RIGHT_MARGIN
;
744 /* Convert X and Y to window-relative pixel coordinates. */
745 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
747 return ON_RIGHT_FRINGE
;
750 /* Everything special ruled out - must be on text area */
751 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
757 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
758 Scoordinates_in_window_p
, 2, 2, 0,
759 doc
: /* Return non-nil if COORDINATES are in WINDOW.
760 COORDINATES is a cons of the form (X . Y), X and Y being distances
761 measured in characters from the upper-left corner of the frame.
762 \(0 . 0) denotes the character in the upper left corner of the
764 If COORDINATES are in the text portion of WINDOW,
765 the coordinates relative to the window are returned.
766 If they are in the mode line of WINDOW, `mode-line' is returned.
767 If they are in the top mode line of WINDOW, `header-line' is returned.
768 If they are in the left fringe of WINDOW, `left-fringe' is returned.
769 If they are in the right fringe of WINDOW, `right-fringe' is returned.
770 If they are on the border between WINDOW and its right sibling,
771 `vertical-line' is returned.
772 If they are in the windows's left or right marginal areas, `left-margin'\n\
773 or `right-margin' is returned. */)
774 (coordinates
, window
)
775 register Lisp_Object coordinates
, window
;
782 CHECK_WINDOW (window
);
783 w
= XWINDOW (window
);
784 f
= XFRAME (w
->frame
);
785 CHECK_CONS (coordinates
);
786 lx
= Fcar (coordinates
);
787 ly
= Fcdr (coordinates
);
788 CHECK_NUMBER_OR_FLOAT (lx
);
789 CHECK_NUMBER_OR_FLOAT (ly
);
790 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
791 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
793 switch (coordinates_in_window (w
, &x
, &y
))
799 /* X and Y are now window relative pixel coordinates. Convert
800 them to canonical char units before returning them. */
801 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
802 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
807 case ON_VERTICAL_BORDER
:
808 return Qvertical_line
;
816 case ON_RIGHT_FRINGE
:
817 return Qright_fringe
;
822 case ON_RIGHT_MARGIN
:
823 return Qright_margin
;
826 /* Historically we are supposed to return nil in this case. */
835 /* Callback for foreach_window, used in window_from_coordinates.
836 Check if window W contains coordinates specified by USER_DATA which
837 is actually a pointer to a struct check_window_data CW.
839 Check if window W contains coordinates *CW->x and *CW->y. If it
840 does, return W in *CW->window, as Lisp_Object, and return in
841 *CW->part the part of the window under coordinates *X,*Y. Return
842 zero from this function to stop iterating over windows. */
844 struct check_window_data
848 enum window_part
*part
;
852 check_window_containing (w
, user_data
)
856 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
857 enum window_part found
;
860 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
861 if (found
!= ON_NOTHING
)
864 XSETWINDOW (*cw
->window
, w
);
872 /* Find the window containing frame-relative pixel position X/Y and
873 return it as a Lisp_Object.
875 If X, Y is on one of the window's special `window_part' elements,
876 set *PART to the id of that element, and return X and Y converted
877 to window relative coordinates in WX and WY.
879 If there is no window under X, Y return nil and leave *PART
880 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
882 This function was previously implemented with a loop cycling over
883 windows with Fnext_window, and starting with the frame's selected
884 window. It turned out that this doesn't work with an
885 implementation of next_window using Vwindow_list, because
886 FRAME_SELECTED_WINDOW (F) is not always contained in the window
887 tree of F when this function is called asynchronously from
888 note_mouse_highlight. The original loop didn't terminate in this
892 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
895 enum window_part
*part
;
900 struct check_window_data cw
;
901 enum window_part dummy
;
907 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
908 foreach_window (f
, check_window_containing
, &cw
);
910 /* If not found above, see if it's in the tool bar window, if a tool
914 && WINDOWP (f
->tool_bar_window
)
915 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
916 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
920 window
= f
->tool_bar_window
;
929 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
930 doc
: /* Return window containing coordinates X and Y on FRAME.
931 If omitted, FRAME defaults to the currently selected frame.
932 The top left corner of the frame is considered to be row 0,
935 Lisp_Object x
, y
, frame
;
940 frame
= selected_frame
;
941 CHECK_LIVE_FRAME (frame
);
944 /* Check that arguments are integers or floats. */
945 CHECK_NUMBER_OR_FLOAT (x
);
946 CHECK_NUMBER_OR_FLOAT (y
);
948 return window_from_coordinates (f
,
949 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
950 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
951 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
952 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
956 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
957 doc
: /* Return current value of point in WINDOW.
958 For a nonselected window, this is the value point would have
959 if that window were selected.
961 Note that, when WINDOW is the selected window and its buffer
962 is also currently selected, the value returned is the same as (point).
963 It would be more strictly correct to return the `top-level' value
964 of point, outside of any save-excursion forms.
965 But that is hard to define. */)
969 register struct window
*w
= decode_window (window
);
971 if (w
== XWINDOW (selected_window
)
972 && current_buffer
== XBUFFER (w
->buffer
))
974 return Fmarker_position (w
->pointm
);
977 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
978 doc
: /* Return position at which display currently starts in WINDOW.
979 This is updated by redisplay or by calling `set-window-start'. */)
983 return Fmarker_position (decode_window (window
)->start
);
986 /* This is text temporarily removed from the doc string below.
988 This function returns nil if the position is not currently known.
989 That happens when redisplay is preempted and doesn't finish.
990 If in that case you want to compute where the end of the window would
991 have been if redisplay had finished, do this:
993 (goto-char (window-start window))
994 (vertical-motion (1- (window-height window)) window)
997 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
998 doc
: /* Return position at which display currently ends in WINDOW.
999 This is updated by redisplay, when it runs to completion.
1000 Simply changing the buffer text or setting `window-start'
1001 does not update this value.
1002 Return nil if there is no recorded value. \(This can happen if the
1003 last redisplay of WINDOW was preempted, and did not finish.)
1004 If UPDATE is non-nil, compute the up-to-date position
1005 if it isn't already recorded. */)
1007 Lisp_Object window
, update
;
1010 struct window
*w
= decode_window (window
);
1016 #if 0 /* This change broke some things. We should make it later. */
1017 /* If we don't know the end position, return nil.
1018 The user can compute it with vertical-motion if he wants to.
1019 It would be nicer to do it automatically,
1020 but that's so slow that it would probably bother people. */
1021 if (NILP (w
->window_end_valid
))
1026 && ! (! NILP (w
->window_end_valid
)
1027 && XFASTINT (w
->last_modified
) >= MODIFF
))
1029 struct text_pos startp
;
1031 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1033 /* In case W->start is out of the range, use something
1034 reasonable. This situation occurred when loading a file with
1035 `-l' containing a call to `rmail' with subsequent other
1036 commands. At the end, W->start happened to be BEG, while
1037 rmail had already narrowed the buffer. */
1038 if (XMARKER (w
->start
)->charpos
< BEGV
)
1039 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1040 else if (XMARKER (w
->start
)->charpos
> ZV
)
1041 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1043 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1045 /* Cannot use Fvertical_motion because that function doesn't
1046 cope with variable-height lines. */
1047 if (b
!= current_buffer
)
1049 old_buffer
= current_buffer
;
1050 set_buffer_internal (b
);
1053 start_display (&it
, w
, startp
);
1054 move_it_vertically (&it
, window_box_height (w
));
1055 if (it
.current_y
< it
.last_visible_y
)
1056 move_it_past_eol (&it
);
1057 value
= make_number (IT_CHARPOS (it
));
1060 set_buffer_internal (old_buffer
);
1063 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1068 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1069 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1072 Lisp_Object window
, pos
;
1074 register struct window
*w
= decode_window (window
);
1076 CHECK_NUMBER_COERCE_MARKER (pos
);
1077 if (w
== XWINDOW (selected_window
)
1078 && XBUFFER (w
->buffer
) == current_buffer
)
1081 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1083 /* We have to make sure that redisplay updates the window to show
1084 the new value of point. */
1085 if (!EQ (window
, selected_window
))
1086 ++windows_or_buffers_changed
;
1091 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1092 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1094 Optional third arg NOFORCE non-nil inhibits next redisplay
1095 from overriding motion of point in order to display at this exact start. */)
1096 (window
, pos
, noforce
)
1097 Lisp_Object window
, pos
, noforce
;
1099 register struct window
*w
= decode_window (window
);
1101 CHECK_NUMBER_COERCE_MARKER (pos
);
1102 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1103 /* this is not right, but much easier than doing what is right. */
1104 w
->start_at_line_beg
= Qnil
;
1106 w
->force_start
= Qt
;
1107 w
->update_mode_line
= Qt
;
1108 XSETFASTINT (w
->last_modified
, 0);
1109 XSETFASTINT (w
->last_overlay_modified
, 0);
1110 if (!EQ (window
, selected_window
))
1111 windows_or_buffers_changed
++;
1116 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1118 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1119 See also `set-window-dedicated-p'. */)
1123 return decode_window (window
)->dedicated
;
1126 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1127 Sset_window_dedicated_p
, 2, 2, 0,
1128 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1129 If it is dedicated, Emacs will not automatically change
1130 which buffer appears in it.
1131 The second argument is the new value for the dedication flag;
1132 non-nil means yes. */)
1134 Lisp_Object window
, arg
;
1136 register struct window
*w
= decode_window (window
);
1140 return w
->dedicated
;
1143 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1145 doc
: /* Return the display-table that WINDOW is using. */)
1149 return decode_window (window
)->display_table
;
1152 /* Get the display table for use on window W. This is either W's
1153 display table or W's buffer's display table. Ignore the specified
1154 tables if they are not valid; if no valid table is specified,
1157 struct Lisp_Char_Table
*
1158 window_display_table (w
)
1161 struct Lisp_Char_Table
*dp
= NULL
;
1163 if (DISP_TABLE_P (w
->display_table
))
1164 dp
= XCHAR_TABLE (w
->display_table
);
1165 else if (BUFFERP (w
->buffer
))
1167 struct buffer
*b
= XBUFFER (w
->buffer
);
1169 if (DISP_TABLE_P (b
->display_table
))
1170 dp
= XCHAR_TABLE (b
->display_table
);
1171 else if (DISP_TABLE_P (Vstandard_display_table
))
1172 dp
= XCHAR_TABLE (Vstandard_display_table
);
1178 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1179 doc
: /* Set WINDOW's display-table to TABLE. */)
1181 register Lisp_Object window
, table
;
1183 register struct window
*w
;
1185 w
= decode_window (window
);
1186 w
->display_table
= table
;
1190 /* Record info on buffer window w is displaying
1191 when it is about to cease to display that buffer. */
1194 register struct window
*w
;
1201 if (b
!= XMARKER (w
->pointm
)->buffer
)
1205 if (w
== XWINDOW (selected_window
)
1206 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1207 /* Do this except when the selected window's buffer
1208 is being removed from some other window. */
1210 /* last_window_start records the start position that this buffer
1211 had in the last window to be disconnected from it.
1212 Now that this statement is unconditional,
1213 it is possible for the buffer to be displayed in the
1214 selected window, while last_window_start reflects another
1215 window which was recently showing the same buffer.
1216 Some people might say that might be a good thing. Let's see. */
1217 b
->last_window_start
= marker_position (w
->start
);
1219 /* Point in the selected window's buffer
1220 is actually stored in that buffer, and the window's pointm isn't used.
1221 So don't clobber point in that buffer. */
1222 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1223 /* This line helps to fix Horsley's testbug.el bug. */
1224 && !(WINDOWP (b
->last_selected_window
)
1225 && w
!= XWINDOW (b
->last_selected_window
)
1226 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1227 temp_set_point_both (b
,
1228 clip_to_bounds (BUF_BEGV (b
),
1229 XMARKER (w
->pointm
)->charpos
,
1231 clip_to_bounds (BUF_BEGV_BYTE (b
),
1232 marker_byte_position (w
->pointm
),
1235 if (WINDOWP (b
->last_selected_window
)
1236 && w
== XWINDOW (b
->last_selected_window
))
1237 b
->last_selected_window
= Qnil
;
1240 /* Put replacement into the window structure in place of old. */
1242 replace_window (old
, replacement
)
1243 Lisp_Object old
, replacement
;
1245 register Lisp_Object tem
;
1246 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1248 /* If OLD is its frame's root_window, then replacement is the new
1249 root_window for that frame. */
1251 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1252 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1254 p
->left_col
= o
->left_col
;
1255 p
->top_line
= o
->top_line
;
1256 p
->total_cols
= o
->total_cols
;
1257 p
->total_lines
= o
->total_lines
;
1258 p
->desired_matrix
= p
->current_matrix
= 0;
1260 bzero (&p
->cursor
, sizeof (p
->cursor
));
1261 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1262 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1263 p
->phys_cursor_type
= -1;
1264 p
->phys_cursor_width
= -1;
1265 p
->must_be_updated_p
= 0;
1266 p
->pseudo_window_p
= 0;
1267 XSETFASTINT (p
->window_end_vpos
, 0);
1268 XSETFASTINT (p
->window_end_pos
, 0);
1269 p
->window_end_valid
= Qnil
;
1270 p
->frozen_window_start_p
= 0;
1271 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1273 p
->next
= tem
= o
->next
;
1275 XWINDOW (tem
)->prev
= replacement
;
1277 p
->prev
= tem
= o
->prev
;
1279 XWINDOW (tem
)->next
= replacement
;
1281 p
->parent
= tem
= o
->parent
;
1284 if (EQ (XWINDOW (tem
)->vchild
, old
))
1285 XWINDOW (tem
)->vchild
= replacement
;
1286 if (EQ (XWINDOW (tem
)->hchild
, old
))
1287 XWINDOW (tem
)->hchild
= replacement
;
1290 /*** Here, if replacement is a vertical combination
1291 and so is its new parent, we should make replacement's
1292 children be children of that parent instead. ***/
1295 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1296 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1298 register Lisp_Object window
;
1300 delete_window (window
);
1302 if (! NILP (Vwindow_configuration_change_hook
)
1303 && ! NILP (Vrun_hooks
))
1304 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1310 delete_window (window
)
1311 register Lisp_Object window
;
1313 register Lisp_Object tem
, parent
, sib
;
1314 register struct window
*p
;
1315 register struct window
*par
;
1318 /* Because this function is called by other C code on non-leaf
1319 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1320 so we can't decode_window here. */
1322 window
= selected_window
;
1324 CHECK_WINDOW (window
);
1325 p
= XWINDOW (window
);
1327 /* It's okay to delete an already-deleted window. */
1328 if (NILP (p
->buffer
)
1330 && NILP (p
->vchild
))
1335 error ("Attempt to delete minibuffer or sole ordinary window");
1336 par
= XWINDOW (parent
);
1338 windows_or_buffers_changed
++;
1339 Vwindow_list
= Qnil
;
1340 f
= XFRAME (WINDOW_FRAME (p
));
1341 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1343 /* Are we trying to delete any frame's selected window? */
1345 Lisp_Object swindow
, pwindow
;
1347 /* See if the frame's selected window is either WINDOW
1348 or any subwindow of it, by finding all that window's parents
1349 and comparing each one with WINDOW. */
1350 swindow
= FRAME_SELECTED_WINDOW (f
);
1355 while (!NILP (pwindow
))
1357 if (EQ (window
, pwindow
))
1359 pwindow
= XWINDOW (pwindow
)->parent
;
1362 /* If the window being deleted is not a parent of SWINDOW,
1363 then SWINDOW is ok as the new selected window. */
1364 if (!EQ (window
, pwindow
))
1366 /* Otherwise, try another window for SWINDOW. */
1367 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1369 /* If we get back to the frame's selected window,
1370 it means there was no acceptable alternative,
1371 so we cannot delete. */
1372 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1373 error ("Cannot delete window");
1376 /* If we need to change SWINDOW, do it. */
1377 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1379 /* If we're about to delete the selected window on the
1380 selected frame, then we should use Fselect_window to select
1381 the new window. On the other hand, if we're about to
1382 delete the selected window on any other frame, we shouldn't do
1383 anything but set the frame's selected_window slot. */
1384 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1385 Fselect_window (swindow
, Qnil
);
1387 FRAME_SELECTED_WINDOW (f
) = swindow
;
1392 /* tem is null for dummy parent windows
1393 (which have inferiors but not any contents themselves) */
1397 unchain_marker (XMARKER (p
->pointm
));
1398 unchain_marker (XMARKER (p
->start
));
1401 /* Free window glyph matrices. It is sure that they are allocated
1402 again when ADJUST_GLYPHS is called. Block input so that expose
1403 events and other events that access glyph matrices are not
1404 processed while we are changing them. */
1406 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1410 XWINDOW (tem
)->prev
= p
->prev
;
1414 XWINDOW (tem
)->next
= p
->next
;
1416 if (EQ (window
, par
->hchild
))
1417 par
->hchild
= p
->next
;
1418 if (EQ (window
, par
->vchild
))
1419 par
->vchild
= p
->next
;
1421 /* Find one of our siblings to give our space to. */
1425 /* If p gives its space to its next sibling, that sibling needs
1426 to have its top/left side pulled back to where p's is.
1427 set_window_{height,width} will re-position the sibling's
1430 XWINDOW (sib
)->top_line
= p
->top_line
;
1431 XWINDOW (sib
)->left_col
= p
->left_col
;
1434 /* Stretch that sibling. */
1435 if (!NILP (par
->vchild
))
1436 set_window_height (sib
,
1437 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1439 if (!NILP (par
->hchild
))
1440 set_window_width (sib
,
1441 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1444 /* If parent now has only one child,
1445 put the child into the parent's place. */
1449 if (NILP (XWINDOW (tem
)->next
))
1450 replace_window (parent
, tem
);
1452 /* Since we may be deleting combination windows, we must make sure that
1453 not only p but all its children have been marked as deleted. */
1454 if (! NILP (p
->hchild
))
1455 delete_all_subwindows (XWINDOW (p
->hchild
));
1456 else if (! NILP (p
->vchild
))
1457 delete_all_subwindows (XWINDOW (p
->vchild
));
1459 /* Mark this window as deleted. */
1460 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1462 /* Adjust glyph matrices. */
1469 /***********************************************************************
1471 ***********************************************************************/
1473 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1474 pointer. This is a callback function for foreach_window, used in
1475 function window_list. */
1478 add_window_to_list (w
, user_data
)
1482 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1484 XSETWINDOW (window
, w
);
1485 *list
= Fcons (window
, *list
);
1490 /* Return a list of all windows, for use by next_window. If
1491 Vwindow_list is a list, return that list. Otherwise, build a new
1492 list, cache it in Vwindow_list, and return that. */
1497 if (!CONSP (Vwindow_list
))
1501 Vwindow_list
= Qnil
;
1502 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1504 Lisp_Object args
[2];
1506 /* We are visiting windows in canonical order, and add
1507 new windows at the front of args[1], which means we
1508 have to reverse this list at the end. */
1510 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1511 args
[0] = Vwindow_list
;
1512 args
[1] = Fnreverse (args
[1]);
1513 Vwindow_list
= Fnconc (2, args
);
1517 return Vwindow_list
;
1521 /* Value is non-zero if WINDOW satisfies the constraints given by
1522 OWINDOW, MINIBUF and ALL_FRAMES.
1524 MINIBUF t means WINDOW may be minibuffer windows.
1525 `lambda' means WINDOW may not be a minibuffer window.
1526 a window means a specific minibuffer window
1528 ALL_FRAMES t means search all frames,
1529 nil means search just current frame,
1530 `visible' means search just visible frames,
1531 0 means search visible and iconified frames,
1532 a window means search the frame that window belongs to,
1533 a frame means consider windows on that frame, only. */
1536 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1537 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1539 struct window
*w
= XWINDOW (window
);
1540 struct frame
*f
= XFRAME (w
->frame
);
1541 int candidate_p
= 1;
1543 if (!BUFFERP (w
->buffer
))
1545 else if (MINI_WINDOW_P (w
)
1546 && (EQ (minibuf
, Qlambda
)
1547 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1549 /* If MINIBUF is `lambda' don't consider any mini-windows.
1550 If it is a window, consider only that one. */
1553 else if (EQ (all_frames
, Qt
))
1555 else if (NILP (all_frames
))
1557 xassert (WINDOWP (owindow
));
1558 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1560 else if (EQ (all_frames
, Qvisible
))
1562 FRAME_SAMPLE_VISIBILITY (f
);
1563 candidate_p
= FRAME_VISIBLE_P (f
);
1565 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1567 FRAME_SAMPLE_VISIBILITY (f
);
1568 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1570 else if (WINDOWP (all_frames
))
1571 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1572 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1573 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1574 else if (FRAMEP (all_frames
))
1575 candidate_p
= EQ (all_frames
, w
->frame
);
1581 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1582 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1586 decode_next_window_args (window
, minibuf
, all_frames
)
1587 Lisp_Object
*window
, *minibuf
, *all_frames
;
1590 *window
= selected_window
;
1592 CHECK_LIVE_WINDOW (*window
);
1594 /* MINIBUF nil may or may not include minibuffers. Decide if it
1596 if (NILP (*minibuf
))
1597 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1598 else if (!EQ (*minibuf
, Qt
))
1601 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1602 => count none of them, or a specific minibuffer window (the
1603 active one) to count. */
1605 /* ALL_FRAMES nil doesn't specify which frames to include. */
1606 if (NILP (*all_frames
))
1607 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1608 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1610 else if (EQ (*all_frames
, Qvisible
))
1612 else if (XFASTINT (*all_frames
) == 0)
1614 else if (FRAMEP (*all_frames
))
1616 else if (!EQ (*all_frames
, Qt
))
1619 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1620 search just current frame, `visible' meaning search just visible
1621 frames, 0 meaning search visible and iconified frames, or a
1622 window, meaning search the frame that window belongs to, or a
1623 frame, meaning consider windows on that frame, only. */
1627 /* Return the next or previous window of WINDOW in canonical ordering
1628 of windows. NEXT_P non-zero means return the next window. See the
1629 documentation string of next-window for the meaning of MINIBUF and
1633 next_window (window
, minibuf
, all_frames
, next_p
)
1634 Lisp_Object window
, minibuf
, all_frames
;
1637 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1639 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1640 return the first window on the frame. */
1641 if (FRAMEP (all_frames
)
1642 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1643 return Fframe_first_window (all_frames
);
1649 /* Find WINDOW in the list of all windows. */
1650 list
= Fmemq (window
, window_list ());
1652 /* Scan forward from WINDOW to the end of the window list. */
1654 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1655 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1658 /* Scan from the start of the window list up to WINDOW. */
1660 for (list
= Vwindow_list
;
1661 CONSP (list
) && !EQ (XCAR (list
), window
);
1663 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1667 window
= XCAR (list
);
1671 Lisp_Object candidate
, list
;
1673 /* Scan through the list of windows for candidates. If there are
1674 candidate windows in front of WINDOW, the last one of these
1675 is the one we want. If there are candidates following WINDOW
1676 in the list, again the last one of these is the one we want. */
1678 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1680 if (EQ (XCAR (list
), window
))
1682 if (WINDOWP (candidate
))
1685 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1687 candidate
= XCAR (list
);
1690 if (WINDOWP (candidate
))
1698 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1699 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1700 If omitted, WINDOW defaults to the selected window.
1702 Optional second arg MINIBUF t means count the minibuffer window even
1703 if not active. MINIBUF nil or omitted means count the minibuffer iff
1704 it is active. MINIBUF neither t nor nil means not to count the
1705 minibuffer even if it is active.
1707 Several frames may share a single minibuffer; if the minibuffer
1708 counts, all windows on all frames that share that minibuffer count
1709 too. Therefore, `next-window' can be used to iterate through the
1710 set of windows even when the minibuffer is on another frame. If the
1711 minibuffer does not count, only windows from WINDOW's frame count.
1713 Optional third arg ALL-FRAMES t means include windows on all frames.
1714 ALL-FRAMES nil or omitted means cycle within the frames as specified
1715 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1716 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1717 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1718 Anything else means restrict to WINDOW's frame.
1720 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1721 `next-window' to iterate through the entire cycle of acceptable
1722 windows, eventually ending up back at the window you started with.
1723 `previous-window' traverses the same cycle, in the reverse order. */)
1724 (window
, minibuf
, all_frames
)
1725 Lisp_Object window
, minibuf
, all_frames
;
1727 return next_window (window
, minibuf
, all_frames
, 1);
1731 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1732 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1733 If omitted, WINDOW defaults to the selected window.
1735 Optional second arg MINIBUF t means count the minibuffer window even
1736 if not active. MINIBUF nil or omitted means count the minibuffer iff
1737 it is active. MINIBUF neither t nor nil means not to count the
1738 minibuffer even if it is active.
1740 Several frames may share a single minibuffer; if the minibuffer
1741 counts, all windows on all frames that share that minibuffer count
1742 too. Therefore, `previous-window' can be used to iterate through
1743 the set of windows even when the minibuffer is on another frame. If
1744 the minibuffer does not count, only windows from WINDOW's frame count
1746 Optional third arg ALL-FRAMES t means include windows on all frames.
1747 ALL-FRAMES nil or omitted means cycle within the frames as specified
1748 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1749 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1750 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1751 Anything else means restrict to WINDOW's frame.
1753 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1754 `previous-window' to iterate through the entire cycle of acceptable
1755 windows, eventually ending up back at the window you started with.
1756 `next-window' traverses the same cycle, in the reverse order. */)
1757 (window
, minibuf
, all_frames
)
1758 Lisp_Object window
, minibuf
, all_frames
;
1760 return next_window (window
, minibuf
, all_frames
, 0);
1764 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1765 doc
: /* Select the ARG'th different window on this frame.
1766 All windows on current frame are arranged in a cyclic order.
1767 This command selects the window ARG steps away in that order.
1768 A negative ARG moves in the opposite order. The optional second
1769 argument ALL_FRAMES has the same meaning as in `next-window', which see. */)
1771 Lisp_Object arg
, all_frames
;
1777 window
= selected_window
;
1779 for (i
= XINT (arg
); i
> 0; --i
)
1780 window
= Fnext_window (window
, Qnil
, all_frames
);
1782 window
= Fprevious_window (window
, Qnil
, all_frames
);
1784 Fselect_window (window
, Qnil
);
1789 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1790 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1791 FRAME nil or omitted means use the selected frame.
1792 WINDOW nil or omitted means use the selected window.
1793 MINIBUF t means include the minibuffer window, even if it isn't active.
1794 MINIBUF nil or omitted means include the minibuffer window only
1796 MINIBUF neither nil nor t means never include the minibuffer window. */)
1797 (frame
, minibuf
, window
)
1798 Lisp_Object frame
, minibuf
, window
;
1801 window
= selected_window
;
1803 frame
= selected_frame
;
1805 if (!EQ (frame
, XWINDOW (window
)->frame
))
1806 error ("Window is on a different frame");
1808 return window_list_1 (window
, minibuf
, frame
);
1812 /* Return a list of windows in canonical ordering. Arguments are like
1813 for `next-window'. */
1816 window_list_1 (window
, minibuf
, all_frames
)
1817 Lisp_Object window
, minibuf
, all_frames
;
1819 Lisp_Object tail
, list
, rest
;
1821 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1824 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1825 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1826 list
= Fcons (XCAR (tail
), list
);
1828 /* Rotate the list to start with WINDOW. */
1829 list
= Fnreverse (list
);
1830 rest
= Fmemq (window
, list
);
1831 if (!NILP (rest
) && !EQ (rest
, list
))
1833 for (tail
= list
; XCDR (tail
) != rest
; tail
= XCDR (tail
))
1835 XSETCDR (tail
, Qnil
);
1836 list
= nconc2 (rest
, list
);
1843 /* Look at all windows, performing an operation specified by TYPE
1845 If FRAMES is Qt, look at all frames;
1846 Qnil, look at just the selected frame;
1847 Qvisible, look at visible frames;
1848 a frame, just look at windows on that frame.
1849 If MINI is non-zero, perform the operation on minibuffer windows too. */
1854 GET_BUFFER_WINDOW
, /* Arg is buffer */
1855 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1856 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1857 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1859 UNSHOW_BUFFER
, /* Arg is buffer */
1860 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1865 window_loop (type
, obj
, mini
, frames
)
1866 enum window_loop type
;
1867 Lisp_Object obj
, frames
;
1870 Lisp_Object window
, windows
, best_window
, frame_arg
;
1872 struct gcpro gcpro1
;
1874 /* If we're only looping through windows on a particular frame,
1875 frame points to that frame. If we're looping through windows
1876 on all frames, frame is 0. */
1877 if (FRAMEP (frames
))
1878 f
= XFRAME (frames
);
1879 else if (NILP (frames
))
1880 f
= SELECTED_FRAME ();
1885 frame_arg
= Qlambda
;
1886 else if (XFASTINT (frames
) == 0)
1888 else if (EQ (frames
, Qvisible
))
1893 /* frame_arg is Qlambda to stick to one frame,
1894 Qvisible to consider all visible frames,
1897 /* Pick a window to start with. */
1901 window
= FRAME_SELECTED_WINDOW (f
);
1903 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1905 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1909 for (; CONSP (windows
); windows
= CDR (windows
))
1913 window
= XCAR (windows
);
1914 w
= XWINDOW (window
);
1916 /* Note that we do not pay attention here to whether the frame
1917 is visible, since Fwindow_list skips non-visible frames if
1918 that is desired, under the control of frame_arg. */
1919 if (!MINI_WINDOW_P (w
)
1920 /* For UNSHOW_BUFFER, we must always consider all windows. */
1921 || type
== UNSHOW_BUFFER
1922 || (mini
&& minibuf_level
> 0))
1925 case GET_BUFFER_WINDOW
:
1926 if (EQ (w
->buffer
, obj
)
1927 /* Don't find any minibuffer window
1928 except the one that is currently in use. */
1929 && (MINI_WINDOW_P (w
)
1930 ? EQ (window
, minibuf_window
)
1933 if (NILP (best_window
))
1934 best_window
= window
;
1935 else if (EQ (window
, selected_window
))
1936 /* For compatibility with 20.x, prefer to return
1938 best_window
= window
;
1942 case GET_LRU_WINDOW
:
1943 /* t as arg means consider only full-width windows */
1944 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1946 /* Ignore dedicated windows and minibuffers. */
1947 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
1949 if (NILP (best_window
)
1950 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1951 > XFASTINT (w
->use_time
)))
1952 best_window
= window
;
1955 case DELETE_OTHER_WINDOWS
:
1956 if (!EQ (window
, obj
))
1957 Fdelete_window (window
);
1960 case DELETE_BUFFER_WINDOWS
:
1961 if (EQ (w
->buffer
, obj
))
1963 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1965 /* If this window is dedicated, and in a frame of its own,
1967 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1968 && !NILP (w
->dedicated
)
1969 && other_visible_frames (f
))
1971 /* Skip the other windows on this frame.
1972 There might be one, the minibuffer! */
1973 while (CONSP (XCDR (windows
))
1974 && EQ (XWINDOW (XCAR (windows
))->frame
,
1975 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1976 windows
= XCDR (windows
);
1978 /* Now we can safely delete the frame. */
1979 Fdelete_frame (w
->frame
, Qnil
);
1981 else if (NILP (w
->parent
))
1983 /* If we're deleting the buffer displayed in the
1984 only window on the frame, find a new buffer to
1987 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1988 Fset_window_buffer (window
, buffer
, Qnil
);
1989 if (EQ (window
, selected_window
))
1990 Fset_buffer (w
->buffer
);
1993 Fdelete_window (window
);
1997 case GET_LARGEST_WINDOW
:
1999 /* Ignore dedicated windows and minibuffers. */
2000 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
2003 if (NILP (best_window
))
2004 best_window
= window
;
2007 struct window
*b
= XWINDOW (best_window
);
2008 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2009 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2010 best_window
= window
;
2016 if (EQ (w
->buffer
, obj
))
2019 struct frame
*f
= XFRAME (w
->frame
);
2021 /* Find another buffer to show in this window. */
2022 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2024 /* If this window is dedicated, and in a frame of its own,
2026 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2027 && !NILP (w
->dedicated
)
2028 && other_visible_frames (f
))
2030 /* Skip the other windows on this frame.
2031 There might be one, the minibuffer! */
2032 while (CONSP (XCDR (windows
))
2033 && EQ (XWINDOW (XCAR (windows
))->frame
,
2034 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2035 windows
= XCDR (windows
);
2037 /* Now we can safely delete the frame. */
2038 Fdelete_frame (w
->frame
, Qnil
);
2040 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2043 XSETWINDOW (window
, w
);
2044 /* If this window is dedicated and not the only window
2045 in its frame, then kill it. */
2046 Fdelete_window (window
);
2050 /* Otherwise show a different buffer in the window. */
2051 w
->dedicated
= Qnil
;
2052 Fset_window_buffer (window
, buffer
, Qnil
);
2053 if (EQ (window
, selected_window
))
2054 Fset_buffer (w
->buffer
);
2059 case REDISPLAY_BUFFER_WINDOWS
:
2060 if (EQ (w
->buffer
, obj
))
2062 mark_window_display_accurate (window
, 0);
2063 w
->update_mode_line
= Qt
;
2064 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2065 ++update_mode_lines
;
2066 best_window
= window
;
2070 /* Check for a window that has a killed buffer. */
2071 case CHECK_ALL_WINDOWS
:
2072 if (! NILP (w
->buffer
)
2073 && NILP (XBUFFER (w
->buffer
)->name
))
2077 case WINDOW_LOOP_UNUSED
:
2086 /* Used for debugging. Abort if any window has a dead buffer. */
2089 check_all_windows ()
2091 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2094 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
2095 doc
: /* Return the window least recently selected or used for display.
2096 Return a full-width window if possible.
2097 A minibuffer window is never a candidate.
2098 If optional argument FRAME is `visible', search all visible frames.
2099 If FRAME is 0, search all visible and iconified frames.
2100 If FRAME is t, search all frames.
2101 If FRAME is nil, search only the selected frame.
2102 If FRAME is a frame, search only that frame. */)
2106 register Lisp_Object w
;
2107 /* First try for a window that is full-width */
2108 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
2109 if (!NILP (w
) && !EQ (w
, selected_window
))
2111 /* If none of them, try the rest */
2112 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
2115 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
2116 doc
: /* Return the largest window in area.
2117 A minibuffer window is never a candidate.
2118 If optional argument FRAME is `visible', search all visible frames.
2119 If FRAME is 0, search all visible and iconified frames.
2120 If FRAME is t, search all frames.
2121 If FRAME is nil, search only the selected frame.
2122 If FRAME is a frame, search only that frame. */)
2126 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
2130 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2131 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2132 BUFFER can be a buffer or a buffer name.
2133 If optional argument FRAME is `visible', search all visible frames.
2134 If optional argument FRAME is 0, search all visible and iconified frames.
2135 If FRAME is t, search all frames.
2136 If FRAME is nil, search only the selected frame.
2137 If FRAME is a frame, search only that frame. */)
2139 Lisp_Object buffer
, frame
;
2141 buffer
= Fget_buffer (buffer
);
2142 if (BUFFERP (buffer
))
2143 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2148 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2150 doc
: /* Make WINDOW (or the selected window) fill its frame.
2151 Only the frame WINDOW is on is affected.
2152 This function tries to reduce display jumps
2153 by keeping the text previously visible in WINDOW
2154 in the same place on the frame. Doing this depends on
2155 the value of (window-start WINDOW), so if calling this function
2156 in a program gives strange scrolling, make sure the window-start
2157 value is reasonable when this function is called. */)
2166 window
= selected_window
;
2168 CHECK_LIVE_WINDOW (window
);
2169 w
= XWINDOW (window
);
2171 startpos
= marker_position (w
->start
);
2172 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2174 if (MINI_WINDOW_P (w
) && top
> 0)
2175 error ("Can't expand minibuffer to full frame");
2177 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2179 /* Try to minimize scrolling, by setting the window start to the point
2180 will cause the text at the old window start to be at the same place
2181 on the frame. But don't try to do this if the window start is
2182 outside the visible portion (as might happen when the display is
2183 not current, due to typeahead). */
2184 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2186 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2187 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2189 struct position pos
;
2190 struct buffer
*obuf
= current_buffer
;
2192 Fset_buffer (w
->buffer
);
2193 /* This computation used to temporarily move point, but that can
2194 have unwanted side effects due to text properties. */
2195 pos
= *vmotion (startpos
, -top
, w
);
2197 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2198 w
->window_end_valid
= Qnil
;
2199 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2200 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2202 /* We need to do this, so that the window-scroll-functions
2204 w
->optional_new_start
= Qt
;
2206 set_buffer_internal (obuf
);
2212 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2213 1, 2, "bDelete windows on (buffer): ",
2214 doc
: /* Delete all windows showing BUFFER.
2215 BUFFER must be a buffer or the name of an existing buffer.
2216 Optional second argument FRAME controls which frames are affected.
2217 If optional argument FRAME is `visible', search all visible frames.
2218 If FRAME is 0, search all visible and iconified frames.
2219 If FRAME is nil, search all frames.
2220 If FRAME is t, search only the selected frame.
2221 If FRAME is a frame, search only that frame. */)
2223 Lisp_Object buffer
, frame
;
2225 /* FRAME uses t and nil to mean the opposite of what window_loop
2229 else if (EQ (frame
, Qt
))
2234 buffer
= Fget_buffer (buffer
);
2235 CHECK_BUFFER (buffer
);
2236 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2242 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2243 Sreplace_buffer_in_windows
,
2244 1, 1, "bReplace buffer in windows: ",
2245 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2246 BUFFER may be a buffer or the name of an existing buffer. */)
2252 buffer
= Fget_buffer (buffer
);
2253 CHECK_BUFFER (buffer
);
2254 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2259 /* Replace BUFFER with some other buffer in all windows
2260 of all frames, even those on other keyboards. */
2263 replace_buffer_in_all_windows (buffer
)
2267 Lisp_Object tail
, frame
;
2269 /* A single call to window_loop won't do the job
2270 because it only considers frames on the current keyboard.
2271 So loop manually over frames, and handle each one. */
2272 FOR_EACH_FRAME (tail
, frame
)
2273 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2275 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2279 /* Set the height of WINDOW and all its inferiors. */
2281 /* The smallest acceptable dimensions for a window. Anything smaller
2282 might crash Emacs. */
2284 #define MIN_SAFE_WINDOW_WIDTH (2)
2285 #define MIN_SAFE_WINDOW_HEIGHT (1)
2287 /* Make sure that window_min_height and window_min_width are
2288 not too small; if they are, set them to safe minima. */
2291 check_min_window_sizes ()
2293 /* Smaller values might permit a crash. */
2294 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2295 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2296 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2297 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2300 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2301 minimum allowable size. */
2304 check_frame_size (frame
, rows
, cols
)
2308 /* For height, we have to see:
2309 how many windows the frame has at minimum (one or two),
2310 and whether it has a menu bar or other special stuff at the top. */
2312 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2313 ? MIN_SAFE_WINDOW_HEIGHT
2314 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2316 if (FRAME_TOP_MARGIN (frame
) > 0)
2317 min_height
+= FRAME_TOP_MARGIN (frame
);
2319 if (*rows
< min_height
)
2321 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2322 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2326 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2327 check if W's width can be changed, otherwise check W's height.
2328 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2329 siblings, too. If none of the siblings is resizable, WINDOW isn't
2333 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2335 int width_p
, check_siblings_p
;
2340 if (!NILP (w
->hchild
))
2342 c
= XWINDOW (w
->hchild
);
2346 /* A horiz. combination is fixed-width if all of if its
2348 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2349 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2350 fixed_p
= c
== NULL
;
2354 /* A horiz. combination is fixed-height if one of if its
2356 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2357 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2358 fixed_p
= c
!= NULL
;
2361 else if (!NILP (w
->vchild
))
2363 c
= XWINDOW (w
->vchild
);
2367 /* A vert. combination is fixed-width if one of if its
2369 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2370 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2371 fixed_p
= c
!= NULL
;
2375 /* A vert. combination is fixed-height if all of if its
2377 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2378 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2379 fixed_p
= c
== NULL
;
2382 else if (BUFFERP (w
->buffer
))
2384 if (w
->height_fixed_p
&& !width_p
)
2388 struct buffer
*old
= current_buffer
;
2391 current_buffer
= XBUFFER (w
->buffer
);
2392 val
= find_symbol_value (Qwindow_size_fixed
);
2393 current_buffer
= old
;
2396 if (!EQ (val
, Qunbound
))
2398 fixed_p
= !NILP (val
);
2401 && ((EQ (val
, Qheight
) && width_p
)
2402 || (EQ (val
, Qwidth
) && !width_p
)))
2407 /* Can't tell if this one is resizable without looking at
2408 siblings. If all siblings are fixed-size this one is too. */
2409 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2413 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2414 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2418 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2419 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2433 /* Return the minimum size of window W, not taking fixed-width windows
2434 into account. WIDTH_P non-zero means return the minimum width,
2435 otherwise return the minimum height. If W is a combination window,
2436 compute the minimum size from the minimum sizes of W's children. */
2439 window_min_size_1 (w
, width_p
)
2446 if (!NILP (w
->hchild
))
2448 c
= XWINDOW (w
->hchild
);
2453 /* The min width of a horizontal combination is
2454 the sum of the min widths of its children. */
2457 size
+= window_min_size_1 (c
, width_p
);
2458 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2463 /* The min height a horizontal combination equals
2464 the maximum of all min height of its children. */
2467 int min_size
= window_min_size_1 (c
, width_p
);
2468 size
= max (min_size
, size
);
2469 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2473 else if (!NILP (w
->vchild
))
2475 c
= XWINDOW (w
->vchild
);
2480 /* The min width of a vertical combination is
2481 the maximum of the min widths 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
;
2491 /* The min height of a vertical combination equals
2492 the sum of the min height of its children. */
2495 size
+= window_min_size_1 (c
, width_p
);
2496 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2503 size
= window_min_width
;
2506 if (MINI_WINDOW_P (w
)
2507 || (!WINDOW_WANTS_MODELINE_P (w
)
2508 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2511 size
= window_min_height
;
2519 /* Return the minimum size of window W, taking fixed-size windows into
2520 account. WIDTH_P non-zero means return the minimum width,
2521 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2522 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2523 unless FIXED is null. */
2526 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2528 int width_p
, ignore_fixed_p
, *fixed
;
2535 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2541 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2543 size
= window_min_size_1 (w
, width_p
);
2549 /* Adjust the margins of window W if text area is too small.
2550 Return 1 if window width is ok after adjustment; 0 if window
2551 is still too narrow. */
2554 adjust_window_margins (w
)
2557 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2558 - WINDOW_FRINGE_COLS (w
)
2559 - WINDOW_SCROLL_BAR_COLS (w
));
2560 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2561 + WINDOW_RIGHT_MARGIN_COLS (w
));
2563 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2566 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2569 /* Window's text area is too narrow, but reducing the window
2570 margins will fix that. */
2571 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2572 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2574 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2575 w
->left_margin_cols
= w
->right_margin_cols
2576 = make_number (margin_cols
/2);
2578 w
->right_margin_cols
= make_number (margin_cols
);
2581 w
->left_margin_cols
= make_number (margin_cols
);
2585 /* Calculate new sizes for windows in the list FORWARD when the window size
2586 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2587 The number of windows in FORWARD is NCHILDREN, and the number that
2588 can shrink is SHRINKABLE.
2589 The minimum size a window can have is MIN_SIZE.
2590 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2591 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2594 This function returns an allocated array of new sizes that the caller
2595 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2596 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2597 the second, and so on.
2599 This function tries to keep windows at least at the minimum size
2600 and resize other windows before it resizes any window to zero (i.e.
2601 delete that window).
2603 Windows are resized proportional to their size, so bigger windows
2604 shrink more than smaller windows. */
2606 shrink_windows (total
, size
, nchildren
, shrinkable
,
2607 min_size
, resize_fixed_p
, forward
, width_p
)
2608 int total
, size
, nchildren
, shrinkable
, min_size
;
2609 int resize_fixed_p
, width_p
;
2610 Lisp_Object forward
;
2612 int available_resize
= 0;
2616 int smallest
= total
;
2617 int total_removed
= 0;
2618 int total_shrink
= total
- size
;
2621 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2623 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2627 c
= XWINDOW (child
);
2628 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2630 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2634 new_sizes
[i
] = child_size
;
2635 if (child_size
> min_size
)
2636 available_resize
+= child_size
- min_size
;
2639 /* We might need to shrink some windows to zero. Find the smallest
2640 windows and set them to 0 until we can fulfil the new size. */
2642 while (shrinkable
> 1 && size
+ available_resize
< total
)
2644 for (i
= 0; i
< nchildren
; ++i
)
2645 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2646 smallest
= new_sizes
[i
];
2648 for (i
= 0; i
< nchildren
; ++i
)
2649 if (new_sizes
[i
] == smallest
)
2651 /* Resize this window down to zero. */
2653 if (smallest
> min_size
)
2654 available_resize
-= smallest
- min_size
;
2655 available_resize
+= smallest
;
2657 total_removed
+= smallest
;
2659 /* Out of for, just remove one window at the time and
2660 check again if we have enough space. */
2665 /* Now, calculate the new sizes. Try to shrink each window
2666 proportional to its size. */
2667 for (i
= 0; i
< nchildren
; ++i
)
2669 if (new_sizes
[i
] > min_size
)
2671 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2672 if (new_sizes
[i
] - to_shrink
< min_size
)
2673 to_shrink
= new_sizes
[i
] - min_size
;
2674 new_sizes
[i
] -= to_shrink
;
2675 total_removed
+= to_shrink
;
2679 /* Any reminder due to rounding, we just subtract from windows
2680 that are left and still can be shrunk. */
2681 while (total_shrink
> total_removed
)
2683 for (i
= 0; i
< nchildren
; ++i
)
2684 if (new_sizes
[i
] > min_size
)
2689 /* Out of for, just shrink one window at the time and
2690 check again if we have enough space. */
2698 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2699 WINDOW's width. Resize WINDOW's children, if any, so that they
2700 keep their proportionate size relative to WINDOW. Propagate
2701 WINDOW's top or left edge position to children. Delete windows
2702 that become too small unless NODELETE_P is non-zero.
2704 If NODELETE_P is 2, that means we do delete windows that are
2705 too small, even if they were too small before! */
2708 size_window (window
, size
, width_p
, nodelete_p
)
2710 int size
, width_p
, nodelete_p
;
2712 struct window
*w
= XWINDOW (window
);
2714 Lisp_Object child
, *forward
, *sideward
;
2715 int old_size
, min_size
, safe_min_size
;
2717 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2718 seems like it's too soon to do this here. ++KFS. */
2719 if (nodelete_p
== 2)
2722 check_min_window_sizes ();
2723 size
= max (0, size
);
2725 /* If the window has been "too small" at one point,
2726 don't delete it for being "too small" in the future.
2727 Preserve it as long as that is at all possible. */
2730 old_size
= WINDOW_TOTAL_COLS (w
);
2731 min_size
= window_min_width
;
2732 /* Ensure that there is room for the scroll bar and fringes!
2733 We may reduce display margins though. */
2734 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2735 + WINDOW_FRINGE_COLS (w
)
2736 + WINDOW_SCROLL_BAR_COLS (w
));
2740 old_size
= XINT (w
->total_lines
);
2741 min_size
= window_min_height
;
2742 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2745 if (old_size
< min_size
&& nodelete_p
!= 2)
2746 w
->too_small_ok
= Qt
;
2748 /* Maybe delete WINDOW if it's too small. */
2749 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2751 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2752 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2753 if (min_size
< safe_min_size
)
2754 min_size
= safe_min_size
;
2755 if (size
< min_size
)
2757 delete_window (window
);
2762 /* Set redisplay hints. */
2763 w
->last_modified
= make_number (0);
2764 w
->last_overlay_modified
= make_number (0);
2765 windows_or_buffers_changed
++;
2766 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2770 sideward
= &w
->vchild
;
2771 forward
= &w
->hchild
;
2772 w
->total_cols
= make_number (size
);
2773 adjust_window_margins (w
);
2777 sideward
= &w
->hchild
;
2778 forward
= &w
->vchild
;
2779 w
->total_lines
= make_number (size
);
2780 w
->orig_total_lines
= Qnil
;
2783 if (!NILP (*sideward
))
2785 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2787 c
= XWINDOW (child
);
2789 c
->left_col
= w
->left_col
;
2791 c
->top_line
= w
->top_line
;
2792 size_window (child
, size
, width_p
, nodelete_p
);
2795 else if (!NILP (*forward
))
2797 int fixed_size
, each
, extra
, n
;
2798 int resize_fixed_p
, nfixed
;
2799 int last_pos
, first_pos
, nchildren
, total
;
2800 int *new_sizes
= NULL
;
2802 /* Determine the fixed-size portion of the this window, and the
2803 number of child windows. */
2804 fixed_size
= nchildren
= nfixed
= total
= 0;
2805 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2809 c
= XWINDOW (child
);
2810 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2811 total
+= child_size
;
2813 if (window_fixed_size_p (c
, width_p
, 0))
2815 fixed_size
+= child_size
;
2820 /* If the new size is smaller than fixed_size, or if there
2821 aren't any resizable windows, allow resizing fixed-size
2823 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2825 /* Compute how many lines/columns to add/remove to each child. The
2826 value of extra takes care of rounding errors. */
2827 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2828 if (size
< total
&& n
> 1)
2829 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2830 resize_fixed_p
, *forward
, width_p
);
2833 each
= (size
- total
) / n
;
2834 extra
= (size
- total
) - n
* each
;
2837 /* Compute new children heights and edge positions. */
2838 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2839 last_pos
= first_pos
;
2840 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2842 int new_size
, old_size
;
2844 c
= XWINDOW (child
);
2845 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2846 new_size
= old_size
;
2848 /* The top or left edge position of this child equals the
2849 bottom or right edge of its predecessor. */
2851 c
->left_col
= make_number (last_pos
);
2853 c
->top_line
= make_number (last_pos
);
2855 /* If this child can be resized, do it. */
2856 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2858 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2862 /* Set new height. Note that size_window also propagates
2863 edge positions to children, so it's not a no-op if we
2864 didn't change the child's size. */
2865 size_window (child
, new_size
, width_p
, 1);
2867 /* Remember the bottom/right edge position of this child; it
2868 will be used to set the top/left edge of the next child. */
2869 last_pos
+= new_size
;
2872 if (new_sizes
) xfree (new_sizes
);
2874 /* We should have covered the parent exactly with child windows. */
2875 xassert (size
== last_pos
- first_pos
);
2877 /* Now delete any children that became too small. */
2879 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2882 c
= XWINDOW (child
);
2883 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2884 size_window (child
, child_size
, width_p
, 2);
2889 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2890 WINDOW's children. NODELETE non-zero means don't delete windows
2891 that become too small in the process. (The caller should check
2892 later and do so if appropriate.) */
2895 set_window_height (window
, height
, nodelete
)
2900 size_window (window
, height
, 0, nodelete
);
2904 /* Set WINDOW's width to WIDTH, and recursively change the width of
2905 WINDOW's children. NODELETE non-zero means don't delete windows
2906 that become too small in the process. (The caller should check
2907 later and do so if appropriate.) */
2910 set_window_width (window
, width
, nodelete
)
2915 size_window (window
, width
, 1, nodelete
);
2918 /* Change window heights in windows rooted in WINDOW by N lines. */
2921 change_window_heights (window
, n
)
2925 struct window
*w
= XWINDOW (window
);
2927 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
2928 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
2930 if (INTEGERP (w
->orig_top_line
))
2931 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
2932 if (INTEGERP (w
->orig_total_lines
))
2933 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
2935 /* Handle just the top child in a vertical split. */
2936 if (!NILP (w
->vchild
))
2937 change_window_heights (w
->vchild
, n
);
2939 /* Adjust all children in a horizontal split. */
2940 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
2942 w
= XWINDOW (window
);
2943 change_window_heights (window
, n
);
2948 int window_select_count
;
2951 Fset_window_buffer_unwind (obuf
)
2958 EXFUN (Fset_window_fringes
, 4);
2959 EXFUN (Fset_window_scroll_bars
, 4);
2961 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2962 means it's allowed to run hooks. See make_frame for a case where
2963 it's not allowed. KEEP_MARGINS_P non-zero means that the current
2964 margins, fringes, and scroll-bar settings of the window are not
2965 reset from the buffer's local settings. */
2968 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
2969 Lisp_Object window
, buffer
;
2970 int run_hooks_p
, keep_margins_p
;
2972 struct window
*w
= XWINDOW (window
);
2973 struct buffer
*b
= XBUFFER (buffer
);
2974 int count
= SPECPDL_INDEX ();
2978 if (EQ (window
, selected_window
))
2979 b
->last_selected_window
= window
;
2981 /* Update time stamps of buffer display. */
2982 if (INTEGERP (b
->display_count
))
2983 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
2984 b
->display_time
= Fcurrent_time ();
2986 XSETFASTINT (w
->window_end_pos
, 0);
2987 XSETFASTINT (w
->window_end_vpos
, 0);
2988 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
2989 w
->window_end_valid
= Qnil
;
2990 w
->hscroll
= w
->min_hscroll
= make_number (0);
2992 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
2993 set_marker_restricted (w
->start
,
2994 make_number (b
->last_window_start
),
2996 w
->start_at_line_beg
= Qnil
;
2997 w
->force_start
= Qnil
;
2998 XSETFASTINT (w
->last_modified
, 0);
2999 XSETFASTINT (w
->last_overlay_modified
, 0);
3000 windows_or_buffers_changed
++;
3002 /* We must select BUFFER for running the window-scroll-functions.
3003 If WINDOW is selected, switch permanently.
3004 Otherwise, switch but go back to the ambient buffer afterward. */
3005 if (EQ (window
, selected_window
))
3006 Fset_buffer (buffer
);
3007 /* We can't check ! NILP (Vwindow_scroll_functions) here
3008 because that might itself be a local variable. */
3009 else if (window_initialized
)
3011 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3012 Fset_buffer (buffer
);
3015 if (!keep_margins_p
)
3017 /* Set left and right marginal area width etc. from buffer. */
3019 /* This may call adjust_window_margins three times, so
3020 temporarily disable window margins. */
3021 Lisp_Object save_left
= w
->left_margin_cols
;
3022 Lisp_Object save_right
= w
->right_margin_cols
;
3024 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3026 Fset_window_fringes (window
,
3027 b
->left_fringe_width
, b
->right_fringe_width
,
3028 b
->fringes_outside_margins
);
3030 Fset_window_scroll_bars (window
,
3031 b
->scroll_bar_width
,
3032 b
->vertical_scroll_bar_type
, Qnil
);
3034 w
->left_margin_cols
= save_left
;
3035 w
->right_margin_cols
= save_right
;
3037 Fset_window_margins (window
,
3038 b
->left_margin_cols
, b
->right_margin_cols
);
3043 if (! NILP (Vwindow_scroll_functions
))
3044 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3045 Fmarker_position (w
->start
));
3047 if (! NILP (Vwindow_configuration_change_hook
)
3048 && ! NILP (Vrun_hooks
))
3049 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3052 unbind_to (count
, Qnil
);
3056 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3057 doc
: /* Make WINDOW display BUFFER as its contents.
3058 BUFFER can be a buffer or the name of an existing buffer.
3059 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3060 display margins, fringe widths, and scroll bar settings are maintained;
3061 the default is to reset these from BUFFER's local settings or the frame
3063 (window
, buffer
, keep_margins
)
3064 register Lisp_Object window
, buffer
, keep_margins
;
3066 register Lisp_Object tem
;
3067 register struct window
*w
= decode_window (window
);
3069 XSETWINDOW (window
, w
);
3070 buffer
= Fget_buffer (buffer
);
3071 CHECK_BUFFER (buffer
);
3073 if (NILP (XBUFFER (buffer
)->name
))
3074 error ("Attempt to display deleted buffer");
3078 error ("Window is deleted");
3079 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3080 is first being set up. */
3082 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3083 error ("Window is dedicated to `%s'",
3084 SDATA (XBUFFER (tem
)->name
));
3089 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3093 /* Note that selected_window can be nil
3094 when this is called from Fset_window_configuration. */
3096 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3097 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3098 If WINDOW is not already selected, make WINDOW's buffer current
3099 and make WINDOW the frame's selected window. Return WINDOW.
3100 Optional second arg NORECORD non-nil means
3101 do not put this buffer at the front of the list of recently selected ones.
3103 Note that the main editor command loop
3104 selects the buffer of the selected window before each command. */)
3106 register Lisp_Object window
, norecord
;
3108 register struct window
*w
;
3109 register struct window
*ow
;
3112 CHECK_LIVE_WINDOW (window
);
3114 w
= XWINDOW (window
);
3115 w
->frozen_window_start_p
= 0;
3117 XSETFASTINT (w
->use_time
, ++window_select_count
);
3118 if (EQ (window
, selected_window
))
3121 if (!NILP (selected_window
))
3123 ow
= XWINDOW (selected_window
);
3124 if (! NILP (ow
->buffer
))
3125 set_marker_both (ow
->pointm
, ow
->buffer
,
3126 BUF_PT (XBUFFER (ow
->buffer
)),
3127 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3130 selected_window
= window
;
3131 sf
= SELECTED_FRAME ();
3132 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3134 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3135 /* Use this rather than Fhandle_switch_frame
3136 so that FRAME_FOCUS_FRAME is moved appropriately as we
3137 move around in the state where a minibuffer in a separate
3139 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
3142 sf
->selected_window
= window
;
3144 if (NILP (norecord
))
3145 record_buffer (w
->buffer
);
3146 Fset_buffer (w
->buffer
);
3148 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3150 /* Go to the point recorded in the window.
3151 This is important when the buffer is in more
3152 than one window. It also matters when
3153 redisplay_window has altered point after scrolling,
3154 because it makes the change only in the window. */
3156 register int new_point
= marker_position (w
->pointm
);
3157 if (new_point
< BEGV
)
3159 else if (new_point
> ZV
)
3165 windows_or_buffers_changed
++;
3170 select_window_norecord (window
)
3173 return Fselect_window (window
, Qt
);
3176 /* Deiconify the frame containing the window WINDOW,
3177 unless it is the selected frame;
3180 The reason for the exception for the selected frame
3181 is that it seems better not to change the selected frames visibility
3182 merely because of displaying a different buffer in it.
3183 The deiconification is useful when a buffer gets shown in
3184 another frame that you were not using lately. */
3187 display_buffer_1 (window
)
3190 Lisp_Object frame
= XWINDOW (window
)->frame
;
3191 FRAME_PTR f
= XFRAME (frame
);
3193 FRAME_SAMPLE_VISIBILITY (f
);
3195 if (EQ (frame
, selected_frame
))
3196 ; /* Assume the selected frame is already visible enough. */
3197 else if (minibuf_level
> 0
3198 && MINI_WINDOW_P (XWINDOW (selected_window
))
3199 && WINDOW_LIVE_P (minibuf_selected_window
)
3200 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3201 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3204 if (FRAME_ICONIFIED_P (f
))
3205 Fmake_frame_visible (frame
);
3206 else if (FRAME_VISIBLE_P (f
))
3207 Fraise_frame (frame
);
3213 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3214 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would be created specially.
3215 The value is actually t if the frame should be called with default frame
3216 parameters, and a list of frame parameters if they were specified.
3217 See `special-display-buffer-names', and `special-display-regexps'. */)
3219 Lisp_Object buffer_name
;
3223 CHECK_STRING (buffer_name
);
3225 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3229 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3233 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3235 Lisp_Object car
= XCAR (tem
);
3237 && fast_string_match (car
, buffer_name
) >= 0)
3239 else if (CONSP (car
)
3240 && STRINGP (XCAR (car
))
3241 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3247 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3248 doc
: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
3249 See `same-window-buffer-names' and `same-window-regexps'. */)
3251 Lisp_Object buffer_name
;
3255 CHECK_STRING (buffer_name
);
3257 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3261 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3265 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3267 Lisp_Object car
= XCAR (tem
);
3269 && fast_string_match (car
, buffer_name
) >= 0)
3271 else if (CONSP (car
)
3272 && STRINGP (XCAR (car
))
3273 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3279 /* Use B so the default is (other-buffer). */
3280 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3281 "BDisplay buffer: \nP",
3282 doc
: /* Make BUFFER appear in some window but don't select it.
3283 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3285 If BUFFER is shown already in some window, just use that one,
3286 unless the window is the selected window and the optional second
3287 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3288 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3289 Returns the window displaying BUFFER.
3290 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3291 displaying BUFFER, then simply raise that frame.
3293 The variables `special-display-buffer-names',
3294 `special-display-regexps', `same-window-buffer-names', and
3295 `same-window-regexps' customize how certain buffer names are handled.
3296 The latter two take effect only if NOT-THIS-WINDOW is t.
3298 If optional argument FRAME is `visible', search all visible frames.
3299 If FRAME is 0, search all visible and iconified frames.
3300 If FRAME is t, search all frames.
3301 If FRAME is a frame, search only that frame.
3302 If FRAME is nil, search only the selected frame
3303 (actually the last nonminibuffer frame),
3304 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3305 which means search visible and iconified frames.
3307 If a full-width window on a splittable frame is available to display
3308 the buffer, it may be split, subject to the value of the variable
3309 `split-height-threshold'.
3311 If `even-window-heights' is non-nil, window heights will be evened out
3312 if displaying the buffer causes two vertically adjacent windows to be
3314 (buffer
, not_this_window
, frame
)
3315 register Lisp_Object buffer
, not_this_window
, frame
;
3317 register Lisp_Object window
, tem
, swp
;
3321 buffer
= Fget_buffer (buffer
);
3322 CHECK_BUFFER (buffer
);
3324 if (!NILP (Vdisplay_buffer_function
))
3325 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3327 if (NILP (not_this_window
)
3328 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3329 return display_buffer_1 (selected_window
);
3331 /* See if the user has specified this buffer should appear
3332 in the selected window. */
3333 if (NILP (not_this_window
))
3335 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3336 if (!NILP (swp
) && !no_switch_window (selected_window
))
3338 Fswitch_to_buffer (buffer
, Qnil
);
3339 return display_buffer_1 (selected_window
);
3343 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3344 look for a window showing BUFFER on any visible or iconified frame.
3345 Otherwise search only the current frame. */
3348 else if (pop_up_frames
3349 || display_buffer_reuse_frames
3350 || last_nonminibuf_frame
== 0)
3351 XSETFASTINT (tem
, 0);
3353 XSETFRAME (tem
, last_nonminibuf_frame
);
3355 window
= Fget_buffer_window (buffer
, tem
);
3357 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3358 return display_buffer_1 (window
);
3360 /* Certain buffer names get special handling. */
3361 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3363 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3365 return call1 (Vspecial_display_function
, buffer
);
3367 return call2 (Vspecial_display_function
, buffer
, tem
);
3370 /* If there are no frames open that have more than a minibuffer,
3371 we need to create a new frame. */
3372 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3374 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3375 Fset_window_buffer (window
, buffer
, Qnil
);
3376 return display_buffer_1 (window
);
3379 f
= SELECTED_FRAME ();
3381 || FRAME_MINIBUF_ONLY_P (f
)
3382 /* If the current frame is a special display frame,
3383 don't try to reuse its windows. */
3384 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3389 if (FRAME_MINIBUF_ONLY_P (f
))
3390 XSETFRAME (frames
, last_nonminibuf_frame
);
3391 /* Don't try to create a window if we would get an error. */
3392 if (split_height_threshold
< window_min_height
<< 1)
3393 split_height_threshold
= window_min_height
<< 1;
3395 /* Note that both Fget_largest_window and Fget_lru_window
3396 ignore minibuffers and dedicated windows.
3397 This means they can return nil. */
3399 /* If the frame we would try to split cannot be split,
3400 try other frames. */
3401 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3403 /* Try visible frames first. */
3404 window
= Fget_largest_window (Qvisible
);
3405 /* If that didn't work, try iconified frames. */
3407 window
= Fget_largest_window (make_number (0));
3409 window
= Fget_largest_window (Qt
);
3412 window
= Fget_largest_window (frames
);
3414 /* If we got a tall enough full-width window that can be split,
3417 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3418 && window_height (window
) >= split_height_threshold
3419 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3420 window
= Fsplit_window (window
, Qnil
, Qnil
);
3423 Lisp_Object upper
, lower
, other
;
3425 window
= Fget_lru_window (frames
);
3426 /* If the LRU window is selected, and big enough,
3427 and can be split, split it. */
3429 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3430 && (EQ (window
, selected_window
)
3431 || EQ (XWINDOW (window
)->parent
, Qnil
))
3432 && window_height (window
) >= window_min_height
<< 1)
3433 window
= Fsplit_window (window
, Qnil
, Qnil
);
3434 /* If Fget_lru_window returned nil, try other approaches. */
3436 /* Try visible frames first. */
3438 window
= Fget_buffer_window (buffer
, Qvisible
);
3440 window
= Fget_largest_window (Qvisible
);
3441 /* If that didn't work, try iconified frames. */
3443 window
= Fget_buffer_window (buffer
, make_number (0));
3445 window
= Fget_largest_window (make_number (0));
3446 /* Try invisible frames. */
3448 window
= Fget_buffer_window (buffer
, Qt
);
3450 window
= Fget_largest_window (Qt
);
3451 /* As a last resort, make a new frame. */
3453 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3454 /* If window appears above or below another,
3455 even out their heights. */
3456 other
= upper
= lower
= Qnil
;
3457 if (!NILP (XWINDOW (window
)->prev
))
3458 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3459 if (!NILP (XWINDOW (window
)->next
))
3460 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3462 && !NILP (Veven_window_heights
)
3463 /* Check that OTHER and WINDOW are vertically arrayed. */
3464 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3465 && (XFASTINT (XWINDOW (other
)->total_lines
)
3466 > XFASTINT (XWINDOW (window
)->total_lines
)))
3468 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3469 + XFASTINT (XWINDOW (window
)->total_lines
));
3470 enlarge_window (upper
,
3471 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3477 window
= Fget_lru_window (Qnil
);
3479 Fset_window_buffer (window
, buffer
, Qnil
);
3480 return display_buffer_1 (window
);
3484 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3486 doc
: /* Force redisplay of all windows.
3487 If optional arg OBJECT is a window, force redisplay of that window only.
3488 If OBJECT is a buffer or buffer name, force redisplay of all windows
3489 displaying that buffer. */)
3495 windows_or_buffers_changed
++;
3496 update_mode_lines
++;
3500 if (WINDOWP (object
))
3502 struct window
*w
= XWINDOW (object
);
3503 mark_window_display_accurate (object
, 0);
3504 w
->update_mode_line
= Qt
;
3505 if (BUFFERP (w
->buffer
))
3506 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3507 ++update_mode_lines
;
3511 if (STRINGP (object
))
3512 object
= Fget_buffer (object
);
3513 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3515 /* Walk all windows looking for buffer, and force update
3516 of each of those windows. */
3518 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3519 return NILP (object
) ? Qnil
: Qt
;
3522 /* If nothing suitable was found, just return.
3523 We could signal an error, but this feature will typically be used
3524 asynchronously in timers or process sentinels, so we don't. */
3530 temp_output_buffer_show (buf
)
3531 register Lisp_Object buf
;
3533 register struct buffer
*old
= current_buffer
;
3534 register Lisp_Object window
;
3535 register struct window
*w
;
3537 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3540 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3544 #if 0 /* rms: there should be no reason for this. */
3545 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3547 set_buffer_internal (old
);
3549 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3550 call1 (Vtemp_buffer_show_function
, buf
);
3553 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3555 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3556 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3557 Vminibuf_scroll_window
= window
;
3558 w
= XWINDOW (window
);
3559 XSETFASTINT (w
->hscroll
, 0);
3560 XSETFASTINT (w
->min_hscroll
, 0);
3561 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3562 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3564 /* Run temp-buffer-show-hook, with the chosen window selected
3565 and its buffer current. */
3567 if (!NILP (Vrun_hooks
)
3568 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3569 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3571 int count
= SPECPDL_INDEX ();
3572 Lisp_Object prev_window
, prev_buffer
;
3573 prev_window
= selected_window
;
3574 XSETBUFFER (prev_buffer
, old
);
3576 /* Select the window that was chosen, for running the hook.
3577 Note: Both Fselect_window and select_window_norecord may
3578 set-buffer to the buffer displayed in the window,
3579 so we need to save the current buffer. --stef */
3580 record_unwind_protect (Fset_buffer
, prev_buffer
);
3581 record_unwind_protect (select_window_norecord
, prev_window
);
3582 Fselect_window (window
, Qt
);
3583 Fset_buffer (w
->buffer
);
3584 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3585 unbind_to (count
, Qnil
);
3591 make_dummy_parent (window
)
3595 register struct window
*o
, *p
;
3598 o
= XWINDOW (window
);
3599 p
= allocate_window ();
3600 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3601 ((struct Lisp_Vector
*) p
)->contents
[i
]
3602 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3603 XSETWINDOW (new, p
);
3605 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
3607 /* Put new into window structure in place of window */
3608 replace_window (window
, new);
3621 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3622 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3623 WINDOW defaults to selected one and SIZE to half its size.
3624 If optional third arg HORFLAG is non-nil, split side by side
3625 and put SIZE columns in the first of the pair. In that case,
3626 SIZE includes that window's scroll bar, or the divider column to its right.
3627 Interactively, all arguments are nil.
3629 Returns the newly created window (which is the lower or rightmost one).
3630 The upper or leftmost window is the original one and remains selected.
3631 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3632 (window
, size
, horflag
)
3633 Lisp_Object window
, size
, horflag
;
3635 register Lisp_Object
new;
3636 register struct window
*o
, *p
;
3638 register int size_int
;
3641 window
= selected_window
;
3643 CHECK_LIVE_WINDOW (window
);
3645 o
= XWINDOW (window
);
3646 fo
= XFRAME (WINDOW_FRAME (o
));
3650 if (!NILP (horflag
))
3651 /* Calculate the size of the left-hand window, by dividing
3652 the usable space in columns by two.
3653 We round up, since the left-hand window may include
3654 a dividing line, while the right-hand may not. */
3655 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3657 size_int
= XFASTINT (o
->total_lines
) >> 1;
3661 CHECK_NUMBER (size
);
3662 size_int
= XINT (size
);
3665 if (MINI_WINDOW_P (o
))
3666 error ("Attempt to split minibuffer window");
3667 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3668 error ("Attempt to split fixed-size window");
3670 check_min_window_sizes ();
3674 if (size_int
< window_min_height
)
3675 error ("Window height %d too small (after splitting)", size_int
);
3676 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3677 error ("Window height %d too small (after splitting)",
3678 XFASTINT (o
->total_lines
) - size_int
);
3679 if (NILP (o
->parent
)
3680 || NILP (XWINDOW (o
->parent
)->vchild
))
3682 make_dummy_parent (window
);
3684 XWINDOW (new)->vchild
= window
;
3689 if (size_int
< window_min_width
)
3690 error ("Window width %d too small (after splitting)", size_int
);
3692 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3693 error ("Window width %d too small (after splitting)",
3694 XFASTINT (o
->total_cols
) - size_int
);
3695 if (NILP (o
->parent
)
3696 || NILP (XWINDOW (o
->parent
)->hchild
))
3698 make_dummy_parent (window
);
3700 XWINDOW (new)->hchild
= window
;
3704 /* Now we know that window's parent is a vertical combination
3705 if we are dividing vertically, or a horizontal combination
3706 if we are making side-by-side windows */
3708 windows_or_buffers_changed
++;
3709 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3710 new = make_window ();
3713 p
->frame
= o
->frame
;
3715 if (!NILP (p
->next
))
3716 XWINDOW (p
->next
)->prev
= new;
3719 p
->parent
= o
->parent
;
3721 p
->window_end_valid
= Qnil
;
3722 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3724 /* Duplicate special geometry settings. */
3726 p
->left_margin_cols
= o
->left_margin_cols
;
3727 p
->right_margin_cols
= o
->right_margin_cols
;
3728 p
->left_fringe_width
= o
->left_fringe_width
;
3729 p
->right_fringe_width
= o
->right_fringe_width
;
3730 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3731 p
->scroll_bar_width
= o
->scroll_bar_width
;
3732 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3734 /* Apportion the available frame space among the two new windows */
3736 if (!NILP (horflag
))
3738 p
->total_lines
= o
->total_lines
;
3739 p
->top_line
= o
->top_line
;
3740 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3741 XSETFASTINT (o
->total_cols
, size_int
);
3742 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3743 adjust_window_margins (p
);
3744 adjust_window_margins (o
);
3748 p
->left_col
= o
->left_col
;
3749 p
->total_cols
= o
->total_cols
;
3750 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3751 XSETFASTINT (o
->total_lines
, size_int
);
3752 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3755 /* Adjust glyph matrices. */
3758 Fset_window_buffer (new, o
->buffer
, Qt
);
3762 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 3, "p",
3763 doc
: /* Make current window ARG lines bigger.
3764 From program, optional second arg non-nil means grow sideways ARG columns.
3765 Interactively, if an argument is not given, make the window one line bigger.
3767 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3768 of the siblings above or to the left of the selected window. Only
3769 siblings to the right or below are changed. */)
3770 (arg
, side
, preserve_before
)
3771 register Lisp_Object arg
, side
, preserve_before
;
3774 enlarge_window (selected_window
, XINT (arg
), !NILP (side
),
3775 !NILP (preserve_before
));
3777 if (! NILP (Vwindow_configuration_change_hook
))
3778 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3783 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3784 doc
: /* Make current window ARG lines smaller.
3785 From program, optional second arg non-nil means shrink sideways arg columns.
3786 Interactively, if an argument is not given, make the window one line smaller.
3788 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3789 of the siblings above or to the left of the selected window. Only
3790 siblings to the right or below are changed. */)
3791 (arg
, side
, preserve_before
)
3792 register Lisp_Object arg
, side
, preserve_before
;
3795 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3796 !NILP (preserve_before
));
3798 if (! NILP (Vwindow_configuration_change_hook
))
3799 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3805 window_height (window
)
3808 register struct window
*p
= XWINDOW (window
);
3809 return WINDOW_TOTAL_LINES (p
);
3813 window_width (window
)
3816 register struct window
*p
= XWINDOW (window
);
3817 return WINDOW_TOTAL_COLS (p
);
3822 *(widthflag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3824 #define CURSIZE(w) \
3825 *(widthflag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3828 /* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
3829 increase its width. Siblings of the selected window are resized to
3830 fulfill the size request. If they become too small in the process,
3831 they will be deleted.
3833 If PRESERVE_BEFORE is nonzero, that means don't alter
3834 the siblings to the left or above WINDOW. */
3837 enlarge_window (window
, delta
, widthflag
, preserve_before
)
3839 int delta
, widthflag
, preserve_before
;
3841 Lisp_Object parent
, next
, prev
;
3845 int (*sizefun
) P_ ((Lisp_Object
))
3846 = widthflag
? window_width
: window_height
;
3847 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3848 = (widthflag
? set_window_width
: set_window_height
);
3850 /* Check values of window_min_width and window_min_height for
3852 check_min_window_sizes ();
3854 /* Give up if this window cannot be resized. */
3855 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3856 error ("Window is not resizable");
3858 /* Find the parent of the selected window. */
3861 p
= XWINDOW (window
);
3867 error ("No other window to side of this one");
3872 ? !NILP (XWINDOW (parent
)->hchild
)
3873 : !NILP (XWINDOW (parent
)->vchild
))
3879 sizep
= &CURSIZE (window
);
3882 register int maxdelta
;
3884 /* Compute the maximum size increment this window can have. */
3886 if (preserve_before
)
3890 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
3891 /* Subtract size of siblings before, since we can't take that. */
3892 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
3895 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3896 - window_min_size (XWINDOW (p
->next
),
3901 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3902 /* This is a main window followed by a minibuffer. */
3903 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3904 - window_min_size (XWINDOW (p
->next
),
3906 /* This is a minibuffer following a main window. */
3907 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3908 - window_min_size (XWINDOW (p
->prev
),
3910 /* This is a frame with only one window, a minibuffer-only
3911 or a minibufferless frame. */
3914 if (delta
> maxdelta
)
3915 /* This case traps trying to make the minibuffer
3916 the full frame, or make the only window aside from the
3917 minibuffer the full frame. */
3921 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3923 delete_window (window
);
3930 /* Find the total we can get from other siblings without deleting them. */
3932 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3933 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3935 if (! preserve_before
)
3936 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3937 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3940 /* If we can get it all from them without deleting them, do so. */
3941 if (delta
<= maximum
)
3943 Lisp_Object first_unaffected
;
3944 Lisp_Object first_affected
;
3949 first_affected
= window
;
3950 /* Look at one sibling at a time,
3951 moving away from this window in both directions alternately,
3952 and take as much as we can get without deleting that sibling. */
3954 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
3958 int this_one
= ((*sizefun
) (next
)
3959 - window_min_size (XWINDOW (next
),
3960 widthflag
, 0, &fixed_p
));
3963 if (this_one
> delta
)
3966 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
3967 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3972 next
= XWINDOW (next
)->next
;
3978 if (!preserve_before
&& ! NILP (prev
))
3980 int this_one
= ((*sizefun
) (prev
)
3981 - window_min_size (XWINDOW (prev
),
3982 widthflag
, 0, &fixed_p
));
3985 if (this_one
> delta
)
3988 first_affected
= prev
;
3990 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
3991 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3996 prev
= XWINDOW (prev
)->prev
;
4000 xassert (delta
== 0);
4002 /* Now recalculate the edge positions of all the windows affected,
4003 based on the new sizes. */
4004 first_unaffected
= next
;
4005 prev
= first_affected
;
4006 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4007 prev
= next
, next
= XWINDOW (next
)->next
)
4009 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4010 /* This does not change size of NEXT,
4011 but it propagates the new top edge to its children */
4012 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4017 register int delta1
;
4018 register int opht
= (*sizefun
) (parent
);
4020 if (opht
<= XINT (*sizep
) + delta
)
4022 /* If trying to grow this window to or beyond size of the parent,
4023 just delete all the sibling windows. */
4024 Lisp_Object start
, tem
, next
;
4026 start
= XWINDOW (parent
)->vchild
;
4028 start
= XWINDOW (parent
)->hchild
;
4030 /* Delete any siblings that come after WINDOW. */
4031 tem
= XWINDOW (window
)->next
;
4032 while (! NILP (tem
))
4034 next
= XWINDOW (tem
)->next
;
4035 delete_window (tem
);
4039 /* Delete any siblings that come after WINDOW.
4040 Note that if START is not WINDOW, then WINDOW still
4041 Fhas siblings, so WINDOW has not yet replaced its parent. */
4043 while (! EQ (tem
, window
))
4045 next
= XWINDOW (tem
)->next
;
4046 delete_window (tem
);
4052 /* Otherwise, make delta1 just right so that if we add
4053 delta1 lines to this window and to the parent, and then
4054 shrink the parent back to its original size, the new
4055 proportional size of this window will increase by delta.
4057 The function size_window will compute the new height h'
4058 of the window from delta1 as:
4061 x = delta1 - delta1/n * n for the 1st resizable child
4064 where n is the number of children that can be resized.
4065 We can ignore x by choosing a delta1 that is a multiple of
4066 n. We want the height of this window to come out as
4076 The number of children n equals the number of resizable
4077 children of this window + 1 because we know window itself
4078 is resizable (otherwise we would have signalled an error. */
4080 struct window
*w
= XWINDOW (window
);
4084 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4085 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4087 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4088 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4093 /* Add delta1 lines or columns to this window, and to the parent,
4094 keeping things consistent while not affecting siblings. */
4095 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4096 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4098 /* Squeeze out delta1 lines or columns from our parent,
4099 shriking this window and siblings proportionately.
4100 This brings parent back to correct size.
4101 Delta1 was calculated so this makes this window the desired size,
4102 taking it all out of the siblings. */
4103 (*setsizefun
) (parent
, opht
, 0);
4108 XSETFASTINT (p
->last_modified
, 0);
4109 XSETFASTINT (p
->last_overlay_modified
, 0);
4111 /* Adjust glyph matrices. */
4112 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4120 /***********************************************************************
4121 Resizing Mini-Windows
4122 ***********************************************************************/
4124 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4126 enum save_restore_action
4133 static int save_restore_orig_size
P_ ((struct window
*,
4134 enum save_restore_action
));
4136 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4137 from lowest windows first. */
4140 shrink_window_lowest_first (w
, height
)
4148 xassert (!MINI_WINDOW_P (w
));
4150 /* Set redisplay hints. */
4151 XSETFASTINT (w
->last_modified
, 0);
4152 XSETFASTINT (w
->last_overlay_modified
, 0);
4153 windows_or_buffers_changed
++;
4154 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4156 old_height
= XFASTINT (w
->total_lines
);
4157 XSETFASTINT (w
->total_lines
, height
);
4159 if (!NILP (w
->hchild
))
4161 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4163 c
= XWINDOW (child
);
4164 c
->top_line
= w
->top_line
;
4165 shrink_window_lowest_first (c
, height
);
4168 else if (!NILP (w
->vchild
))
4170 Lisp_Object last_child
;
4171 int delta
= old_height
- height
;
4176 /* Find the last child. We are taking space from lowest windows
4177 first, so we iterate over children from the last child
4179 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4182 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4183 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4187 c
= XWINDOW (child
);
4188 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4190 if (this_one
> delta
)
4193 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4197 /* Compute new positions. */
4198 last_top
= XINT (w
->top_line
);
4199 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4201 c
= XWINDOW (child
);
4202 c
->top_line
= make_number (last_top
);
4203 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4204 last_top
+= XFASTINT (c
->total_lines
);
4210 /* Save, restore, or check positions and sizes in the window tree
4211 rooted at W. ACTION says what to do.
4213 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4214 orig_total_lines members are valid for all windows in the window
4215 tree. Value is non-zero if they are valid.
4217 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4218 orig_top_line and orig_total_lines for all windows in the tree.
4220 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4221 stored in orig_top_line and orig_total_lines for all windows. */
4224 save_restore_orig_size (w
, action
)
4226 enum save_restore_action action
;
4232 if (!NILP (w
->hchild
))
4234 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4237 else if (!NILP (w
->vchild
))
4239 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4245 case CHECK_ORIG_SIZES
:
4246 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4250 case SAVE_ORIG_SIZES
:
4251 w
->orig_top_line
= w
->top_line
;
4252 w
->orig_total_lines
= w
->total_lines
;
4253 XSETFASTINT (w
->last_modified
, 0);
4254 XSETFASTINT (w
->last_overlay_modified
, 0);
4257 case RESTORE_ORIG_SIZES
:
4258 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4259 w
->top_line
= w
->orig_top_line
;
4260 w
->total_lines
= w
->orig_total_lines
;
4261 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4262 XSETFASTINT (w
->last_modified
, 0);
4263 XSETFASTINT (w
->last_overlay_modified
, 0);
4270 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4277 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4278 without deleting other windows. */
4281 grow_mini_window (w
, delta
)
4285 struct frame
*f
= XFRAME (w
->frame
);
4286 struct window
*root
;
4288 xassert (MINI_WINDOW_P (w
));
4289 xassert (delta
>= 0);
4291 /* Check values of window_min_width and window_min_height for
4293 check_min_window_sizes ();
4295 /* Compute how much we can enlarge the mini-window without deleting
4297 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4300 int min_height
= window_min_size (root
, 0, 0, 0);
4301 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4302 /* Note that the root window may already be smaller than
4304 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4309 /* Save original window sizes and positions, if not already done. */
4310 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4311 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4313 /* Shrink other windows. */
4314 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4316 /* Grow the mini-window. */
4317 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4318 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4319 XSETFASTINT (w
->last_modified
, 0);
4320 XSETFASTINT (w
->last_overlay_modified
, 0);
4327 /* Shrink mini-window W. If there is recorded info about window sizes
4328 before a call to grow_mini_window, restore recorded window sizes.
4329 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4333 shrink_mini_window (w
)
4336 struct frame
*f
= XFRAME (w
->frame
);
4337 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4339 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4341 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4343 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4344 windows_or_buffers_changed
= 1;
4346 else if (XFASTINT (w
->total_lines
) > 1)
4348 /* Distribute the additional lines of the mini-window
4349 among the other windows. */
4351 XSETWINDOW (window
, w
);
4352 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0, 0);
4358 /* Mark window cursors off for all windows in the window tree rooted
4359 at W by setting their phys_cursor_on_p flag to zero. Called from
4360 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4361 the frame are cleared. */
4364 mark_window_cursors_off (w
)
4369 if (!NILP (w
->hchild
))
4370 mark_window_cursors_off (XWINDOW (w
->hchild
));
4371 else if (!NILP (w
->vchild
))
4372 mark_window_cursors_off (XWINDOW (w
->vchild
));
4374 w
->phys_cursor_on_p
= 0;
4376 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4381 /* Return number of lines of text (not counting mode lines) in W. */
4384 window_internal_height (w
)
4387 int ht
= XFASTINT (w
->total_lines
);
4389 if (!MINI_WINDOW_P (w
))
4391 if (!NILP (w
->parent
)
4392 || !NILP (w
->vchild
)
4393 || !NILP (w
->hchild
)
4396 || WINDOW_WANTS_MODELINE_P (w
))
4399 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4407 /* Return the number of columns in W.
4408 Don't count columns occupied by scroll bars or the vertical bar
4409 separating W from the sibling to its right. */
4412 window_box_text_cols (w
)
4415 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4416 int width
= XINT (w
->total_cols
);
4418 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4419 /* Scroll bars occupy a few columns. */
4420 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4421 else if (!FRAME_WINDOW_P (f
)
4422 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4423 /* The column of `|' characters separating side-by-side windows
4424 occupies one column only. */
4427 if (FRAME_WINDOW_P (f
))
4428 /* On window-systems, fringes and display margins cannot be
4429 used for normal text. */
4430 width
-= (WINDOW_FRINGE_COLS (w
)
4431 + WINDOW_LEFT_MARGIN_COLS (w
)
4432 + WINDOW_RIGHT_MARGIN_COLS (w
));
4438 /************************************************************************
4440 ***********************************************************************/
4442 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4443 N screen-fulls, which is defined as the height of the window minus
4444 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4445 instead. Negative values of N mean scroll down. NOERROR non-zero
4446 means don't signal an error if we try to move over BEGV or ZV,
4450 window_scroll (window
, n
, whole
, noerror
)
4458 /* If we must, use the pixel-based version which is much slower than
4459 the line-based one but can handle varying line heights. */
4460 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4461 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4463 window_scroll_line_based (window
, n
, whole
, noerror
);
4469 /* Implementation of window_scroll that works based on pixel line
4470 heights. See the comment of window_scroll for parameter
4474 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4481 struct window
*w
= XWINDOW (window
);
4482 struct text_pos start
;
4484 int this_scroll_margin
;
4486 /* True if we fiddled the window vscroll field without really scrolling. */
4489 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4491 /* If PT is not visible in WINDOW, move back one half of
4492 the screen. Allow PT to be partially visible, otherwise
4493 something like (scroll-down 1) with PT in the line before
4494 the partially visible one would recenter. */
4495 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4498 /* Move backward half the height of the window. Performance note:
4499 vmotion used here is about 10% faster, but would give wrong
4500 results for variable height lines. */
4501 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4502 it
.current_y
= it
.last_visible_y
;
4503 move_it_vertically (&it
, - window_box_height (w
) / 2);
4505 /* The function move_iterator_vertically may move over more than
4506 the specified y-distance. If it->w is small, e.g. a
4507 mini-buffer window, we may end up in front of the window's
4508 display area. This is the case when Start displaying at the
4509 start of the line containing PT in this case. */
4510 if (it
.current_y
<= 0)
4512 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4513 move_it_vertically (&it
, 0);
4517 start
= it
.current
.pos
;
4520 /* If scroll_preserve_screen_position is non-zero, we try to set
4521 point in the same window line as it is now, so get that line. */
4522 if (!NILP (Vscroll_preserve_screen_position
))
4524 start_display (&it
, w
, start
);
4525 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4526 preserve_y
= it
.current_y
;
4531 /* Move iterator it from start the specified distance forward or
4532 backward. The result is the new window start. */
4533 start_display (&it
, w
, start
);
4536 int screen_full
= (window_box_height (w
)
4537 - next_screen_context_lines
* FRAME_LINE_HEIGHT (it
.f
));
4538 int dy
= n
* screen_full
;
4540 /* Note that move_it_vertically always moves the iterator to the
4541 start of a line. So, if the last line doesn't have a newline,
4542 we would end up at the start of the line ending at ZV. */
4544 move_it_vertically_backward (&it
, -dy
);
4546 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4547 MOVE_TO_POS
| MOVE_TO_Y
);
4550 move_it_by_lines (&it
, n
, 1);
4552 /* We failed if we find ZV is already on the screen (scrolling up,
4553 means there's nothing past the end), or if we can't start any
4554 earlier (scrolling down, means there's nothing past the top). */
4555 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4556 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4558 if (IT_CHARPOS (it
) == ZV
)
4560 if (it
.current_y
< it
.last_visible_y
4561 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4562 >= it
.last_visible_y
))
4564 /* The last line was only partially visible, make it fully
4566 w
->vscroll
= (it
.last_visible_y
4567 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4568 adjust_glyphs (it
.f
);
4573 Fsignal (Qend_of_buffer
, Qnil
);
4577 if (w
->vscroll
!= 0)
4578 /* The first line was only partially visible, make it fully
4584 Fsignal (Qbeginning_of_buffer
, Qnil
);
4587 /* If control gets here, then we vscrolled. */
4589 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4591 /* Don't try to change the window start below. */
4597 int pos
= IT_CHARPOS (it
);
4600 /* If in the middle of a multi-glyph character move forward to
4601 the next character. */
4602 if (in_display_vector_p (&it
))
4605 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4608 /* Set the window start, and set up the window for redisplay. */
4609 set_marker_restricted (w
->start
, make_number (pos
),
4611 bytepos
= XMARKER (w
->start
)->bytepos
;
4612 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4614 w
->update_mode_line
= Qt
;
4615 XSETFASTINT (w
->last_modified
, 0);
4616 XSETFASTINT (w
->last_overlay_modified
, 0);
4617 /* Set force_start so that redisplay_window will run the
4618 window-scroll-functions. */
4619 w
->force_start
= Qt
;
4622 it
.current_y
= it
.vpos
= 0;
4624 /* Preserve the screen position if we must. */
4625 if (preserve_y
>= 0)
4627 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4628 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4632 /* Move PT out of scroll margins. */
4633 this_scroll_margin
= max (0, scroll_margin
);
4634 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4635 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4639 /* We moved the window start towards ZV, so PT may be now
4640 in the scroll margin at the top. */
4641 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4642 while (it
.current_y
< this_scroll_margin
)
4644 int prev
= it
.current_y
;
4645 move_it_by_lines (&it
, 1, 1);
4646 if (prev
== it
.current_y
)
4649 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4653 int charpos
, bytepos
;
4655 /* We moved the window start towards BEGV, so PT may be now
4656 in the scroll margin at the bottom. */
4657 move_it_to (&it
, PT
, -1,
4658 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4659 MOVE_TO_POS
| MOVE_TO_Y
);
4661 /* Save our position, in case it's correct. */
4662 charpos
= IT_CHARPOS (it
);
4663 bytepos
= IT_BYTEPOS (it
);
4665 /* See if point is on a partially visible line at the end. */
4666 move_it_by_lines (&it
, 1, 1);
4667 if (it
.current_y
> it
.last_visible_y
)
4668 /* The last line was only partially visible, so back up two
4669 lines to make sure we're on a fully visible line. */
4671 move_it_by_lines (&it
, -2, 0);
4672 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4675 /* No, the position we saved is OK, so use it. */
4676 SET_PT_BOTH (charpos
, bytepos
);
4682 /* Implementation of window_scroll that works based on screen lines.
4683 See the comment of window_scroll for parameter descriptions. */
4686 window_scroll_line_based (window
, n
, whole
, noerror
)
4692 register struct window
*w
= XWINDOW (window
);
4693 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4694 register int pos
, pos_byte
;
4695 register int ht
= window_internal_height (w
);
4696 register Lisp_Object tem
;
4700 struct position posit
;
4703 /* If scrolling screen-fulls, compute the number of lines to
4704 scroll from the window's height. */
4706 n
*= max (1, ht
- next_screen_context_lines
);
4708 startpos
= marker_position (w
->start
);
4710 posit
= *compute_motion (startpos
, 0, 0, 0,
4712 window_box_text_cols (w
), XINT (w
->hscroll
),
4714 original_vpos
= posit
.vpos
;
4716 XSETFASTINT (tem
, PT
);
4717 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4721 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4726 lose
= n
< 0 && PT
== BEGV
;
4727 Fvertical_motion (make_number (n
), window
);
4731 SET_PT_BOTH (opoint
, opoint_byte
);
4738 Fsignal (Qbeginning_of_buffer
, Qnil
);
4743 int this_scroll_margin
= scroll_margin
;
4745 /* Don't use a scroll margin that is negative or too large. */
4746 if (this_scroll_margin
< 0)
4747 this_scroll_margin
= 0;
4749 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
4750 this_scroll_margin
= XINT (w
->total_lines
) / 4;
4752 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4753 w
->start_at_line_beg
= bolp
;
4754 w
->update_mode_line
= Qt
;
4755 XSETFASTINT (w
->last_modified
, 0);
4756 XSETFASTINT (w
->last_overlay_modified
, 0);
4757 /* Set force_start so that redisplay_window will run
4758 the window-scroll-functions. */
4759 w
->force_start
= Qt
;
4761 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4763 SET_PT_BOTH (pos
, pos_byte
);
4764 Fvertical_motion (make_number (original_vpos
), window
);
4766 /* If we scrolled forward, put point enough lines down
4767 that it is outside the scroll margin. */
4772 if (this_scroll_margin
> 0)
4774 SET_PT_BOTH (pos
, pos_byte
);
4775 Fvertical_motion (make_number (this_scroll_margin
), window
);
4781 if (top_margin
<= opoint
)
4782 SET_PT_BOTH (opoint
, opoint_byte
);
4783 else if (!NILP (Vscroll_preserve_screen_position
))
4785 SET_PT_BOTH (pos
, pos_byte
);
4786 Fvertical_motion (make_number (original_vpos
), window
);
4789 SET_PT (top_margin
);
4795 /* If we scrolled backward, put point near the end of the window
4796 but not within the scroll margin. */
4797 SET_PT_BOTH (pos
, pos_byte
);
4798 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4799 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4802 bottom_margin
= PT
+ 1;
4804 if (bottom_margin
> opoint
)
4805 SET_PT_BOTH (opoint
, opoint_byte
);
4808 if (!NILP (Vscroll_preserve_screen_position
))
4810 SET_PT_BOTH (pos
, pos_byte
);
4811 Fvertical_motion (make_number (original_vpos
), window
);
4814 Fvertical_motion (make_number (-1), window
);
4823 Fsignal (Qend_of_buffer
, Qnil
);
4828 /* Scroll selected_window up or down. If N is nil, scroll a
4829 screen-full which is defined as the height of the window minus
4830 next_screen_context_lines. If N is the symbol `-', scroll.
4831 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4832 up. This is the guts of Fscroll_up and Fscroll_down. */
4835 scroll_command (n
, direction
)
4839 int count
= SPECPDL_INDEX ();
4841 xassert (abs (direction
) == 1);
4843 /* If selected window's buffer isn't current, make it current for
4844 the moment. But don't screw up if window_scroll gets an error. */
4845 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4847 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4848 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4850 /* Make redisplay consider other windows than just selected_window. */
4851 ++windows_or_buffers_changed
;
4855 window_scroll (selected_window
, direction
, 1, 0);
4856 else if (EQ (n
, Qminus
))
4857 window_scroll (selected_window
, -direction
, 1, 0);
4860 n
= Fprefix_numeric_value (n
);
4861 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4864 unbind_to (count
, Qnil
);
4867 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
4868 doc
: /* Scroll text of current window upward ARG lines.
4869 If ARG is omitted or nil, scroll upward by a near full screen.
4870 A near full screen is `next-screen-context-lines' less than a full screen.
4871 Negative ARG means scroll downward.
4872 If ARG is the atom `-', scroll downward by nearly full screen.
4873 When calling from a program, supply as argument a number, nil, or `-'. */)
4877 scroll_command (arg
, 1);
4881 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
4882 doc
: /* Scroll text of current window down ARG lines.
4883 If ARG is omitted or nil, scroll down by a near full screen.
4884 A near full screen is `next-screen-context-lines' less than a full screen.
4885 Negative ARG means scroll upward.
4886 If ARG is the atom `-', scroll upward by nearly full screen.
4887 When calling from a program, supply as argument a number, nil, or `-'. */)
4891 scroll_command (arg
, -1);
4895 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4896 doc
: /* Return the other window for \"other window scroll\" commands.
4897 If `other-window-scroll-buffer' is non-nil, a window
4898 showing that buffer is used.
4899 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4900 specifies the window. This takes precedence over
4901 `other-window-scroll-buffer'. */)
4906 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4907 && !NILP (Vminibuf_scroll_window
))
4908 window
= Vminibuf_scroll_window
;
4909 /* If buffer is specified, scroll that buffer. */
4910 else if (!NILP (Vother_window_scroll_buffer
))
4912 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4914 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4918 /* Nothing specified; look for a neighboring window on the same
4920 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4922 if (EQ (window
, selected_window
))
4923 /* That didn't get us anywhere; look for a window on another
4926 window
= Fnext_window (window
, Qnil
, Qt
);
4927 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4928 && ! EQ (window
, selected_window
));
4931 CHECK_LIVE_WINDOW (window
);
4933 if (EQ (window
, selected_window
))
4934 error ("There is no other window");
4939 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4940 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4941 A near full screen is `next-screen-context-lines' less than a full screen.
4942 The next window is the one below the current one; or the one at the top
4943 if the current one is at the bottom. Negative ARG means scroll downward.
4944 If ARG is the atom `-', scroll downward by nearly full screen.
4945 When calling from a program, supply as argument a number, nil, or `-'.
4947 If `other-window-scroll-buffer' is non-nil, scroll the window
4948 showing that buffer, popping the buffer up if necessary.
4949 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4950 specifies the window to scroll. This takes precedence over
4951 `other-window-scroll-buffer'. */)
4957 int count
= SPECPDL_INDEX ();
4959 window
= Fother_window_for_scrolling ();
4960 w
= XWINDOW (window
);
4962 /* Don't screw up if window_scroll gets an error. */
4963 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4964 ++windows_or_buffers_changed
;
4966 Fset_buffer (w
->buffer
);
4967 SET_PT (marker_position (w
->pointm
));
4970 window_scroll (window
, 1, 1, 1);
4971 else if (EQ (arg
, Qminus
))
4972 window_scroll (window
, -1, 1, 1);
4978 window_scroll (window
, XINT (arg
), 0, 1);
4981 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4982 unbind_to (count
, Qnil
);
4987 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
4988 doc
: /* Scroll selected window display ARG columns left.
4989 Default for ARG is window width minus 2.
4990 Value is the total amount of leftward horizontal scrolling in
4991 effect after the change.
4992 If `automatic-hscrolling' is non-nil, the argument ARG modifies
4993 a lower bound for automatic scrolling, i.e. automatic scrolling
4994 will not scroll a window to a column less than the value returned
4995 by this function. */)
4997 register Lisp_Object arg
;
5001 struct window
*w
= XWINDOW (selected_window
);
5004 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5006 arg
= Fprefix_numeric_value (arg
);
5008 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5009 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5011 if (interactive_p (0))
5012 w
->min_hscroll
= w
->hscroll
;
5017 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
5018 doc
: /* Scroll selected window display ARG columns right.
5019 Default for ARG is window width minus 2.
5020 Value is the total amount of leftward horizontal scrolling in
5021 effect after the change.
5022 If `automatic-hscrolling' is non-nil, the argument ARG modifies
5023 a lower bound for automatic scrolling, i.e. automatic scrolling
5024 will not scroll a window to a column less than the value returned
5025 by this function. */)
5027 register Lisp_Object arg
;
5031 struct window
*w
= XWINDOW (selected_window
);
5034 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5036 arg
= Fprefix_numeric_value (arg
);
5038 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5039 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5041 if (interactive_p (0))
5042 w
->min_hscroll
= w
->hscroll
;
5047 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5048 doc
: /* Return the window which was selected when entering the minibuffer.
5049 Returns nil, if current window is not a minibuffer window. */)
5052 if (minibuf_level
> 0
5053 && MINI_WINDOW_P (XWINDOW (selected_window
))
5054 && WINDOW_LIVE_P (minibuf_selected_window
))
5055 return minibuf_selected_window
;
5060 /* Value is the number of lines actually displayed in window W,
5061 as opposed to its height. */
5064 displayed_window_lines (w
)
5068 struct text_pos start
;
5069 int height
= window_box_height (w
);
5070 struct buffer
*old_buffer
;
5073 if (XBUFFER (w
->buffer
) != current_buffer
)
5075 old_buffer
= current_buffer
;
5076 set_buffer_internal (XBUFFER (w
->buffer
));
5081 /* In case W->start is out of the accessible range, do something
5082 reasonable. This happens in Info mode when Info-scroll-down
5083 calls (recenter -1) while W->start is 1. */
5084 if (XMARKER (w
->start
)->charpos
< BEGV
)
5085 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5086 else if (XMARKER (w
->start
)->charpos
> ZV
)
5087 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5089 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5091 start_display (&it
, w
, start
);
5092 move_it_vertically (&it
, height
);
5093 bottom_y
= line_bottom_y (&it
);
5095 /* rms: On a non-window display,
5096 the value of it.vpos at the bottom of the screen
5097 seems to be 1 larger than window_box_height (w).
5098 This kludge fixes a bug whereby (move-to-window-line -1)
5099 when ZV is on the last screen line
5100 moves to the previous screen line instead of the last one. */
5101 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5104 /* Add in empty lines at the bottom of the window. */
5105 if (bottom_y
< height
)
5107 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5108 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5112 set_buffer_internal (old_buffer
);
5118 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5119 doc
: /* Center point in window and redisplay frame.
5120 With prefix argument ARG, recenter putting point on screen line ARG
5121 relative to the current window. If ARG is negative, it counts up from the
5122 bottom of the window. (ARG should be less than the height of the window.)
5124 If ARG is omitted or nil, erase the entire frame and then
5125 redraw with point in the center of the current window.
5126 Just C-u as prefix means put point in the center of the window
5127 and redisplay normally--don't erase and redraw the frame. */)
5129 register Lisp_Object arg
;
5131 struct window
*w
= XWINDOW (selected_window
);
5132 struct buffer
*buf
= XBUFFER (w
->buffer
);
5133 struct buffer
*obuf
= current_buffer
;
5135 int charpos
, bytepos
;
5137 /* If redisplay is suppressed due to an error, try again. */
5138 obuf
->display_error_modiff
= 0;
5144 /* Invalidate pixel data calculated for all compositions. */
5145 for (i
= 0; i
< n_compositions
; i
++)
5146 composition_table
[i
]->font
= NULL
;
5148 Fredraw_frame (w
->frame
);
5149 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5152 else if (CONSP (arg
)) /* Just C-u. */
5156 arg
= Fprefix_numeric_value (arg
);
5160 set_buffer_internal (buf
);
5162 /* Handle centering on a graphical frame specially. Such frames can
5163 have variable-height lines and centering point on the basis of
5164 line counts would lead to strange effects. */
5165 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5172 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5173 start_display (&it
, w
, pt
);
5174 move_it_vertically (&it
, - window_box_height (w
) / 2);
5175 charpos
= IT_CHARPOS (it
);
5176 bytepos
= IT_BYTEPOS (it
);
5178 else if (XINT (arg
) < 0)
5182 int y0
, y1
, h
, nlines
;
5184 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5185 start_display (&it
, w
, pt
);
5188 /* The amount of pixels we have to move back is the window
5189 height minus what's displayed in the line containing PT,
5190 and the lines below. */
5191 nlines
= - XINT (arg
) - 1;
5192 move_it_by_lines (&it
, nlines
, 1);
5194 y1
= line_bottom_y (&it
);
5196 /* If we can't move down NLINES lines because we hit
5197 the end of the buffer, count in some empty lines. */
5198 if (it
.vpos
< nlines
)
5199 y1
+= (nlines
- it
.vpos
) * FRAME_LINE_HEIGHT (it
.f
);
5201 h
= window_box_height (w
) - (y1
- y0
);
5203 start_display (&it
, w
, pt
);
5204 move_it_vertically (&it
, - h
);
5205 charpos
= IT_CHARPOS (it
);
5206 bytepos
= IT_BYTEPOS (it
);
5210 struct position pos
;
5211 pos
= *vmotion (PT
, - XINT (arg
), w
);
5212 charpos
= pos
.bufpos
;
5213 bytepos
= pos
.bytepos
;
5218 struct position pos
;
5219 int ht
= window_internal_height (w
);
5222 arg
= make_number (ht
/ 2);
5223 else if (XINT (arg
) < 0)
5224 arg
= make_number (XINT (arg
) + ht
);
5226 pos
= *vmotion (PT
, - XINT (arg
), w
);
5227 charpos
= pos
.bufpos
;
5228 bytepos
= pos
.bytepos
;
5231 /* Set the new window start. */
5232 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5233 w
->window_end_valid
= Qnil
;
5235 w
->optional_new_start
= Qt
;
5237 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5238 w
->start_at_line_beg
= Qt
;
5240 w
->start_at_line_beg
= Qnil
;
5242 set_buffer_internal (obuf
);
5247 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5249 doc
: /* Return the height in lines of the text display area of WINDOW.
5250 This doesn't include the mode-line (or header-line if any) or any
5251 partial-height lines in the text display area. */)
5255 struct window
*w
= decode_window (window
);
5256 int pixel_height
= window_box_height (w
);
5257 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5258 return make_number (line_height
);
5263 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5265 doc
: /* Position point relative to window.
5266 With no argument, position point at center of window.
5267 An argument specifies vertical position within the window;
5268 zero means top of window, negative means relative to bottom of window. */)
5272 struct window
*w
= XWINDOW (selected_window
);
5276 window
= selected_window
;
5277 start
= marker_position (w
->start
);
5278 if (start
< BEGV
|| start
> ZV
)
5280 int height
= window_internal_height (w
);
5281 Fvertical_motion (make_number (- (height
/ 2)), window
);
5282 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5283 w
->start_at_line_beg
= Fbolp ();
5284 w
->force_start
= Qt
;
5287 Fgoto_char (w
->start
);
5289 lines
= displayed_window_lines (w
);
5291 XSETFASTINT (arg
, lines
/ 2);
5294 arg
= Fprefix_numeric_value (arg
);
5296 XSETINT (arg
, XINT (arg
) + lines
);
5299 /* Skip past a partially visible first line. */
5301 XSETINT (arg
, XINT (arg
) + 1);
5303 return Fvertical_motion (arg
, window
);
5308 /***********************************************************************
5309 Window Configuration
5310 ***********************************************************************/
5312 struct save_window_data
5314 EMACS_INT size_from_Lisp_Vector_struct
;
5315 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5316 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5317 Lisp_Object frame_tool_bar_lines
;
5318 Lisp_Object selected_frame
;
5319 Lisp_Object current_window
;
5320 Lisp_Object current_buffer
;
5321 Lisp_Object minibuf_scroll_window
;
5322 Lisp_Object minibuf_selected_window
;
5323 Lisp_Object root_window
;
5324 Lisp_Object focus_frame
;
5325 /* Record the values of window-min-width and window-min-height
5326 so that window sizes remain consistent with them. */
5327 Lisp_Object min_width
, min_height
;
5328 /* A vector, each of whose elements is a struct saved_window
5330 Lisp_Object saved_windows
;
5333 /* This is saved as a Lisp_Vector */
5336 /* these first two must agree with struct Lisp_Vector in lisp.h */
5337 EMACS_INT size_from_Lisp_Vector_struct
;
5338 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5341 Lisp_Object buffer
, start
, pointm
, mark
;
5342 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5343 Lisp_Object hscroll
, min_hscroll
;
5344 Lisp_Object parent
, prev
;
5345 Lisp_Object start_at_line_beg
;
5346 Lisp_Object display_table
;
5347 Lisp_Object orig_top_line
, orig_total_lines
;
5348 Lisp_Object left_margin_cols
, right_margin_cols
;
5349 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5350 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5353 #define SAVED_WINDOW_VECTOR_SIZE 24 /* Arg to Fmake_vector */
5355 #define SAVED_WINDOW_N(swv,n) \
5356 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5358 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5359 doc
: /* Return t if OBJECT is a window-configuration object. */)
5363 if (WINDOW_CONFIGURATIONP (object
))
5368 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5369 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5373 register struct save_window_data
*data
;
5374 struct Lisp_Vector
*saved_windows
;
5376 if (! WINDOW_CONFIGURATIONP (config
))
5377 wrong_type_argument (Qwindow_configuration_p
, config
);
5379 data
= (struct save_window_data
*) XVECTOR (config
);
5380 saved_windows
= XVECTOR (data
->saved_windows
);
5381 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5384 DEFUN ("set-window-configuration", Fset_window_configuration
,
5385 Sset_window_configuration
, 1, 1, 0,
5386 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5387 CONFIGURATION must be a value previously returned
5388 by `current-window-configuration' (which see).
5389 If CONFIGURATION was made from a frame that is now deleted,
5390 only frame-independent values can be restored. In this case,
5391 the return value is nil. Otherwise the value is t. */)
5393 Lisp_Object configuration
;
5395 register struct save_window_data
*data
;
5396 struct Lisp_Vector
*saved_windows
;
5397 Lisp_Object new_current_buffer
;
5402 while (!WINDOW_CONFIGURATIONP (configuration
))
5403 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5405 data
= (struct save_window_data
*) XVECTOR (configuration
);
5406 saved_windows
= XVECTOR (data
->saved_windows
);
5408 new_current_buffer
= data
->current_buffer
;
5409 if (NILP (XBUFFER (new_current_buffer
)->name
))
5410 new_current_buffer
= Qnil
;
5413 if (XBUFFER (new_current_buffer
) == current_buffer
)
5416 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5419 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5422 /* If f is a dead frame, don't bother rebuilding its window tree.
5423 However, there is other stuff we should still try to do below. */
5424 if (FRAME_LIVE_P (f
))
5426 register struct window
*w
;
5427 register struct saved_window
*p
;
5428 struct window
*root_window
;
5429 struct window
**leaf_windows
;
5433 /* If the frame has been resized since this window configuration was
5434 made, we change the frame to the size specified in the
5435 configuration, restore the configuration, and then resize it
5436 back. We keep track of the prevailing height in these variables. */
5437 int previous_frame_lines
= FRAME_LINES (f
);
5438 int previous_frame_cols
= FRAME_COLS (f
);
5439 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5440 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5442 /* The mouse highlighting code could get screwed up
5443 if it runs during this. */
5446 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5447 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5448 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5449 XFASTINT (data
->frame_cols
), 0, 0, 0);
5450 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5451 if (XFASTINT (data
->frame_menu_bar_lines
)
5452 != previous_frame_menu_bar_lines
)
5453 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5454 #ifdef HAVE_WINDOW_SYSTEM
5455 if (XFASTINT (data
->frame_tool_bar_lines
)
5456 != previous_frame_tool_bar_lines
)
5457 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5461 /* "Swap out" point from the selected window
5462 into its buffer. We do this now, before
5463 restoring the window contents, and prevent it from
5464 being done later on when we select a new window. */
5465 if (! NILP (XWINDOW (selected_window
)->buffer
))
5467 w
= XWINDOW (selected_window
);
5468 set_marker_both (w
->pointm
,
5470 BUF_PT (XBUFFER (w
->buffer
)),
5471 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5474 windows_or_buffers_changed
++;
5475 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5477 /* Problem: Freeing all matrices and later allocating them again
5478 is a serious redisplay flickering problem. What we would
5479 really like to do is to free only those matrices not reused
5481 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5483 = (struct window
**) alloca (count_windows (root_window
)
5484 * sizeof (struct window
*));
5485 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5487 /* Temporarily avoid any problems with windows that are smaller
5488 than they are supposed to be. */
5489 window_min_height
= 1;
5490 window_min_width
= 1;
5493 Mark all windows now on frame as "deleted".
5494 Restoring the new configuration "undeletes" any that are in it.
5496 Save their current buffers in their height fields, since we may
5497 need it later, if a buffer saved in the configuration is now
5499 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5501 for (k
= 0; k
< saved_windows
->size
; k
++)
5503 p
= SAVED_WINDOW_N (saved_windows
, k
);
5504 w
= XWINDOW (p
->window
);
5507 if (!NILP (p
->parent
))
5508 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5509 XFASTINT (p
->parent
))->window
;
5513 if (!NILP (p
->prev
))
5515 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5516 XFASTINT (p
->prev
))->window
;
5517 XWINDOW (w
->prev
)->next
= p
->window
;
5522 if (!NILP (w
->parent
))
5524 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5526 XWINDOW (w
->parent
)->vchild
= p
->window
;
5527 XWINDOW (w
->parent
)->hchild
= Qnil
;
5531 XWINDOW (w
->parent
)->hchild
= p
->window
;
5532 XWINDOW (w
->parent
)->vchild
= Qnil
;
5537 /* If we squirreled away the buffer in the window's height,
5539 if (BUFFERP (w
->total_lines
))
5540 w
->buffer
= w
->total_lines
;
5541 w
->left_col
= p
->left_col
;
5542 w
->top_line
= p
->top_line
;
5543 w
->total_cols
= p
->total_cols
;
5544 w
->total_lines
= p
->total_lines
;
5545 w
->hscroll
= p
->hscroll
;
5546 w
->min_hscroll
= p
->min_hscroll
;
5547 w
->display_table
= p
->display_table
;
5548 w
->orig_top_line
= p
->orig_top_line
;
5549 w
->orig_total_lines
= p
->orig_total_lines
;
5550 w
->left_margin_cols
= p
->left_margin_cols
;
5551 w
->right_margin_cols
= p
->right_margin_cols
;
5552 w
->left_fringe_width
= p
->left_fringe_width
;
5553 w
->right_fringe_width
= p
->right_fringe_width
;
5554 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5555 w
->scroll_bar_width
= p
->scroll_bar_width
;
5556 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5557 XSETFASTINT (w
->last_modified
, 0);
5558 XSETFASTINT (w
->last_overlay_modified
, 0);
5560 /* Reinstall the saved buffer and pointers into it. */
5561 if (NILP (p
->buffer
))
5562 w
->buffer
= p
->buffer
;
5565 if (!NILP (XBUFFER (p
->buffer
)->name
))
5566 /* If saved buffer is alive, install it. */
5568 w
->buffer
= p
->buffer
;
5569 w
->start_at_line_beg
= p
->start_at_line_beg
;
5570 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5571 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5572 Fset_marker (XBUFFER (w
->buffer
)->mark
,
5573 p
->mark
, w
->buffer
);
5575 /* As documented in Fcurrent_window_configuration, don't
5576 restore the location of point in the buffer which was
5577 current when the window configuration was recorded. */
5578 if (!EQ (p
->buffer
, new_current_buffer
)
5579 && XBUFFER (p
->buffer
) == current_buffer
)
5580 Fgoto_char (w
->pointm
);
5582 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
5583 /* Else unless window has a live buffer, get one. */
5585 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5586 /* This will set the markers to beginning of visible
5588 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5589 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5590 w
->start_at_line_beg
= Qt
;
5593 /* Keeping window's old buffer; make sure the markers
5596 /* Set window markers at start of visible range. */
5597 if (XMARKER (w
->start
)->buffer
== 0)
5598 set_marker_restricted (w
->start
, make_number (0),
5600 if (XMARKER (w
->pointm
)->buffer
== 0)
5601 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5602 BUF_PT (XBUFFER (w
->buffer
)),
5603 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5604 w
->start_at_line_beg
= Qt
;
5609 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5610 /* Prevent "swapping out point" in the old selected window
5611 using the buffer that has been restored into it.
5612 Use the point value from the beginning of this function
5613 since unshow_buffer (called from delete_all_subwindows)
5614 could have altered it. */
5615 selected_window
= Qnil
;
5616 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5617 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5618 make_number (old_point
),
5619 XWINDOW (data
->current_window
)->buffer
);
5621 Fselect_window (data
->current_window
, Qnil
);
5622 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
5625 if (NILP (data
->focus_frame
)
5626 || (FRAMEP (data
->focus_frame
)
5627 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5628 Fredirect_frame_focus (frame
, data
->focus_frame
);
5630 #if 0 /* I don't understand why this is needed, and it causes problems
5631 when the frame's old selected window has been deleted. */
5632 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
5633 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5637 /* Set the screen height to the value it had before this function. */
5638 if (previous_frame_lines
!= FRAME_LINES (f
)
5639 || previous_frame_cols
!= FRAME_COLS (f
))
5640 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5642 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5643 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5644 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5646 #ifdef HAVE_WINDOW_SYSTEM
5647 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5648 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5653 /* Now, free glyph matrices in windows that were not reused. */
5654 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5656 if (NILP (leaf_windows
[i
]->buffer
))
5658 /* Assert it's not reused as a combination. */
5659 xassert (NILP (leaf_windows
[i
]->hchild
)
5660 && NILP (leaf_windows
[i
]->vchild
));
5661 free_window_matrices (leaf_windows
[i
]);
5663 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5671 /* Fselect_window will have made f the selected frame, so we
5672 reselect the proper frame here. Fhandle_switch_frame will change the
5673 selected window too, but that doesn't make the call to
5674 Fselect_window above totally superfluous; it still sets f's
5676 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5677 do_switch_frame (data
->selected_frame
, 0, 0);
5679 if (! NILP (Vwindow_configuration_change_hook
)
5680 && ! NILP (Vrun_hooks
))
5681 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5684 if (!NILP (new_current_buffer
))
5685 Fset_buffer (new_current_buffer
);
5687 /* Restore the minimum heights recorded in the configuration. */
5688 window_min_height
= XINT (data
->min_height
);
5689 window_min_width
= XINT (data
->min_width
);
5691 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5692 minibuf_selected_window
= data
->minibuf_selected_window
;
5694 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5697 /* Mark all windows now on frame as deleted
5698 by setting their buffers to nil. */
5701 delete_all_subwindows (w
)
5702 register struct window
*w
;
5704 if (!NILP (w
->next
))
5705 delete_all_subwindows (XWINDOW (w
->next
));
5706 if (!NILP (w
->vchild
))
5707 delete_all_subwindows (XWINDOW (w
->vchild
));
5708 if (!NILP (w
->hchild
))
5709 delete_all_subwindows (XWINDOW (w
->hchild
));
5711 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5713 if (!NILP (w
->buffer
))
5716 /* We set all three of these fields to nil, to make sure that we can
5717 distinguish this dead window from any live window. Live leaf
5718 windows will have buffer set, and combination windows will have
5719 vchild or hchild set. */
5724 Vwindow_list
= Qnil
;
5728 count_windows (window
)
5729 register struct window
*window
;
5731 register int count
= 1;
5732 if (!NILP (window
->next
))
5733 count
+= count_windows (XWINDOW (window
->next
));
5734 if (!NILP (window
->vchild
))
5735 count
+= count_windows (XWINDOW (window
->vchild
));
5736 if (!NILP (window
->hchild
))
5737 count
+= count_windows (XWINDOW (window
->hchild
));
5742 /* Fill vector FLAT with leaf windows under W, starting at index I.
5743 Value is last index + 1. */
5746 get_leaf_windows (w
, flat
, i
)
5748 struct window
**flat
;
5753 if (!NILP (w
->hchild
))
5754 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5755 else if (!NILP (w
->vchild
))
5756 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5760 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5767 /* Return a pointer to the glyph W's physical cursor is on. Value is
5768 null if W's current matrix is invalid, so that no meaningfull glyph
5772 get_phys_cursor_glyph (w
)
5775 struct glyph_row
*row
;
5776 struct glyph
*glyph
;
5778 if (w
->phys_cursor
.vpos
>= 0
5779 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5780 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5782 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5783 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5792 save_window_save (window
, vector
, i
)
5794 struct Lisp_Vector
*vector
;
5797 register struct saved_window
*p
;
5798 register struct window
*w
;
5799 register Lisp_Object tem
;
5801 for (;!NILP (window
); window
= w
->next
)
5803 p
= SAVED_WINDOW_N (vector
, i
);
5804 w
= XWINDOW (window
);
5806 XSETFASTINT (w
->temslot
, i
++);
5808 p
->buffer
= w
->buffer
;
5809 p
->left_col
= w
->left_col
;
5810 p
->top_line
= w
->top_line
;
5811 p
->total_cols
= w
->total_cols
;
5812 p
->total_lines
= w
->total_lines
;
5813 p
->hscroll
= w
->hscroll
;
5814 p
->min_hscroll
= w
->min_hscroll
;
5815 p
->display_table
= w
->display_table
;
5816 p
->orig_top_line
= w
->orig_top_line
;
5817 p
->orig_total_lines
= w
->orig_total_lines
;
5818 p
->left_margin_cols
= w
->left_margin_cols
;
5819 p
->right_margin_cols
= w
->right_margin_cols
;
5820 p
->left_fringe_width
= w
->left_fringe_width
;
5821 p
->right_fringe_width
= w
->right_fringe_width
;
5822 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
5823 p
->scroll_bar_width
= w
->scroll_bar_width
;
5824 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
5825 if (!NILP (w
->buffer
))
5827 /* Save w's value of point in the window configuration.
5828 If w is the selected window, then get the value of point
5829 from the buffer; pointm is garbage in the selected window. */
5830 if (EQ (window
, selected_window
))
5832 p
->pointm
= Fmake_marker ();
5833 set_marker_both (p
->pointm
, w
->buffer
,
5834 BUF_PT (XBUFFER (w
->buffer
)),
5835 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5838 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5840 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5841 p
->start_at_line_beg
= w
->start_at_line_beg
;
5843 tem
= XBUFFER (w
->buffer
)->mark
;
5844 p
->mark
= Fcopy_marker (tem
, Qnil
);
5851 p
->start_at_line_beg
= Qnil
;
5854 if (NILP (w
->parent
))
5857 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5862 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5864 if (!NILP (w
->vchild
))
5865 i
= save_window_save (w
->vchild
, vector
, i
);
5866 if (!NILP (w
->hchild
))
5867 i
= save_window_save (w
->hchild
, vector
, i
);
5873 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5874 Scurrent_window_configuration
, 0, 1, 0,
5875 doc
: /* Return an object representing the current window configuration of FRAME.
5876 If FRAME is nil or omitted, use the selected frame.
5877 This describes the number of windows, their sizes and current buffers,
5878 and for each displayed buffer, where display starts, and the positions of
5879 point and mark. An exception is made for point in the current buffer:
5880 its value is -not- saved.
5881 This also records the currently selected frame, and FRAME's focus
5882 redirection (see `redirect-frame-focus'). */)
5886 register Lisp_Object tem
;
5887 register int n_windows
;
5888 register struct save_window_data
*data
;
5889 register struct Lisp_Vector
*vec
;
5894 frame
= selected_frame
;
5895 CHECK_LIVE_FRAME (frame
);
5898 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5899 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
5900 data
= (struct save_window_data
*)vec
;
5902 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
5903 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
5904 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
5905 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
5906 data
->selected_frame
= selected_frame
;
5907 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5908 XSETBUFFER (data
->current_buffer
, current_buffer
);
5909 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
5910 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
5911 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5912 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5913 XSETINT (data
->min_height
, window_min_height
);
5914 XSETINT (data
->min_width
, window_min_width
);
5915 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5916 data
->saved_windows
= tem
;
5917 for (i
= 0; i
< n_windows
; i
++)
5918 XVECTOR (tem
)->contents
[i
]
5919 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
5920 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5921 XSETWINDOW_CONFIGURATION (tem
, data
);
5925 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
5927 doc
: /* Execute BODY, preserving window sizes and contents.
5928 Return the value of the last form in BODY.
5929 Restore which buffer appears in which window, where display starts,
5930 and the value of point and mark for each window.
5931 Also restore the choice of selected window.
5932 Also restore which buffer is current.
5933 Does not restore the value of point in current buffer.
5934 usage: (save-window-excursion BODY ...) */)
5938 register Lisp_Object val
;
5939 register int count
= SPECPDL_INDEX ();
5941 record_unwind_protect (Fset_window_configuration
,
5942 Fcurrent_window_configuration (Qnil
));
5943 val
= Fprogn (args
);
5944 return unbind_to (count
, val
);
5948 /***********************************************************************
5950 ***********************************************************************/
5952 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5954 doc
: /* Set width of marginal areas of window WINDOW.
5955 If WINDOW is nil, set margins of the currently selected window.
5956 Second arg LEFT-WIDTH specifies the number of character cells to
5957 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
5958 does the same for the right marginal area. A nil width parameter
5959 means no margin. */)
5960 (window
, left
, right
)
5961 Lisp_Object window
, left
, right
;
5963 struct window
*w
= decode_window (window
);
5965 /* Translate negative or zero widths to nil.
5966 Margins that are too wide have to be checked elsewhere. */
5970 CHECK_NUMBER (left
);
5971 if (XINT (left
) <= 0)
5977 CHECK_NUMBER (right
);
5978 if (XINT (right
) <= 0)
5982 if (!EQ (w
->left_margin_cols
, left
)
5983 || !EQ (w
->right_margin_cols
, right
))
5985 w
->left_margin_cols
= left
;
5986 w
->right_margin_cols
= right
;
5988 adjust_window_margins (w
);
5990 ++windows_or_buffers_changed
;
5991 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
5998 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6000 doc
: /* Get width of marginal areas of window WINDOW.
6001 If WINDOW is omitted or nil, use the currently selected window.
6002 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6003 If a marginal area does not exist, its width will be returned
6008 struct window
*w
= decode_window (window
);
6009 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6014 /***********************************************************************
6016 ***********************************************************************/
6018 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6020 doc
: /* Set the fringe widths of window WINDOW.
6021 If WINDOW is nil, set the fringe widths of the currently selected
6023 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6024 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6025 fringe width. If a fringe width arg is nil, that means to use the
6026 frame's default fringe width. Default fringe widths can be set with
6027 the command `set-fringe-style'.
6028 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6029 outside of the display margins. By default, fringes are drawn between
6030 display marginal areas and the text area. */)
6031 (window
, left
, right
, outside_margins
)
6032 Lisp_Object window
, left
, right
, outside_margins
;
6034 struct window
*w
= decode_window (window
);
6037 CHECK_NUMBER (left
);
6039 CHECK_NUMBER (right
);
6041 if (!EQ (w
->left_fringe_width
, left
)
6042 || !EQ (w
->right_fringe_width
, right
)
6043 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6045 w
->left_fringe_width
= left
;
6046 w
->right_fringe_width
= right
;
6047 w
->fringes_outside_margins
= outside_margins
;
6049 adjust_window_margins (w
);
6051 clear_glyph_matrix (w
->current_matrix
);
6052 w
->window_end_valid
= Qnil
;
6054 ++windows_or_buffers_changed
;
6055 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6062 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6064 doc
: /* Get width of fringes of window WINDOW.
6065 If WINDOW is omitted or nil, use the currently selected window.
6066 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6070 struct window
*w
= decode_window (window
);
6071 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6072 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6073 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6074 Qt
: Qnil
), Qnil
)));
6079 /***********************************************************************
6081 ***********************************************************************/
6083 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6085 doc
: /* Set width and type of scroll bars of window WINDOW.
6086 If window is nil, set scroll bars of the currently selected window.
6087 Second parameter WIDTH specifies the pixel width for the scroll bar;
6088 this is automatically adjusted to a multiple of the frame column width.
6089 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6090 bar: left, right, or nil.
6091 If WIDTH is nil, use the frame's scroll-bar width.
6092 If TYPE is t, use the frame's scroll-bar type. */)
6093 (window
, width
, vertical_type
, horizontal_type
)
6094 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6096 struct window
*w
= decode_window (window
);
6099 CHECK_NUMBER (width
);
6101 if (XINT (width
) == 0)
6102 vertical_type
= Qnil
;
6104 if (!(EQ (vertical_type
, Qnil
)
6105 || EQ (vertical_type
, Qleft
)
6106 || EQ (vertical_type
, Qright
)
6107 || EQ (vertical_type
, Qt
)))
6108 error ("Invalid type of vertical scroll bar");
6110 if (!EQ (w
->scroll_bar_width
, width
)
6111 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6113 w
->scroll_bar_width
= width
;
6114 w
->vertical_scroll_bar_type
= vertical_type
;
6116 adjust_window_margins (w
);
6118 clear_glyph_matrix (w
->current_matrix
);
6119 w
->window_end_valid
= Qnil
;
6121 ++windows_or_buffers_changed
;
6122 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6129 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6131 doc
: /* Get width and type of scroll bars of window WINDOW.
6132 If WINDOW is omitted or nil, use the currently selected window.
6133 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6134 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6139 struct window
*w
= decode_window (window
);
6140 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6141 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6142 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6143 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6144 Fcons (w
->vertical_scroll_bar_type
,
6145 Fcons (Qnil
, Qnil
))));
6150 /***********************************************************************
6152 ***********************************************************************/
6154 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6155 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6156 Use the selected window if WINDOW is nil or omitted.
6157 Normally, value is a multiple of the canonical character height of WINDOW;
6158 optional second arg PIXELS_P means value is measured in pixels. */)
6160 Lisp_Object window
, pixels_p
;
6167 window
= selected_window
;
6169 CHECK_WINDOW (window
);
6170 w
= XWINDOW (window
);
6171 f
= XFRAME (w
->frame
);
6173 if (FRAME_WINDOW_P (f
))
6174 result
= (NILP (pixels_p
)
6175 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6176 : make_number (-w
->vscroll
));
6178 result
= make_number (0);
6183 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6185 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6186 WINDOW nil means use the selected window. Normally, VSCROLL is a
6187 non-negative multiple of the canonical character height of WINDOW;
6188 optional third arg PIXELS_P non-nil means that VSCROLL is in pixels.
6189 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6190 corresponds to an integral number of pixels. The return value is the
6191 result of this rounding.
6192 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6193 (window
, vscroll
, pixels_p
)
6194 Lisp_Object window
, vscroll
, pixels_p
;
6200 window
= selected_window
;
6202 CHECK_WINDOW (window
);
6203 CHECK_NUMBER_OR_FLOAT (vscroll
);
6205 w
= XWINDOW (window
);
6206 f
= XFRAME (w
->frame
);
6208 if (FRAME_WINDOW_P (f
))
6210 int old_dy
= w
->vscroll
;
6212 w
->vscroll
= - (NILP (pixels_p
)
6213 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6214 : XFLOATINT (vscroll
));
6215 w
->vscroll
= min (w
->vscroll
, 0);
6217 /* Adjust glyph matrix of the frame if the virtual display
6218 area becomes larger than before. */
6219 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6222 /* Prevent redisplay shortcuts. */
6223 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6226 return Fwindow_vscroll (window
, pixels_p
);
6230 /* Call FN for all leaf windows on frame F. FN is called with the
6231 first argument being a pointer to the leaf window, and with
6232 additional argument USER_DATA. Stops when FN returns 0. */
6235 foreach_window (f
, fn
, user_data
)
6237 int (* fn
) P_ ((struct window
*, void *));
6240 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6244 /* Helper function for foreach_window. Call FN for all leaf windows
6245 reachable from W. FN is called with the first argument being a
6246 pointer to the leaf window, and with additional argument USER_DATA.
6247 Stop when FN returns 0. Value is 0 if stopped by FN. */
6250 foreach_window_1 (w
, fn
, user_data
)
6252 int (* fn
) P_ ((struct window
*, void *));
6257 for (cont
= 1; w
&& cont
;)
6259 if (!NILP (w
->hchild
))
6260 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6261 else if (!NILP (w
->vchild
))
6262 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6264 cont
= fn (w
, user_data
);
6266 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6273 /* Freeze or unfreeze the window start of W unless it is a
6274 mini-window or the selected window. FREEZE_P non-null means freeze
6275 the window start. */
6278 freeze_window_start (w
, freeze_p
)
6282 if (w
== XWINDOW (selected_window
)
6283 || MINI_WINDOW_P (w
)
6284 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6285 && ! NILP (Vminibuf_scroll_window
)
6286 && w
== XWINDOW (Vminibuf_scroll_window
)))
6289 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6294 /* Freeze or unfreeze the window starts of all leaf windows on frame
6295 F, except the selected window and a mini-window. FREEZE_P non-zero
6296 means freeze the window start. */
6299 freeze_window_starts (f
, freeze_p
)
6303 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6307 /***********************************************************************
6309 ***********************************************************************/
6311 /* Return 1 if window configurations C1 and C2
6312 describe the same state of affairs. This is used by Fequal. */
6315 compare_window_configurations (c1
, c2
, ignore_positions
)
6317 int ignore_positions
;
6319 register struct save_window_data
*d1
, *d2
;
6320 struct Lisp_Vector
*sw1
, *sw2
;
6323 if (!WINDOW_CONFIGURATIONP (c1
))
6324 wrong_type_argument (Qwindow_configuration_p
, c1
);
6325 if (!WINDOW_CONFIGURATIONP (c2
))
6326 wrong_type_argument (Qwindow_configuration_p
, c2
);
6328 d1
= (struct save_window_data
*) XVECTOR (c1
);
6329 d2
= (struct save_window_data
*) XVECTOR (c2
);
6330 sw1
= XVECTOR (d1
->saved_windows
);
6331 sw2
= XVECTOR (d2
->saved_windows
);
6333 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6335 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6337 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6339 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6341 /* Don't compare the current_window field directly.
6342 Instead see w1_is_current and w2_is_current, below. */
6343 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6345 if (! ignore_positions
)
6347 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6349 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6352 /* Don't compare the root_window field.
6353 We don't require the two configurations
6354 to use the same window object,
6355 and the two root windows must be equivalent
6356 if everything else compares equal. */
6357 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6359 if (! EQ (d1
->min_width
, d2
->min_width
))
6361 if (! EQ (d1
->min_height
, d2
->min_height
))
6364 /* Verify that the two confis have the same number of windows. */
6365 if (sw1
->size
!= sw2
->size
)
6368 for (i
= 0; i
< sw1
->size
; i
++)
6370 struct saved_window
*p1
, *p2
;
6371 int w1_is_current
, w2_is_current
;
6373 p1
= SAVED_WINDOW_N (sw1
, i
);
6374 p2
= SAVED_WINDOW_N (sw2
, i
);
6376 /* Verify that the current windows in the two
6377 configurations correspond to each other. */
6378 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6379 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6381 if (w1_is_current
!= w2_is_current
)
6384 /* Verify that the corresponding windows do match. */
6385 if (! EQ (p1
->buffer
, p2
->buffer
))
6387 if (! EQ (p1
->left_col
, p2
->left_col
))
6389 if (! EQ (p1
->top_line
, p2
->top_line
))
6391 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6393 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6395 if (! EQ (p1
->display_table
, p2
->display_table
))
6397 if (! EQ (p1
->parent
, p2
->parent
))
6399 if (! EQ (p1
->prev
, p2
->prev
))
6401 if (! ignore_positions
)
6403 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6405 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6407 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6409 if (NILP (Fequal (p1
->start
, p2
->start
)))
6411 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6413 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6416 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6418 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6420 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6422 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6424 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6426 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6428 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6435 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6436 Scompare_window_configurations
, 2, 2, 0,
6437 doc
: /* Compare two window configurations as regards the structure of windows.
6438 This function ignores details such as the values of point and mark
6439 and scrolling positions. */)
6443 if (compare_window_configurations (x
, y
, 1))
6451 struct frame
*f
= make_initial_frame ();
6452 XSETFRAME (selected_frame
, f
);
6453 Vterminal_frame
= selected_frame
;
6454 minibuf_window
= f
->minibuffer_window
;
6455 selected_window
= f
->selected_window
;
6456 last_nonminibuf_frame
= f
;
6458 window_initialized
= 1;
6464 Vwindow_list
= Qnil
;
6470 Qwindow_size_fixed
= intern ("window-size-fixed");
6471 staticpro (&Qwindow_size_fixed
);
6473 staticpro (&Qwindow_configuration_change_hook
);
6474 Qwindow_configuration_change_hook
6475 = intern ("window-configuration-change-hook");
6477 Qwindowp
= intern ("windowp");
6478 staticpro (&Qwindowp
);
6480 Qwindow_configuration_p
= intern ("window-configuration-p");
6481 staticpro (&Qwindow_configuration_p
);
6483 Qwindow_live_p
= intern ("window-live-p");
6484 staticpro (&Qwindow_live_p
);
6486 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
6487 staticpro (&Qtemp_buffer_show_hook
);
6489 staticpro (&Vwindow_list
);
6491 minibuf_selected_window
= Qnil
;
6492 staticpro (&minibuf_selected_window
);
6494 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
6495 doc
: /* Non-nil means call as function to display a help buffer.
6496 The function is called with one argument, the buffer to be displayed.
6497 Used by `with-output-to-temp-buffer'.
6498 If this function is used, then it must do the entire job of showing
6499 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6500 Vtemp_buffer_show_function
= Qnil
;
6502 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
6503 doc
: /* If non-nil, function to call to handle `display-buffer'.
6504 It will receive two args, the buffer and a flag which if non-nil means
6505 that the currently selected window is not acceptable.
6506 It should choose or create a window, display the specified buffer in it,
6507 and return the window.
6508 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
6509 work using this function. */);
6510 Vdisplay_buffer_function
= Qnil
;
6512 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
6513 doc
: /* *If non-nil, `display-buffer' should even the window heights.
6514 If nil, `display-buffer' will leave the window configuration alone. */);
6515 Veven_window_heights
= Qt
;
6517 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
6518 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6519 Vminibuf_scroll_window
= Qnil
;
6521 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
6522 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6523 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6524 is displayed in the `mode-line' face. */);
6525 mode_line_in_non_selected_windows
= 1;
6527 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
6528 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6529 Vother_window_scroll_buffer
= Qnil
;
6531 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
6532 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
6535 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
6536 doc
: /* *Non-nil means `display-buffer' should reuse frames.
6537 If the buffer in question is already displayed in a frame, raise that frame. */);
6538 display_buffer_reuse_frames
= 0;
6540 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
6541 doc
: /* Function to call to handle automatic new frame creation.
6542 It is called with no arguments and should return a newly created frame.
6544 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
6545 where `pop-up-frame-alist' would hold the default frame parameters. */);
6546 Vpop_up_frame_function
= Qnil
;
6548 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
6549 doc
: /* *List of buffer names that should have their own special frames.
6550 Displaying a buffer whose name is in this list makes a special frame for it
6551 using `special-display-function'. See also `special-display-regexps'.
6553 An element of the list can be a list instead of just a string.
6554 There are two ways to use a list as an element:
6555 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
6556 In the first case, the FRAME-PARAMETERS are pairs of the form
6557 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6558 In the second case, FUNCTION is called with BUFFER as the first argument,
6559 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
6560 All this is done by the function found in `special-display-function'.
6562 If the specified frame parameters include (same-buffer . t), the
6563 buffer is displayed in the currently selected window. Otherwise, if
6564 they include (same-frame . t), the buffer is displayed in a new window
6565 in the currently selected frame.
6567 If this variable appears \"not to work\", because you add a name to it
6568 but that buffer still appears in the selected window, look at the
6569 values of `same-window-buffer-names' and `same-window-regexps'.
6570 Those variables take precedence over this one. */);
6571 Vspecial_display_buffer_names
= Qnil
;
6573 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
6574 doc
: /* *List of regexps saying which buffers should have their own special frames.
6575 If a buffer name matches one of these regexps, it gets its own frame.
6576 Displaying a buffer whose name is in this list makes a special frame for it
6577 using `special-display-function'.
6579 An element of the list can be a list instead of just a string.
6580 There are two ways to use a list as an element:
6581 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
6582 In the first case, the FRAME-PARAMETERS are pairs of the form
6583 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6584 In the second case, FUNCTION is called with BUFFER as the first argument,
6585 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
6586 All this is done by the function found in `special-display-function'.
6588 If the specified frame parameters include (same-buffer . t), the
6589 buffer is displayed in the currently selected window. Otherwise, if
6590 they include (same-frame . t), the buffer is displayed in a new window
6591 in the currently selected frame.
6593 If this variable appears \"not to work\", because you add a regexp to it
6594 but the matching buffers still appear in the selected window, look at the
6595 values of `same-window-buffer-names' and `same-window-regexps'.
6596 Those variables take precedence over this one. */);
6597 Vspecial_display_regexps
= Qnil
;
6599 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
6600 doc
: /* Function to call to make a new frame for a special buffer.
6601 It is called with two arguments, the buffer and optional buffer specific
6602 data, and should return a window displaying that buffer.
6603 The default value normally makes a separate frame for the buffer,
6604 using `special-display-frame-alist' to specify the frame parameters.
6605 But if the buffer specific data includes (same-buffer . t) then the
6606 buffer is displayed in the current selected window.
6607 Otherwise if it includes (same-frame . t) then the buffer is displayed in
6608 a new window in the currently selected frame.
6610 A buffer is special if it is listed in `special-display-buffer-names'
6611 or matches a regexp in `special-display-regexps'. */);
6612 Vspecial_display_function
= Qnil
;
6614 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
6615 doc
: /* *List of buffer names that should appear in the selected window.
6616 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
6617 switches to it in the selected window, rather than making it appear
6618 in some other window.
6620 An element of the list can be a cons cell instead of just a string.
6621 Then the car must be a string, which specifies the buffer name.
6622 This is for compatibility with `special-display-buffer-names';
6623 the cdr of the cons cell is ignored.
6625 See also `same-window-regexps'. */);
6626 Vsame_window_buffer_names
= Qnil
;
6628 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
6629 doc
: /* *List of regexps saying which buffers should appear in the selected window.
6630 If a buffer name matches one of these regexps, then displaying it
6631 using `display-buffer' or `pop-to-buffer' switches to it
6632 in the selected window, rather than making it appear in some other window.
6634 An element of the list can be a cons cell instead of just a string.
6635 Then the car must be a string, which specifies the buffer name.
6636 This is for compatibility with `special-display-buffer-names';
6637 the cdr of the cons cell is ignored.
6639 See also `same-window-buffer-names'. */);
6640 Vsame_window_regexps
= Qnil
;
6642 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
6643 doc
: /* *Non-nil means display-buffer should make new windows. */);
6646 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
6647 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
6648 next_screen_context_lines
= 2;
6650 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
6651 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
6652 If there is only one window, it is split regardless of this value. */);
6653 split_height_threshold
= 500;
6655 DEFVAR_INT ("window-min-height", &window_min_height
,
6656 doc
: /* *Delete any window less than this tall (including its mode line). */);
6657 window_min_height
= 4;
6659 DEFVAR_INT ("window-min-width", &window_min_width
,
6660 doc
: /* *Delete any window less than this wide. */);
6661 window_min_width
= 10;
6663 DEFVAR_LISP ("scroll-preserve-screen-position",
6664 &Vscroll_preserve_screen_position
,
6665 doc
: /* *Non-nil means scroll commands move point to keep its screen line unchanged. */);
6666 Vscroll_preserve_screen_position
= Qnil
;
6668 DEFVAR_LISP ("window-configuration-change-hook",
6669 &Vwindow_configuration_change_hook
,
6670 doc
: /* Functions to call when window configuration changes.
6671 The selected frame is the one whose configuration has changed. */);
6672 Vwindow_configuration_change_hook
= Qnil
;
6674 DEFVAR_BOOL ("window-size-fixed", &window_size_fixed
,
6675 doc
: /* Non-nil in a buffer means windows displaying the buffer are fixed-size.
6676 If the value is`height', then only the window's height is fixed.
6677 If the value is `width', then only the window's width is fixed.
6678 Any other non-nil value fixes both the width and the height.
6679 Emacs won't change the size of any window displaying that buffer,
6680 unless you explicitly change the size, or Emacs has no other choice. */);
6681 Fmake_variable_buffer_local (Qwindow_size_fixed
);
6682 window_size_fixed
= 0;
6684 defsubr (&Sselected_window
);
6685 defsubr (&Sminibuffer_window
);
6686 defsubr (&Swindow_minibuffer_p
);
6687 defsubr (&Swindowp
);
6688 defsubr (&Swindow_live_p
);
6689 defsubr (&Spos_visible_in_window_p
);
6690 defsubr (&Swindow_buffer
);
6691 defsubr (&Swindow_height
);
6692 defsubr (&Swindow_width
);
6693 defsubr (&Swindow_hscroll
);
6694 defsubr (&Sset_window_hscroll
);
6695 defsubr (&Swindow_redisplay_end_trigger
);
6696 defsubr (&Sset_window_redisplay_end_trigger
);
6697 defsubr (&Swindow_edges
);
6698 defsubr (&Swindow_pixel_edges
);
6699 defsubr (&Swindow_inside_edges
);
6700 defsubr (&Swindow_inside_pixel_edges
);
6701 defsubr (&Scoordinates_in_window_p
);
6702 defsubr (&Swindow_at
);
6703 defsubr (&Swindow_point
);
6704 defsubr (&Swindow_start
);
6705 defsubr (&Swindow_end
);
6706 defsubr (&Sset_window_point
);
6707 defsubr (&Sset_window_start
);
6708 defsubr (&Swindow_dedicated_p
);
6709 defsubr (&Sset_window_dedicated_p
);
6710 defsubr (&Swindow_display_table
);
6711 defsubr (&Sset_window_display_table
);
6712 defsubr (&Snext_window
);
6713 defsubr (&Sprevious_window
);
6714 defsubr (&Sother_window
);
6715 defsubr (&Sget_lru_window
);
6716 defsubr (&Sget_largest_window
);
6717 defsubr (&Sget_buffer_window
);
6718 defsubr (&Sdelete_other_windows
);
6719 defsubr (&Sdelete_windows_on
);
6720 defsubr (&Sreplace_buffer_in_windows
);
6721 defsubr (&Sdelete_window
);
6722 defsubr (&Sset_window_buffer
);
6723 defsubr (&Sselect_window
);
6724 defsubr (&Sspecial_display_p
);
6725 defsubr (&Ssame_window_p
);
6726 defsubr (&Sdisplay_buffer
);
6727 defsubr (&Sforce_window_update
);
6728 defsubr (&Ssplit_window
);
6729 defsubr (&Senlarge_window
);
6730 defsubr (&Sshrink_window
);
6731 defsubr (&Sscroll_up
);
6732 defsubr (&Sscroll_down
);
6733 defsubr (&Sscroll_left
);
6734 defsubr (&Sscroll_right
);
6735 defsubr (&Sother_window_for_scrolling
);
6736 defsubr (&Sscroll_other_window
);
6737 defsubr (&Sminibuffer_selected_window
);
6738 defsubr (&Srecenter
);
6739 defsubr (&Swindow_text_height
);
6740 defsubr (&Smove_to_window_line
);
6741 defsubr (&Swindow_configuration_p
);
6742 defsubr (&Swindow_configuration_frame
);
6743 defsubr (&Sset_window_configuration
);
6744 defsubr (&Scurrent_window_configuration
);
6745 defsubr (&Ssave_window_excursion
);
6746 defsubr (&Sset_window_margins
);
6747 defsubr (&Swindow_margins
);
6748 defsubr (&Sset_window_fringes
);
6749 defsubr (&Swindow_fringes
);
6750 defsubr (&Sset_window_scroll_bars
);
6751 defsubr (&Swindow_scroll_bars
);
6752 defsubr (&Swindow_vscroll
);
6753 defsubr (&Sset_window_vscroll
);
6754 defsubr (&Scompare_window_configurations
);
6755 defsubr (&Swindow_list
);
6761 initial_define_key (control_x_map
, '1', "delete-other-windows");
6762 initial_define_key (control_x_map
, '2', "split-window");
6763 initial_define_key (control_x_map
, '0', "delete-window");
6764 initial_define_key (control_x_map
, 'o', "other-window");
6765 initial_define_key (control_x_map
, '^', "enlarge-window");
6766 initial_define_key (control_x_map
, '<', "scroll-left");
6767 initial_define_key (control_x_map
, '>', "scroll-right");
6769 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
6770 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6771 initial_define_key (meta_map
, 'v', "scroll-down");
6773 initial_define_key (global_map
, Ctl('L'), "recenter");
6774 initial_define_key (meta_map
, 'r', "move-to-window-line");
6777 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
6778 (do not change this comment) */