1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
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 Qscroll_up
, Qscroll_down
;
56 Lisp_Object Qwindow_size_fixed
;
57 extern Lisp_Object Qleft_margin
, Qright_margin
;
59 static int displayed_window_lines
P_ ((struct window
*));
60 static struct window
*decode_window
P_ ((Lisp_Object
));
61 static int count_windows
P_ ((struct window
*));
62 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
63 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
64 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
65 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
66 static int window_min_size_1
P_ ((struct window
*, int));
67 static int window_min_size
P_ ((struct window
*, int, int, int *));
68 static void size_window
P_ ((Lisp_Object
, int, int, int, int, int));
69 static int freeze_window_start
P_ ((struct window
*, void *));
70 static int window_fixed_size_p
P_ ((struct window
*, int, int));
71 static void enlarge_window
P_ ((Lisp_Object
, int, int));
72 static Lisp_Object window_list
P_ ((void));
73 static int add_window_to_list
P_ ((struct window
*, void *));
74 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
76 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
78 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
80 static int foreach_window_1
P_ ((struct window
*,
81 int (* fn
) (struct window
*, void *),
83 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
85 /* This is the window in which the terminal's cursor should
86 be left when nothing is being done with it. This must
87 always be a leaf window, and its buffer is selected by
88 the top level editing loop at the end of each command.
90 This value is always the same as
91 FRAME_SELECTED_WINDOW (selected_frame). */
93 Lisp_Object selected_window
;
95 /* A list of all windows for use by next_window and Fwindow_list.
96 Functions creating or deleting windows should invalidate this cache
97 by setting it to nil. */
99 Lisp_Object Vwindow_list
;
101 /* The mini-buffer window of the selected frame.
102 Note that you cannot test for mini-bufferness of an arbitrary window
103 by comparing against this; but you can test for mini-bufferness of
104 the selected window. */
106 Lisp_Object minibuf_window
;
108 /* Non-nil means it is the window whose mode line should be
109 shown as the selected window when the minibuffer is selected. */
111 Lisp_Object minibuf_selected_window
;
113 /* Non-nil means it is the window for C-M-v to scroll
114 when the mini-buffer is selected. */
116 Lisp_Object Vminibuf_scroll_window
;
118 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
120 Lisp_Object Vother_window_scroll_buffer
;
122 /* Non-nil means it's function to call to display temp buffers. */
124 Lisp_Object Vtemp_buffer_show_function
;
126 /* Non-zero means line and page scrolling on tall lines (with images)
127 does partial scrolling by modifying window-vscroll. */
129 int auto_window_vscroll_p
;
131 /* Non-zero means to use mode-line-inactive face in all windows but the
132 selected-window and the minibuffer-scroll-window when the
133 minibuffer is active. */
134 int mode_line_in_non_selected_windows
;
136 /* If a window gets smaller than either of these, it is removed. */
138 EMACS_INT window_min_height
;
139 EMACS_INT window_min_width
;
141 /* Nonzero implies Fdisplay_buffer should create windows. */
145 /* Nonzero implies make new frames for Fdisplay_buffer. */
149 /* Nonzero means reuse existing frames for displaying buffers. */
151 int display_buffer_reuse_frames
;
153 /* Non-nil means use this function instead of default */
155 Lisp_Object Vpop_up_frame_function
;
157 /* Function to call to handle Fdisplay_buffer. */
159 Lisp_Object Vdisplay_buffer_function
;
161 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
163 Lisp_Object Veven_window_heights
;
165 /* List of buffer *names* for buffers that should have their own frames. */
167 Lisp_Object Vspecial_display_buffer_names
;
169 /* List of regexps for buffer names that should have their own frames. */
171 Lisp_Object Vspecial_display_regexps
;
173 /* Function to pop up a special frame. */
175 Lisp_Object Vspecial_display_function
;
177 /* List of buffer *names* for buffers to appear in selected window. */
179 Lisp_Object Vsame_window_buffer_names
;
181 /* List of regexps for buffer names to appear in selected window. */
183 Lisp_Object Vsame_window_regexps
;
185 /* Hook run at end of temp_output_buffer_show. */
187 Lisp_Object Qtemp_buffer_show_hook
;
189 /* Fdisplay_buffer always splits the largest window
190 if that window is more than this high. */
192 EMACS_INT split_height_threshold
;
194 /* Number of lines of continuity in scrolling by screenfuls. */
196 EMACS_INT next_screen_context_lines
;
198 /* Incremented for each window created. */
200 static int sequence_number
;
202 /* Nonzero after init_window_once has finished. */
204 static int window_initialized
;
206 /* Hook to run when window config changes. */
208 Lisp_Object Qwindow_configuration_change_hook
;
209 Lisp_Object Vwindow_configuration_change_hook
;
211 /* Non-nil means scroll commands try to put point
212 at the same screen height as previously. */
214 Lisp_Object Vscroll_preserve_screen_position
;
216 /* Incremented by 1 whenever a window is deleted. */
218 int window_deletion_count
;
220 /* Used by the function window_scroll_pixel_based */
222 static int window_scroll_pixel_based_preserve_y
;
224 #if 0 /* This isn't used anywhere. */
225 /* Nonzero means we can split a frame even if it is "unsplittable". */
226 static int inhibit_frame_unsplittable
;
229 extern EMACS_INT scroll_margin
;
231 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
233 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
234 doc
: /* Returns t if OBJECT is a window. */)
238 return WINDOWP (object
) ? Qt
: Qnil
;
241 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
242 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
246 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
253 register struct window
*p
;
255 p
= allocate_window ();
257 XSETFASTINT (p
->sequence_number
, sequence_number
);
258 XSETFASTINT (p
->left_col
, 0);
259 XSETFASTINT (p
->top_line
, 0);
260 XSETFASTINT (p
->total_lines
, 0);
261 XSETFASTINT (p
->total_cols
, 0);
262 XSETFASTINT (p
->hscroll
, 0);
263 XSETFASTINT (p
->min_hscroll
, 0);
264 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
265 p
->start
= Fmake_marker ();
266 p
->pointm
= Fmake_marker ();
267 XSETFASTINT (p
->use_time
, 0);
269 p
->display_table
= Qnil
;
271 p
->pseudo_window_p
= 0;
272 bzero (&p
->cursor
, sizeof (p
->cursor
));
273 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
274 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
275 p
->desired_matrix
= p
->current_matrix
= 0;
276 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
277 p
->phys_cursor_type
= -1;
278 p
->phys_cursor_width
= -1;
279 p
->must_be_updated_p
= 0;
280 XSETFASTINT (p
->window_end_vpos
, 0);
281 XSETFASTINT (p
->window_end_pos
, 0);
282 p
->window_end_valid
= Qnil
;
285 XSETFASTINT (p
->last_point
, 0);
286 p
->frozen_window_start_p
= 0;
287 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
288 p
->left_margin_cols
= Qnil
;
289 p
->right_margin_cols
= Qnil
;
290 p
->left_fringe_width
= Qnil
;
291 p
->right_fringe_width
= Qnil
;
292 p
->fringes_outside_margins
= Qnil
;
293 p
->scroll_bar_width
= Qnil
;
294 p
->vertical_scroll_bar_type
= Qt
;
300 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
301 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
304 return selected_window
;
307 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
308 doc
: /* Return the window used now for minibuffers.
309 If the optional argument FRAME is specified, return the minibuffer window
310 used by that frame. */)
315 frame
= selected_frame
;
316 CHECK_LIVE_FRAME (frame
);
317 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
320 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
321 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
322 WINDOW defaults to the selected window. */)
326 struct window
*w
= decode_window (window
);
327 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
331 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
332 Spos_visible_in_window_p
, 0, 3, 0,
333 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
334 Return nil if that position is scrolled vertically out of view.
335 If a character is only partially visible, nil is returned, unless the
336 optional argument PARTIALLY is non-nil.
337 If POS is only out of view because of horizontal scrolling, return non-nil.
338 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
340 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
341 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
342 relative to the top left corner of the window. PARTIAL is nil if the character
343 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
344 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
345 (pos
, window
, partially
)
346 Lisp_Object pos
, window
, partially
;
348 register struct window
*w
;
350 register struct buffer
*buf
;
352 Lisp_Object in_window
= Qnil
;
353 int rtop
, rbot
, fully_p
= 1;
356 w
= decode_window (window
);
357 buf
= XBUFFER (w
->buffer
);
358 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
362 CHECK_NUMBER_COERCE_MARKER (pos
);
365 else if (w
== XWINDOW (selected_window
))
368 posint
= XMARKER (w
->pointm
)->charpos
;
370 /* If position is above window start or outside buffer boundaries,
371 or if window start is out of range, position is not visible. */
372 if (posint
>= CHARPOS (top
)
373 && posint
<= BUF_ZV (buf
)
374 && CHARPOS (top
) >= BUF_BEGV (buf
)
375 && CHARPOS (top
) <= BUF_ZV (buf
)
376 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
377 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
380 if (!NILP (in_window
) && !NILP (partially
))
381 in_window
= Fcons (make_number (x
),
382 Fcons (make_number (y
),
383 Fcons ((fully_p
? Qnil
384 : Fcons (make_number (rtop
),
385 make_number (rbot
))),
391 static struct window
*
392 decode_window (window
)
393 register Lisp_Object window
;
396 return XWINDOW (selected_window
);
398 CHECK_LIVE_WINDOW (window
);
399 return XWINDOW (window
);
402 static struct window
*
403 decode_any_window (window
)
404 register Lisp_Object window
;
407 return XWINDOW (selected_window
);
409 CHECK_WINDOW (window
);
410 return XWINDOW (window
);
413 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
414 doc
: /* Return the buffer that WINDOW is displaying.
415 WINDOW defaults to the selected window. */)
419 return decode_window (window
)->buffer
;
422 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
423 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
427 return decode_any_window (window
)->total_lines
;
430 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
431 doc
: /* Return the number of display columns in WINDOW.
432 This is the width that is usable columns available for text in WINDOW.
433 If you want to find out how many columns WINDOW takes up,
434 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
438 return make_number (window_box_text_cols (decode_any_window (window
)));
441 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
442 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
446 return decode_window (window
)->hscroll
;
449 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
450 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
451 Return NCOL. NCOL should be zero or positive.
453 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
454 window so that the location of point becomes invisible. */)
456 Lisp_Object window
, ncol
;
458 struct window
*w
= decode_window (window
);
462 hscroll
= max (0, XINT (ncol
));
464 /* Prevent redisplay shortcuts when changing the hscroll. */
465 if (XINT (w
->hscroll
) != hscroll
)
466 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
468 w
->hscroll
= make_number (hscroll
);
472 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
473 Swindow_redisplay_end_trigger
, 0, 1, 0,
474 doc
: /* Return WINDOW's redisplay end trigger value.
475 See `set-window-redisplay-end-trigger' for more information. */)
479 return decode_window (window
)->redisplay_end_trigger
;
482 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
483 Sset_window_redisplay_end_trigger
, 2, 2, 0,
484 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
485 VALUE should be a buffer position (typically a marker) or nil.
486 If it is a buffer position, then if redisplay in WINDOW reaches a position
487 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
488 with two arguments: WINDOW, and the end trigger value.
489 Afterwards the end-trigger value is reset to nil. */)
491 register Lisp_Object window
, value
;
493 register struct window
*w
;
495 w
= decode_window (window
);
496 w
->redisplay_end_trigger
= value
;
500 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
501 doc
: /* Return a list of the edge coordinates of WINDOW.
502 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
503 RIGHT is one more than the rightmost column occupied by WINDOW,
504 and BOTTOM is one more than the bottommost row occupied by WINDOW.
505 The edges include the space used by the window's scroll bar,
506 display margins, fringes, header line, and mode line, if it has them.
507 To get the edges of the actual text area, use `window-inside-edges'. */)
511 register struct window
*w
= decode_any_window (window
);
513 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
514 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
515 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
516 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
520 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
521 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
522 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
523 RIGHT is one more than the rightmost x position occupied by WINDOW,
524 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
525 The pixel edges include the space used by the window's scroll bar,
526 display margins, fringes, header line, and mode line, if it has them.
527 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
531 register struct window
*w
= decode_any_window (window
);
533 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
534 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
535 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
536 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
540 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
541 doc
: /* Return a list of the edge coordinates of WINDOW.
542 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
543 RIGHT is one more than the rightmost column used by text in WINDOW,
544 and BOTTOM is one more than the bottommost row used by text in WINDOW.
545 The inside edges do not include the space used by the window's scroll bar,
546 display margins, fringes, header line, and/or mode line. */)
550 register struct window
*w
= decode_any_window (window
);
552 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
553 + WINDOW_LEFT_MARGIN_COLS (w
)
554 + WINDOW_LEFT_FRINGE_COLS (w
)),
555 make_number (WINDOW_TOP_EDGE_LINE (w
)
556 + WINDOW_HEADER_LINE_LINES (w
)),
557 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
558 - WINDOW_RIGHT_MARGIN_COLS (w
)
559 - WINDOW_RIGHT_FRINGE_COLS (w
)),
560 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
561 - WINDOW_MODE_LINE_LINES (w
)));
564 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
565 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
566 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
567 RIGHT is one more than the rightmost x position used by text in WINDOW,
568 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
569 The inside edges do not include the space used by the window's scroll bar,
570 display margins, fringes, header line, and/or mode line. */)
574 register struct window
*w
= decode_any_window (window
);
576 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
577 + WINDOW_LEFT_MARGIN_WIDTH (w
)
578 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
579 make_number (WINDOW_TOP_EDGE_Y (w
)
580 + WINDOW_HEADER_LINE_HEIGHT (w
)),
581 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
582 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
583 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
584 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
585 - WINDOW_MODE_LINE_HEIGHT (w
)));
588 /* Test if the character at column *X, row *Y is within window W.
589 If it is not, return ON_NOTHING;
590 if it is in the window's text area,
591 set *x and *y to its location relative to the upper left corner
594 if it is on the window's modeline, return ON_MODE_LINE;
595 if it is on the border between the window and its right sibling,
596 return ON_VERTICAL_BORDER.
597 if it is on a scroll bar,
598 return ON_SCROLL_BAR.
599 if it is on the window's top line, return ON_HEADER_LINE;
600 if it is in left or right fringe of the window,
601 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
602 to window-relative coordinates;
603 if it is in the marginal area to the left/right of the window,
604 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
605 to window-relative coordinates.
607 X and Y are frame relative pixel coordinates. */
609 static enum window_part
610 coordinates_in_window (w
, x
, y
)
611 register struct window
*w
;
614 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
615 int left_x
, right_x
, top_y
, bottom_y
;
616 enum window_part part
;
617 int ux
= FRAME_COLUMN_WIDTH (f
);
618 int x0
= WINDOW_LEFT_EDGE_X (w
);
619 int x1
= WINDOW_RIGHT_EDGE_X (w
);
620 /* The width of the area where the vertical line can be dragged.
621 (Between mode lines for instance. */
622 int grabbable_width
= ux
;
623 int lmargin_width
, rmargin_width
, text_left
, text_right
;
625 /* In what's below, we subtract 1 when computing right_x because we
626 want the rightmost pixel, which is given by left_pixel+width-1. */
627 if (w
->pseudo_window_p
)
630 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
631 top_y
= WINDOW_TOP_EDGE_Y (w
);
632 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
636 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
637 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
638 top_y
= WINDOW_TOP_EDGE_Y (w
);
639 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
642 /* Outside any interesting row? */
643 if (*y
< top_y
|| *y
>= bottom_y
)
646 /* On the mode line or header line? If it's near the start of
647 the mode or header line of window that's has a horizontal
648 sibling, say it's on the vertical line. That's to be able
649 to resize windows horizontally in case we're using toolkit
652 if (WINDOW_WANTS_MODELINE_P (w
)
653 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
657 header_vertical_border_check
:
658 /* We're somewhere on the mode line. We consider the place
659 between mode lines of horizontally adjacent mode lines
660 as the vertical border. If scroll bars on the left,
661 return the right window. */
662 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
663 || WINDOW_RIGHTMOST_P (w
))
665 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
667 /* Convert X and Y to window relative coordinates.
668 Vertical border is at the left edge of window. */
669 *x
= max (0, *x
- x0
);
671 return ON_VERTICAL_BORDER
;
676 if (abs (*x
- x1
) < grabbable_width
)
678 /* Convert X and Y to window relative coordinates.
679 Vertical border is at the right edge of window. */
680 *x
= min (x1
, *x
) - x0
;
682 return ON_VERTICAL_BORDER
;
686 if (*x
< x0
|| *x
>= x1
)
689 /* Convert X and Y to window relative coordinates.
690 Mode line starts at left edge of window. */
696 if (WINDOW_WANTS_HEADER_LINE_P (w
)
697 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
699 part
= ON_HEADER_LINE
;
700 goto header_vertical_border_check
;
703 if (*x
< x0
|| *x
>= x1
)
706 /* Outside any interesting column? */
707 if (*x
< left_x
|| *x
> right_x
)
710 return ON_SCROLL_BAR
;
713 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
714 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
716 text_left
= window_box_left (w
, TEXT_AREA
);
717 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
719 if (FRAME_WINDOW_P (f
))
721 if (!w
->pseudo_window_p
722 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
723 && !WINDOW_RIGHTMOST_P (w
)
724 && (abs (*x
- right_x
) < grabbable_width
))
726 /* Convert X and Y to window relative coordinates.
727 Vertical border is at the right edge of window. */
728 *x
= min (right_x
, *x
) - left_x
;
730 return ON_VERTICAL_BORDER
;
735 /* Need to say "*x > right_x" rather than >=, since on character
736 terminals, the vertical line's x coordinate is right_x. */
737 if (!w
->pseudo_window_p
738 && !WINDOW_RIGHTMOST_P (w
)
739 && *x
> right_x
- ux
)
741 /* On the border on the right side of the window? Assume that
742 this area begins at RIGHT_X minus a canonical char width. */
743 *x
= min (right_x
, *x
) - left_x
;
745 return ON_VERTICAL_BORDER
;
751 if (lmargin_width
> 0
752 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
753 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
754 : (*x
< left_x
+ lmargin_width
)))
757 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
758 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
760 return ON_LEFT_MARGIN
;
763 /* Convert X and Y to window-relative pixel coordinates. */
766 return ON_LEFT_FRINGE
;
769 if (*x
>= text_right
)
771 if (rmargin_width
> 0
772 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
773 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
774 : (*x
>= right_x
- rmargin_width
)))
776 *x
-= right_x
- rmargin_width
;
777 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
778 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
780 return ON_RIGHT_MARGIN
;
783 /* Convert X and Y to window-relative pixel coordinates. */
784 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
786 return ON_RIGHT_FRINGE
;
789 /* Everything special ruled out - must be on text area */
796 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
797 Scoordinates_in_window_p
, 2, 2, 0,
798 doc
: /* Return non-nil if COORDINATES are in WINDOW.
799 COORDINATES is a cons of the form (X . Y), X and Y being distances
800 measured in characters from the upper-left corner of the frame.
801 \(0 . 0) denotes the character in the upper left corner of the
803 If COORDINATES are in the text portion of WINDOW,
804 the coordinates relative to the window are returned.
805 If they are in the mode line of WINDOW, `mode-line' is returned.
806 If they are in the top mode line of WINDOW, `header-line' is returned.
807 If they are in the left fringe of WINDOW, `left-fringe' is returned.
808 If they are in the right fringe of WINDOW, `right-fringe' is returned.
809 If they are on the border between WINDOW and its right sibling,
810 `vertical-line' is returned.
811 If they are in the windows's left or right marginal areas, `left-margin'\n\
812 or `right-margin' is returned. */)
813 (coordinates
, window
)
814 register Lisp_Object coordinates
, window
;
821 CHECK_WINDOW (window
);
822 w
= XWINDOW (window
);
823 f
= XFRAME (w
->frame
);
824 CHECK_CONS (coordinates
);
825 lx
= Fcar (coordinates
);
826 ly
= Fcdr (coordinates
);
827 CHECK_NUMBER_OR_FLOAT (lx
);
828 CHECK_NUMBER_OR_FLOAT (ly
);
829 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
830 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
832 switch (coordinates_in_window (w
, &x
, &y
))
838 /* X and Y are now window relative pixel coordinates. Convert
839 them to canonical char units before returning them. */
840 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
841 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
846 case ON_VERTICAL_BORDER
:
847 return Qvertical_line
;
855 case ON_RIGHT_FRINGE
:
856 return Qright_fringe
;
861 case ON_RIGHT_MARGIN
:
862 return Qright_margin
;
865 /* Historically we are supposed to return nil in this case. */
874 /* Callback for foreach_window, used in window_from_coordinates.
875 Check if window W contains coordinates specified by USER_DATA which
876 is actually a pointer to a struct check_window_data CW.
878 Check if window W contains coordinates *CW->x and *CW->y. If it
879 does, return W in *CW->window, as Lisp_Object, and return in
880 *CW->part the part of the window under coordinates *X,*Y. Return
881 zero from this function to stop iterating over windows. */
883 struct check_window_data
887 enum window_part
*part
;
891 check_window_containing (w
, user_data
)
895 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
896 enum window_part found
;
899 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
900 if (found
!= ON_NOTHING
)
903 XSETWINDOW (*cw
->window
, w
);
911 /* Find the window containing frame-relative pixel position X/Y and
912 return it as a Lisp_Object.
914 If X, Y is on one of the window's special `window_part' elements,
915 set *PART to the id of that element, and return X and Y converted
916 to window relative coordinates in WX and WY.
918 If there is no window under X, Y return nil and leave *PART
919 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
921 This function was previously implemented with a loop cycling over
922 windows with Fnext_window, and starting with the frame's selected
923 window. It turned out that this doesn't work with an
924 implementation of next_window using Vwindow_list, because
925 FRAME_SELECTED_WINDOW (F) is not always contained in the window
926 tree of F when this function is called asynchronously from
927 note_mouse_highlight. The original loop didn't terminate in this
931 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
934 enum window_part
*part
;
939 struct check_window_data cw
;
940 enum window_part dummy
;
946 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
947 foreach_window (f
, check_window_containing
, &cw
);
949 /* If not found above, see if it's in the tool bar window, if a tool
953 && WINDOWP (f
->tool_bar_window
)
954 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
955 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
959 window
= f
->tool_bar_window
;
968 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
969 doc
: /* Return window containing coordinates X and Y on FRAME.
970 If omitted, FRAME defaults to the currently selected frame.
971 The top left corner of the frame is considered to be row 0,
974 Lisp_Object x
, y
, frame
;
979 frame
= selected_frame
;
980 CHECK_LIVE_FRAME (frame
);
983 /* Check that arguments are integers or floats. */
984 CHECK_NUMBER_OR_FLOAT (x
);
985 CHECK_NUMBER_OR_FLOAT (y
);
987 return window_from_coordinates (f
,
988 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
989 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
990 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
991 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
995 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
996 doc
: /* Return current value of point in WINDOW.
997 For a nonselected window, this is the value point would have
998 if that window were selected.
1000 Note that, when WINDOW is the selected window and its buffer
1001 is also currently selected, the value returned is the same as (point).
1002 It would be more strictly correct to return the `top-level' value
1003 of point, outside of any save-excursion forms.
1004 But that is hard to define. */)
1008 register struct window
*w
= decode_window (window
);
1010 if (w
== XWINDOW (selected_window
)
1011 && current_buffer
== XBUFFER (w
->buffer
))
1013 return Fmarker_position (w
->pointm
);
1016 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
1017 doc
: /* Return position at which display currently starts in WINDOW.
1018 This is updated by redisplay or by calling `set-window-start'. */)
1022 return Fmarker_position (decode_window (window
)->start
);
1025 /* This is text temporarily removed from the doc string below.
1027 This function returns nil if the position is not currently known.
1028 That happens when redisplay is preempted and doesn't finish.
1029 If in that case you want to compute where the end of the window would
1030 have been if redisplay had finished, do this:
1032 (goto-char (window-start window))
1033 (vertical-motion (1- (window-height window)) window)
1036 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1037 doc
: /* Return position at which display currently ends in WINDOW.
1038 This is updated by redisplay, when it runs to completion.
1039 Simply changing the buffer text or setting `window-start'
1040 does not update this value.
1041 Return nil if there is no recorded value. \(This can happen if the
1042 last redisplay of WINDOW was preempted, and did not finish.)
1043 If UPDATE is non-nil, compute the up-to-date position
1044 if it isn't already recorded. */)
1046 Lisp_Object window
, update
;
1049 struct window
*w
= decode_window (window
);
1055 #if 0 /* This change broke some things. We should make it later. */
1056 /* If we don't know the end position, return nil.
1057 The user can compute it with vertical-motion if he wants to.
1058 It would be nicer to do it automatically,
1059 but that's so slow that it would probably bother people. */
1060 if (NILP (w
->window_end_valid
))
1065 && ! (! NILP (w
->window_end_valid
)
1066 && XFASTINT (w
->last_modified
) >= MODIFF
)
1069 struct text_pos startp
;
1071 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1073 /* In case W->start is out of the range, use something
1074 reasonable. This situation occurred when loading a file with
1075 `-l' containing a call to `rmail' with subsequent other
1076 commands. At the end, W->start happened to be BEG, while
1077 rmail had already narrowed the buffer. */
1078 if (XMARKER (w
->start
)->charpos
< BEGV
)
1079 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1080 else if (XMARKER (w
->start
)->charpos
> ZV
)
1081 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1083 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1085 /* Cannot use Fvertical_motion because that function doesn't
1086 cope with variable-height lines. */
1087 if (b
!= current_buffer
)
1089 old_buffer
= current_buffer
;
1090 set_buffer_internal (b
);
1093 start_display (&it
, w
, startp
);
1094 move_it_vertically (&it
, window_box_height (w
));
1095 if (it
.current_y
< it
.last_visible_y
)
1096 move_it_past_eol (&it
);
1097 value
= make_number (IT_CHARPOS (it
));
1100 set_buffer_internal (old_buffer
);
1103 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1108 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1109 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1112 Lisp_Object window
, pos
;
1114 register struct window
*w
= decode_window (window
);
1116 CHECK_NUMBER_COERCE_MARKER (pos
);
1117 if (w
== XWINDOW (selected_window
)
1118 && XBUFFER (w
->buffer
) == current_buffer
)
1121 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1123 /* We have to make sure that redisplay updates the window to show
1124 the new value of point. */
1125 if (!EQ (window
, selected_window
))
1126 ++windows_or_buffers_changed
;
1131 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1132 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1134 Optional third arg NOFORCE non-nil inhibits next redisplay
1135 from overriding motion of point in order to display at this exact start. */)
1136 (window
, pos
, noforce
)
1137 Lisp_Object window
, pos
, noforce
;
1139 register struct window
*w
= decode_window (window
);
1141 CHECK_NUMBER_COERCE_MARKER (pos
);
1142 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1143 /* this is not right, but much easier than doing what is right. */
1144 w
->start_at_line_beg
= Qnil
;
1146 w
->force_start
= Qt
;
1147 w
->update_mode_line
= Qt
;
1148 XSETFASTINT (w
->last_modified
, 0);
1149 XSETFASTINT (w
->last_overlay_modified
, 0);
1150 if (!EQ (window
, selected_window
))
1151 windows_or_buffers_changed
++;
1156 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1158 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1159 See also `set-window-dedicated-p'. */)
1163 return decode_window (window
)->dedicated
;
1166 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1167 Sset_window_dedicated_p
, 2, 2, 0,
1168 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1169 If it is dedicated, Emacs will not automatically change
1170 which buffer appears in it.
1171 The second argument is the new value for the dedication flag;
1172 non-nil means yes. */)
1174 Lisp_Object window
, arg
;
1176 register struct window
*w
= decode_window (window
);
1180 return w
->dedicated
;
1183 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1185 doc
: /* Return the display-table that WINDOW is using. */)
1189 return decode_window (window
)->display_table
;
1192 /* Get the display table for use on window W. This is either W's
1193 display table or W's buffer's display table. Ignore the specified
1194 tables if they are not valid; if no valid table is specified,
1197 struct Lisp_Char_Table
*
1198 window_display_table (w
)
1201 struct Lisp_Char_Table
*dp
= NULL
;
1203 if (DISP_TABLE_P (w
->display_table
))
1204 dp
= XCHAR_TABLE (w
->display_table
);
1205 else if (BUFFERP (w
->buffer
))
1207 struct buffer
*b
= XBUFFER (w
->buffer
);
1209 if (DISP_TABLE_P (b
->display_table
))
1210 dp
= XCHAR_TABLE (b
->display_table
);
1211 else if (DISP_TABLE_P (Vstandard_display_table
))
1212 dp
= XCHAR_TABLE (Vstandard_display_table
);
1218 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1219 doc
: /* Set WINDOW's display-table to TABLE. */)
1221 register Lisp_Object window
, table
;
1223 register struct window
*w
;
1225 w
= decode_window (window
);
1226 w
->display_table
= table
;
1230 /* Record info on buffer window w is displaying
1231 when it is about to cease to display that buffer. */
1234 register struct window
*w
;
1241 if (b
!= XMARKER (w
->pointm
)->buffer
)
1245 if (w
== XWINDOW (selected_window
)
1246 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1247 /* Do this except when the selected window's buffer
1248 is being removed from some other window. */
1250 /* last_window_start records the start position that this buffer
1251 had in the last window to be disconnected from it.
1252 Now that this statement is unconditional,
1253 it is possible for the buffer to be displayed in the
1254 selected window, while last_window_start reflects another
1255 window which was recently showing the same buffer.
1256 Some people might say that might be a good thing. Let's see. */
1257 b
->last_window_start
= marker_position (w
->start
);
1259 /* Point in the selected window's buffer
1260 is actually stored in that buffer, and the window's pointm isn't used.
1261 So don't clobber point in that buffer. */
1262 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1263 /* This line helps to fix Horsley's testbug.el bug. */
1264 && !(WINDOWP (b
->last_selected_window
)
1265 && w
!= XWINDOW (b
->last_selected_window
)
1266 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1267 temp_set_point_both (b
,
1268 clip_to_bounds (BUF_BEGV (b
),
1269 XMARKER (w
->pointm
)->charpos
,
1271 clip_to_bounds (BUF_BEGV_BYTE (b
),
1272 marker_byte_position (w
->pointm
),
1275 if (WINDOWP (b
->last_selected_window
)
1276 && w
== XWINDOW (b
->last_selected_window
))
1277 b
->last_selected_window
= Qnil
;
1280 /* Put replacement into the window structure in place of old. */
1282 replace_window (old
, replacement
)
1283 Lisp_Object old
, replacement
;
1285 register Lisp_Object tem
;
1286 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1288 /* If OLD is its frame's root_window, then replacement is the new
1289 root_window for that frame. */
1291 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1292 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1294 p
->left_col
= o
->left_col
;
1295 p
->top_line
= o
->top_line
;
1296 p
->total_cols
= o
->total_cols
;
1297 p
->total_lines
= o
->total_lines
;
1298 p
->desired_matrix
= p
->current_matrix
= 0;
1300 bzero (&p
->cursor
, sizeof (p
->cursor
));
1301 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1302 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1303 p
->phys_cursor_type
= -1;
1304 p
->phys_cursor_width
= -1;
1305 p
->must_be_updated_p
= 0;
1306 p
->pseudo_window_p
= 0;
1307 XSETFASTINT (p
->window_end_vpos
, 0);
1308 XSETFASTINT (p
->window_end_pos
, 0);
1309 p
->window_end_valid
= Qnil
;
1310 p
->frozen_window_start_p
= 0;
1311 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1313 p
->next
= tem
= o
->next
;
1315 XWINDOW (tem
)->prev
= replacement
;
1317 p
->prev
= tem
= o
->prev
;
1319 XWINDOW (tem
)->next
= replacement
;
1321 p
->parent
= tem
= o
->parent
;
1324 if (EQ (XWINDOW (tem
)->vchild
, old
))
1325 XWINDOW (tem
)->vchild
= replacement
;
1326 if (EQ (XWINDOW (tem
)->hchild
, old
))
1327 XWINDOW (tem
)->hchild
= replacement
;
1330 /*** Here, if replacement is a vertical combination
1331 and so is its new parent, we should make replacement's
1332 children be children of that parent instead. ***/
1335 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1336 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1338 register Lisp_Object window
;
1340 delete_window (window
);
1342 if (! NILP (Vwindow_configuration_change_hook
)
1343 && ! NILP (Vrun_hooks
))
1344 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1350 delete_window (window
)
1351 register Lisp_Object window
;
1353 register Lisp_Object tem
, parent
, sib
;
1354 register struct window
*p
;
1355 register struct window
*par
;
1358 /* Because this function is called by other C code on non-leaf
1359 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1360 so we can't decode_window here. */
1362 window
= selected_window
;
1364 CHECK_WINDOW (window
);
1365 p
= XWINDOW (window
);
1367 /* It's a no-op to delete an already-deleted window. */
1368 if (NILP (p
->buffer
)
1370 && NILP (p
->vchild
))
1375 error ("Attempt to delete minibuffer or sole ordinary window");
1376 par
= XWINDOW (parent
);
1378 windows_or_buffers_changed
++;
1379 Vwindow_list
= Qnil
;
1380 f
= XFRAME (WINDOW_FRAME (p
));
1381 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1383 /* Are we trying to delete any frame's selected window? */
1385 Lisp_Object swindow
, pwindow
;
1387 /* See if the frame's selected window is either WINDOW
1388 or any subwindow of it, by finding all that window's parents
1389 and comparing each one with WINDOW. */
1390 swindow
= FRAME_SELECTED_WINDOW (f
);
1395 while (!NILP (pwindow
))
1397 if (EQ (window
, pwindow
))
1399 pwindow
= XWINDOW (pwindow
)->parent
;
1402 /* If the window being deleted is not a parent of SWINDOW,
1403 then SWINDOW is ok as the new selected window. */
1404 if (!EQ (window
, pwindow
))
1406 /* Otherwise, try another window for SWINDOW. */
1407 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1409 /* If we get back to the frame's selected window,
1410 it means there was no acceptable alternative,
1411 so we cannot delete. */
1412 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1413 error ("Cannot delete window");
1416 /* If we need to change SWINDOW, do it. */
1417 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1419 /* If we're about to delete the selected window on the
1420 selected frame, then we should use Fselect_window to select
1421 the new window. On the other hand, if we're about to
1422 delete the selected window on any other frame, we shouldn't do
1423 anything but set the frame's selected_window slot. */
1424 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1425 Fselect_window (swindow
, Qnil
);
1427 FRAME_SELECTED_WINDOW (f
) = swindow
;
1431 /* Now we know we can delete this one. */
1432 window_deletion_count
++;
1435 /* tem is null for dummy parent windows
1436 (which have inferiors but not any contents themselves) */
1440 unchain_marker (XMARKER (p
->pointm
));
1441 unchain_marker (XMARKER (p
->start
));
1444 /* Free window glyph matrices. It is sure that they are allocated
1445 again when ADJUST_GLYPHS is called. Block input so that expose
1446 events and other events that access glyph matrices are not
1447 processed while we are changing them. */
1449 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1453 XWINDOW (tem
)->prev
= p
->prev
;
1457 XWINDOW (tem
)->next
= p
->next
;
1459 if (EQ (window
, par
->hchild
))
1460 par
->hchild
= p
->next
;
1461 if (EQ (window
, par
->vchild
))
1462 par
->vchild
= p
->next
;
1464 /* Find one of our siblings to give our space to. */
1468 /* If p gives its space to its next sibling, that sibling needs
1469 to have its top/left side pulled back to where p's is.
1470 set_window_{height,width} will re-position the sibling's
1473 XWINDOW (sib
)->top_line
= p
->top_line
;
1474 XWINDOW (sib
)->left_col
= p
->left_col
;
1477 /* Stretch that sibling. */
1478 if (!NILP (par
->vchild
))
1479 set_window_height (sib
,
1480 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1482 if (!NILP (par
->hchild
))
1483 set_window_width (sib
,
1484 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1487 /* If parent now has only one child,
1488 put the child into the parent's place. */
1492 if (NILP (XWINDOW (tem
)->next
)) {
1493 replace_window (parent
, tem
);
1494 par
= XWINDOW (tem
);
1497 /* Since we may be deleting combination windows, we must make sure that
1498 not only p but all its children have been marked as deleted. */
1499 if (! NILP (p
->hchild
))
1500 delete_all_subwindows (XWINDOW (p
->hchild
));
1501 else if (! NILP (p
->vchild
))
1502 delete_all_subwindows (XWINDOW (p
->vchild
));
1504 /* Mark this window as deleted. */
1505 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1507 if (! NILP (par
->parent
))
1508 par
= XWINDOW (par
->parent
);
1510 /* Check if we have a v/hchild with a v/hchild. In that case remove
1513 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1515 p
= XWINDOW (par
->vchild
);
1516 par
->vchild
= p
->vchild
;
1519 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1521 p
= XWINDOW (par
->hchild
);
1522 par
->hchild
= p
->hchild
;
1530 while (! NILP (tem
)) {
1531 XWINDOW (tem
)->parent
= p
->parent
;
1532 if (NILP (XWINDOW (tem
)->next
))
1534 tem
= XWINDOW (tem
)->next
;
1537 /* The next of the v/hchild we are removing is now the next of the
1538 last child for the v/hchild:
1539 Before v/hchild -> v/hchild -> next1 -> next2
1542 After: v/hchild -> next1 -> next2 -> next3
1544 XWINDOW (tem
)->next
= p
->next
;
1545 if (! NILP (p
->next
))
1546 XWINDOW (p
->next
)->prev
= tem
;
1548 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1552 /* Adjust glyph matrices. */
1559 /***********************************************************************
1561 ***********************************************************************/
1563 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1564 pointer. This is a callback function for foreach_window, used in
1565 function window_list. */
1568 add_window_to_list (w
, user_data
)
1572 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1574 XSETWINDOW (window
, w
);
1575 *list
= Fcons (window
, *list
);
1580 /* Return a list of all windows, for use by next_window. If
1581 Vwindow_list is a list, return that list. Otherwise, build a new
1582 list, cache it in Vwindow_list, and return that. */
1587 if (!CONSP (Vwindow_list
))
1591 Vwindow_list
= Qnil
;
1592 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1594 Lisp_Object args
[2];
1596 /* We are visiting windows in canonical order, and add
1597 new windows at the front of args[1], which means we
1598 have to reverse this list at the end. */
1600 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1601 args
[0] = Vwindow_list
;
1602 args
[1] = Fnreverse (args
[1]);
1603 Vwindow_list
= Fnconc (2, args
);
1607 return Vwindow_list
;
1611 /* Value is non-zero if WINDOW satisfies the constraints given by
1612 OWINDOW, MINIBUF and ALL_FRAMES.
1614 MINIBUF t means WINDOW may be minibuffer windows.
1615 `lambda' means WINDOW may not be a minibuffer window.
1616 a window means a specific minibuffer window
1618 ALL_FRAMES t means search all frames,
1619 nil means search just current frame,
1620 `visible' means search just visible frames,
1621 0 means search visible and iconified frames,
1622 a window means search the frame that window belongs to,
1623 a frame means consider windows on that frame, only. */
1626 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1627 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1629 struct window
*w
= XWINDOW (window
);
1630 struct frame
*f
= XFRAME (w
->frame
);
1631 int candidate_p
= 1;
1633 if (!BUFFERP (w
->buffer
))
1635 else if (MINI_WINDOW_P (w
)
1636 && (EQ (minibuf
, Qlambda
)
1637 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1639 /* If MINIBUF is `lambda' don't consider any mini-windows.
1640 If it is a window, consider only that one. */
1643 else if (EQ (all_frames
, Qt
))
1645 else if (NILP (all_frames
))
1647 xassert (WINDOWP (owindow
));
1648 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1650 else if (EQ (all_frames
, Qvisible
))
1652 FRAME_SAMPLE_VISIBILITY (f
);
1653 candidate_p
= FRAME_VISIBLE_P (f
);
1655 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1657 FRAME_SAMPLE_VISIBILITY (f
);
1658 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1660 else if (WINDOWP (all_frames
))
1661 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1662 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1663 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1664 else if (FRAMEP (all_frames
))
1665 candidate_p
= EQ (all_frames
, w
->frame
);
1671 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1672 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1676 decode_next_window_args (window
, minibuf
, all_frames
)
1677 Lisp_Object
*window
, *minibuf
, *all_frames
;
1680 *window
= selected_window
;
1682 CHECK_LIVE_WINDOW (*window
);
1684 /* MINIBUF nil may or may not include minibuffers. Decide if it
1686 if (NILP (*minibuf
))
1687 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1688 else if (!EQ (*minibuf
, Qt
))
1691 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1692 => count none of them, or a specific minibuffer window (the
1693 active one) to count. */
1695 /* ALL_FRAMES nil doesn't specify which frames to include. */
1696 if (NILP (*all_frames
))
1697 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1698 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1700 else if (EQ (*all_frames
, Qvisible
))
1702 else if (EQ (*all_frames
, make_number (0)))
1704 else if (FRAMEP (*all_frames
))
1706 else if (!EQ (*all_frames
, Qt
))
1709 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1710 search just current frame, `visible' meaning search just visible
1711 frames, 0 meaning search visible and iconified frames, or a
1712 window, meaning search the frame that window belongs to, or a
1713 frame, meaning consider windows on that frame, only. */
1717 /* Return the next or previous window of WINDOW in canonical ordering
1718 of windows. NEXT_P non-zero means return the next window. See the
1719 documentation string of next-window for the meaning of MINIBUF and
1723 next_window (window
, minibuf
, all_frames
, next_p
)
1724 Lisp_Object window
, minibuf
, all_frames
;
1727 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1729 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1730 return the first window on the frame. */
1731 if (FRAMEP (all_frames
)
1732 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1733 return Fframe_first_window (all_frames
);
1739 /* Find WINDOW in the list of all windows. */
1740 list
= Fmemq (window
, window_list ());
1742 /* Scan forward from WINDOW to the end of the window list. */
1744 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1745 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1748 /* Scan from the start of the window list up to WINDOW. */
1750 for (list
= Vwindow_list
;
1751 CONSP (list
) && !EQ (XCAR (list
), window
);
1753 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1757 window
= XCAR (list
);
1761 Lisp_Object candidate
, list
;
1763 /* Scan through the list of windows for candidates. If there are
1764 candidate windows in front of WINDOW, the last one of these
1765 is the one we want. If there are candidates following WINDOW
1766 in the list, again the last one of these is the one we want. */
1768 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1770 if (EQ (XCAR (list
), window
))
1772 if (WINDOWP (candidate
))
1775 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1777 candidate
= XCAR (list
);
1780 if (WINDOWP (candidate
))
1788 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1789 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1790 If omitted, WINDOW defaults to the selected window.
1792 Optional second arg MINIBUF t means count the minibuffer window even
1793 if not active. MINIBUF nil or omitted means count the minibuffer iff
1794 it is active. MINIBUF neither t nor nil means not to count the
1795 minibuffer even if it is active.
1797 Several frames may share a single minibuffer; if the minibuffer
1798 counts, all windows on all frames that share that minibuffer count
1799 too. Therefore, `next-window' can be used to iterate through the
1800 set of windows even when the minibuffer is on another frame. If the
1801 minibuffer does not count, only windows from WINDOW's frame count.
1803 Optional third arg ALL-FRAMES t means include windows on all frames.
1804 ALL-FRAMES nil or omitted means cycle within the frames as specified
1805 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1806 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1807 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1808 Anything else means restrict to WINDOW's frame.
1810 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1811 `next-window' to iterate through the entire cycle of acceptable
1812 windows, eventually ending up back at the window you started with.
1813 `previous-window' traverses the same cycle, in the reverse order. */)
1814 (window
, minibuf
, all_frames
)
1815 Lisp_Object window
, minibuf
, all_frames
;
1817 return next_window (window
, minibuf
, all_frames
, 1);
1821 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1822 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1823 If omitted, WINDOW defaults to the selected window.
1825 Optional second arg MINIBUF t means count the minibuffer window even
1826 if not active. MINIBUF nil or omitted means count the minibuffer iff
1827 it is active. MINIBUF neither t nor nil means not to count the
1828 minibuffer even if it is active.
1830 Several frames may share a single minibuffer; if the minibuffer
1831 counts, all windows on all frames that share that minibuffer count
1832 too. Therefore, `previous-window' can be used to iterate through
1833 the set of windows even when the minibuffer is on another frame. If
1834 the minibuffer does not count, only windows from WINDOW's frame count
1836 Optional third arg ALL-FRAMES t means include windows on all frames.
1837 ALL-FRAMES nil or omitted means cycle within the frames as specified
1838 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1839 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1840 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1841 Anything else means restrict to WINDOW's frame.
1843 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1844 `previous-window' to iterate through the entire cycle of acceptable
1845 windows, eventually ending up back at the window you started with.
1846 `next-window' traverses the same cycle, in the reverse order. */)
1847 (window
, minibuf
, all_frames
)
1848 Lisp_Object window
, minibuf
, all_frames
;
1850 return next_window (window
, minibuf
, all_frames
, 0);
1854 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1855 doc
: /* Select the ARG'th different window on this frame.
1856 All windows on current frame are arranged in a cyclic order.
1857 This command selects the window ARG steps away in that order.
1858 A negative ARG moves in the opposite order. The optional second
1859 argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
1861 Lisp_Object arg
, all_frames
;
1867 window
= selected_window
;
1869 for (i
= XINT (arg
); i
> 0; --i
)
1870 window
= Fnext_window (window
, Qnil
, all_frames
);
1872 window
= Fprevious_window (window
, Qnil
, all_frames
);
1874 Fselect_window (window
, Qnil
);
1879 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1880 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1881 FRAME nil or omitted means use the selected frame.
1882 WINDOW nil or omitted means use the selected window.
1883 MINIBUF t means include the minibuffer window, even if it isn't active.
1884 MINIBUF nil or omitted means include the minibuffer window only
1886 MINIBUF neither nil nor t means never include the minibuffer window. */)
1887 (frame
, minibuf
, window
)
1888 Lisp_Object frame
, minibuf
, window
;
1891 window
= FRAMEP (frame
) ? XFRAME (frame
)->selected_window
: selected_window
;
1892 CHECK_WINDOW (window
);
1894 frame
= selected_frame
;
1896 if (!EQ (frame
, XWINDOW (window
)->frame
))
1897 error ("Window is on a different frame");
1899 return window_list_1 (window
, minibuf
, frame
);
1903 /* Return a list of windows in canonical ordering. Arguments are like
1904 for `next-window'. */
1907 window_list_1 (window
, minibuf
, all_frames
)
1908 Lisp_Object window
, minibuf
, all_frames
;
1910 Lisp_Object tail
, list
, rest
;
1912 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1915 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1916 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1917 list
= Fcons (XCAR (tail
), list
);
1919 /* Rotate the list to start with WINDOW. */
1920 list
= Fnreverse (list
);
1921 rest
= Fmemq (window
, list
);
1922 if (!NILP (rest
) && !EQ (rest
, list
))
1924 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1926 XSETCDR (tail
, Qnil
);
1927 list
= nconc2 (rest
, list
);
1934 /* Look at all windows, performing an operation specified by TYPE
1936 If FRAMES is Qt, look at all frames;
1937 Qnil, look at just the selected frame;
1938 Qvisible, look at visible frames;
1939 a frame, just look at windows on that frame.
1940 If MINI is non-zero, perform the operation on minibuffer windows too. */
1945 GET_BUFFER_WINDOW
, /* Arg is buffer */
1946 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1947 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1948 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1950 UNSHOW_BUFFER
, /* Arg is buffer */
1951 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1956 window_loop (type
, obj
, mini
, frames
)
1957 enum window_loop type
;
1958 Lisp_Object obj
, frames
;
1961 Lisp_Object window
, windows
, best_window
, frame_arg
;
1963 struct gcpro gcpro1
;
1965 /* If we're only looping through windows on a particular frame,
1966 frame points to that frame. If we're looping through windows
1967 on all frames, frame is 0. */
1968 if (FRAMEP (frames
))
1969 f
= XFRAME (frames
);
1970 else if (NILP (frames
))
1971 f
= SELECTED_FRAME ();
1976 frame_arg
= Qlambda
;
1977 else if (EQ (frames
, make_number (0)))
1979 else if (EQ (frames
, Qvisible
))
1984 /* frame_arg is Qlambda to stick to one frame,
1985 Qvisible to consider all visible frames,
1988 /* Pick a window to start with. */
1992 window
= FRAME_SELECTED_WINDOW (f
);
1994 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1996 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
2000 for (; CONSP (windows
); windows
= XCDR (windows
))
2004 window
= XCAR (windows
);
2005 w
= XWINDOW (window
);
2007 /* Note that we do not pay attention here to whether the frame
2008 is visible, since Fwindow_list skips non-visible frames if
2009 that is desired, under the control of frame_arg. */
2010 if (!MINI_WINDOW_P (w
)
2011 /* For UNSHOW_BUFFER, we must always consider all windows. */
2012 || type
== UNSHOW_BUFFER
2013 || (mini
&& minibuf_level
> 0))
2016 case GET_BUFFER_WINDOW
:
2017 if (EQ (w
->buffer
, obj
)
2018 /* Don't find any minibuffer window
2019 except the one that is currently in use. */
2020 && (MINI_WINDOW_P (w
)
2021 ? EQ (window
, minibuf_window
)
2024 if (NILP (best_window
))
2025 best_window
= window
;
2026 else if (EQ (window
, selected_window
))
2027 /* For compatibility with 20.x, prefer to return
2029 best_window
= window
;
2033 case GET_LRU_WINDOW
:
2034 /* `obj' is an integer encoding a bitvector.
2035 `obj & 1' means consider only full-width windows.
2036 `obj & 2' means consider also dedicated windows. */
2037 if (((XINT (obj
) & 1) && !WINDOW_FULL_WIDTH_P (w
))
2038 || (!(XINT (obj
) & 2) && !NILP (w
->dedicated
))
2039 /* Minibuffer windows are always ignored. */
2040 || MINI_WINDOW_P (w
))
2042 if (NILP (best_window
)
2043 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2044 > XFASTINT (w
->use_time
)))
2045 best_window
= window
;
2048 case DELETE_OTHER_WINDOWS
:
2049 if (!EQ (window
, obj
))
2050 Fdelete_window (window
);
2053 case DELETE_BUFFER_WINDOWS
:
2054 if (EQ (w
->buffer
, obj
))
2056 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2058 /* If this window is dedicated, and in a frame of its own,
2060 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2061 && !NILP (w
->dedicated
)
2062 && other_visible_frames (f
))
2064 /* Skip the other windows on this frame.
2065 There might be one, the minibuffer! */
2066 while (CONSP (XCDR (windows
))
2067 && EQ (XWINDOW (XCAR (windows
))->frame
,
2068 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2069 windows
= XCDR (windows
);
2071 /* Now we can safely delete the frame. */
2072 Fdelete_frame (w
->frame
, Qnil
);
2074 else if (NILP (w
->parent
))
2076 /* If we're deleting the buffer displayed in the
2077 only window on the frame, find a new buffer to
2080 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2081 Fset_window_buffer (window
, buffer
, Qnil
);
2082 if (EQ (window
, selected_window
))
2083 Fset_buffer (w
->buffer
);
2086 Fdelete_window (window
);
2090 case GET_LARGEST_WINDOW
:
2091 { /* nil `obj' means to ignore dedicated windows. */
2092 /* Ignore dedicated windows and minibuffers. */
2093 if (MINI_WINDOW_P (w
) || (NILP (obj
) && !NILP (w
->dedicated
)))
2096 if (NILP (best_window
))
2097 best_window
= window
;
2100 struct window
*b
= XWINDOW (best_window
);
2101 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2102 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2103 best_window
= window
;
2109 if (EQ (w
->buffer
, obj
))
2112 struct frame
*f
= XFRAME (w
->frame
);
2114 /* Find another buffer to show in this window. */
2115 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2117 /* If this window is dedicated, and in a frame of its own,
2119 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2120 && !NILP (w
->dedicated
)
2121 && other_visible_frames (f
))
2123 /* Skip the other windows on this frame.
2124 There might be one, the minibuffer! */
2125 while (CONSP (XCDR (windows
))
2126 && EQ (XWINDOW (XCAR (windows
))->frame
,
2127 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2128 windows
= XCDR (windows
);
2130 /* Now we can safely delete the frame. */
2131 Fdelete_frame (w
->frame
, Qnil
);
2133 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2136 XSETWINDOW (window
, w
);
2137 /* If this window is dedicated and not the only window
2138 in its frame, then kill it. */
2139 Fdelete_window (window
);
2143 /* Otherwise show a different buffer in the window. */
2144 w
->dedicated
= Qnil
;
2145 Fset_window_buffer (window
, buffer
, Qnil
);
2146 if (EQ (window
, selected_window
))
2147 Fset_buffer (w
->buffer
);
2152 case REDISPLAY_BUFFER_WINDOWS
:
2153 if (EQ (w
->buffer
, obj
))
2155 mark_window_display_accurate (window
, 0);
2156 w
->update_mode_line
= Qt
;
2157 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2158 ++update_mode_lines
;
2159 best_window
= window
;
2163 /* Check for a window that has a killed buffer. */
2164 case CHECK_ALL_WINDOWS
:
2165 if (! NILP (w
->buffer
)
2166 && NILP (XBUFFER (w
->buffer
)->name
))
2170 case WINDOW_LOOP_UNUSED
:
2179 /* Used for debugging. Abort if any window has a dead buffer. */
2182 check_all_windows ()
2184 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2187 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2188 doc
: /* Return the window least recently selected or used for display.
2189 Return a full-width window if possible.
2190 A minibuffer window is never a candidate.
2191 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2192 so if all windows are dedicated, the value is nil.
2193 If optional argument FRAME is `visible', search all visible frames.
2194 If FRAME is 0, search all visible and iconified frames.
2195 If FRAME is t, search all frames.
2196 If FRAME is nil, search only the selected frame.
2197 If FRAME is a frame, search only that frame. */)
2199 Lisp_Object frame
, dedicated
;
2201 register Lisp_Object w
;
2202 /* First try for a window that is full-width */
2203 w
= window_loop (GET_LRU_WINDOW
,
2204 NILP (dedicated
) ? make_number (1) : make_number (3),
2206 if (!NILP (w
) && !EQ (w
, selected_window
))
2208 /* If none of them, try the rest */
2209 return window_loop (GET_LRU_WINDOW
,
2210 NILP (dedicated
) ? make_number (0) : make_number (2),
2214 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2215 doc
: /* Return the largest window in area.
2216 A minibuffer window is never a candidate.
2217 A dedicated window is never a candidate unless DEDICATED is non-nil,
2218 so if all windows are dedicated, the value is nil.
2219 If optional argument FRAME is `visible', search all visible frames.
2220 If FRAME is 0, search all visible and iconified frames.
2221 If FRAME is t, search all frames.
2222 If FRAME is nil, search only the selected frame.
2223 If FRAME is a frame, search only that frame. */)
2225 Lisp_Object frame
, dedicated
;
2227 return window_loop (GET_LARGEST_WINDOW
, dedicated
, 0,
2231 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2232 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2233 BUFFER can be a buffer or a buffer name.
2234 If optional argument FRAME is `visible', search all visible frames.
2235 If optional argument FRAME is 0, search all visible and iconified frames.
2236 If FRAME is t, search all frames.
2237 If FRAME is nil, search only the selected frame.
2238 If FRAME is a frame, search only that frame. */)
2240 Lisp_Object buffer
, frame
;
2242 buffer
= Fget_buffer (buffer
);
2243 if (BUFFERP (buffer
))
2244 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2249 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2251 doc
: /* Make WINDOW (or the selected window) fill its frame.
2252 Only the frame WINDOW is on is affected.
2253 This function tries to reduce display jumps
2254 by keeping the text previously visible in WINDOW
2255 in the same place on the frame. Doing this depends on
2256 the value of (window-start WINDOW), so if calling this function
2257 in a program gives strange scrolling, make sure the window-start
2258 value is reasonable when this function is called. */)
2267 window
= selected_window
;
2269 CHECK_LIVE_WINDOW (window
);
2270 w
= XWINDOW (window
);
2272 startpos
= marker_position (w
->start
);
2273 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2275 if (MINI_WINDOW_P (w
) && top
> 0)
2276 error ("Can't expand minibuffer to full frame");
2278 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2280 /* Try to minimize scrolling, by setting the window start to the point
2281 will cause the text at the old window start to be at the same place
2282 on the frame. But don't try to do this if the window start is
2283 outside the visible portion (as might happen when the display is
2284 not current, due to typeahead). */
2285 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2287 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2288 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2290 struct position pos
;
2291 struct buffer
*obuf
= current_buffer
;
2293 Fset_buffer (w
->buffer
);
2294 /* This computation used to temporarily move point, but that can
2295 have unwanted side effects due to text properties. */
2296 pos
= *vmotion (startpos
, -top
, w
);
2298 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2299 w
->window_end_valid
= Qnil
;
2300 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2301 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2303 /* We need to do this, so that the window-scroll-functions
2305 w
->optional_new_start
= Qt
;
2307 set_buffer_internal (obuf
);
2313 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2314 1, 2, "bDelete windows on (buffer): ",
2315 doc
: /* Delete all windows showing BUFFER.
2316 BUFFER must be a buffer or the name of an existing buffer.
2317 Optional second argument FRAME controls which frames are affected.
2318 If optional argument FRAME is `visible', search all visible frames.
2319 If FRAME is 0, search all visible and iconified frames.
2320 If FRAME is nil, search all frames.
2321 If FRAME is t, search only the selected frame.
2322 If FRAME is a frame, search only that frame. */)
2324 Lisp_Object buffer
, frame
;
2326 /* FRAME uses t and nil to mean the opposite of what window_loop
2330 else if (EQ (frame
, Qt
))
2335 buffer
= Fget_buffer (buffer
);
2336 CHECK_BUFFER (buffer
);
2337 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2343 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2344 Sreplace_buffer_in_windows
,
2345 1, 1, "bReplace buffer in windows: ",
2346 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2347 BUFFER may be a buffer or the name of an existing buffer. */)
2353 buffer
= Fget_buffer (buffer
);
2354 CHECK_BUFFER (buffer
);
2355 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2360 /* Replace BUFFER with some other buffer in all windows
2361 of all frames, even those on other keyboards. */
2364 replace_buffer_in_all_windows (buffer
)
2368 Lisp_Object tail
, frame
;
2370 /* A single call to window_loop won't do the job
2371 because it only considers frames on the current keyboard.
2372 So loop manually over frames, and handle each one. */
2373 FOR_EACH_FRAME (tail
, frame
)
2374 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2376 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2380 /* Set the height of WINDOW and all its inferiors. */
2382 /* The smallest acceptable dimensions for a window. Anything smaller
2383 might crash Emacs. */
2385 #define MIN_SAFE_WINDOW_WIDTH (2)
2386 #define MIN_SAFE_WINDOW_HEIGHT (1)
2388 /* Make sure that window_min_height and window_min_width are
2389 not too small; if they are, set them to safe minima. */
2392 check_min_window_sizes ()
2394 /* Smaller values might permit a crash. */
2395 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2396 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2397 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2398 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2401 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2402 minimum allowable size. */
2405 check_frame_size (frame
, rows
, cols
)
2409 /* For height, we have to see:
2410 how many windows the frame has at minimum (one or two),
2411 and whether it has a menu bar or other special stuff at the top. */
2413 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2414 ? MIN_SAFE_WINDOW_HEIGHT
2415 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2417 if (FRAME_TOP_MARGIN (frame
) > 0)
2418 min_height
+= FRAME_TOP_MARGIN (frame
);
2420 if (*rows
< min_height
)
2422 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2423 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2427 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2428 check if W's width can be changed, otherwise check W's height.
2429 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2430 siblings, too. If none of the siblings is resizable, WINDOW isn't
2434 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2436 int width_p
, check_siblings_p
;
2441 if (!NILP (w
->hchild
))
2443 c
= XWINDOW (w
->hchild
);
2447 /* A horiz. combination is fixed-width if all of if its
2449 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2450 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2451 fixed_p
= c
== NULL
;
2455 /* A horiz. combination is fixed-height if one of if its
2457 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2458 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2459 fixed_p
= c
!= NULL
;
2462 else if (!NILP (w
->vchild
))
2464 c
= XWINDOW (w
->vchild
);
2468 /* A vert. combination is fixed-width if one of if its
2470 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2471 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2472 fixed_p
= c
!= NULL
;
2476 /* A vert. combination is fixed-height if all of if its
2478 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2479 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2480 fixed_p
= c
== NULL
;
2483 else if (BUFFERP (w
->buffer
))
2485 struct buffer
*old
= current_buffer
;
2488 current_buffer
= XBUFFER (w
->buffer
);
2489 val
= find_symbol_value (Qwindow_size_fixed
);
2490 current_buffer
= old
;
2493 if (!EQ (val
, Qunbound
))
2495 fixed_p
= !NILP (val
);
2498 && ((EQ (val
, Qheight
) && width_p
)
2499 || (EQ (val
, Qwidth
) && !width_p
)))
2503 /* Can't tell if this one is resizable without looking at
2504 siblings. If all siblings are fixed-size this one is too. */
2505 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2509 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2510 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2514 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2515 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2529 /* Return the minimum size of window W, not taking fixed-width windows
2530 into account. WIDTH_P non-zero means return the minimum width,
2531 otherwise return the minimum height. If W is a combination window,
2532 compute the minimum size from the minimum sizes of W's children. */
2535 window_min_size_1 (w
, width_p
)
2542 if (!NILP (w
->hchild
))
2544 c
= XWINDOW (w
->hchild
);
2549 /* The min width of a horizontal combination is
2550 the sum of the min widths of its children. */
2553 size
+= window_min_size_1 (c
, width_p
);
2554 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2559 /* The min height a horizontal combination equals
2560 the maximum of all min height of its children. */
2563 int min_size
= window_min_size_1 (c
, width_p
);
2564 size
= max (min_size
, size
);
2565 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2569 else if (!NILP (w
->vchild
))
2571 c
= XWINDOW (w
->vchild
);
2576 /* The min width of a vertical combination is
2577 the maximum of the min widths of its children. */
2580 int min_size
= window_min_size_1 (c
, width_p
);
2581 size
= max (min_size
, size
);
2582 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2587 /* The min height of a vertical combination equals
2588 the sum of the min height of its children. */
2591 size
+= window_min_size_1 (c
, width_p
);
2592 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2599 size
= max (window_min_width
,
2600 (MIN_SAFE_WINDOW_WIDTH
2601 + WINDOW_FRINGE_COLS (w
)
2602 + WINDOW_SCROLL_BAR_COLS (w
)));
2605 if (MINI_WINDOW_P (w
)
2606 || (!WINDOW_WANTS_MODELINE_P (w
)
2607 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2610 size
= window_min_height
;
2618 /* Return the minimum size of window W, taking fixed-size windows into
2619 account. WIDTH_P non-zero means return the minimum width,
2620 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2621 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2622 unless FIXED is null. */
2625 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2627 int width_p
, ignore_fixed_p
, *fixed
;
2634 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2640 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2642 size
= window_min_size_1 (w
, width_p
);
2648 /* Adjust the margins of window W if text area is too small.
2649 Return 1 if window width is ok after adjustment; 0 if window
2650 is still too narrow. */
2653 adjust_window_margins (w
)
2656 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2657 - WINDOW_FRINGE_COLS (w
)
2658 - WINDOW_SCROLL_BAR_COLS (w
));
2659 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2660 + WINDOW_RIGHT_MARGIN_COLS (w
));
2662 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2665 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2668 /* Window's text area is too narrow, but reducing the window
2669 margins will fix that. */
2670 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2671 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2673 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2674 w
->left_margin_cols
= w
->right_margin_cols
2675 = make_number (margin_cols
/2);
2677 w
->right_margin_cols
= make_number (margin_cols
);
2680 w
->left_margin_cols
= make_number (margin_cols
);
2684 /* Calculate new sizes for windows in the list FORWARD when the window size
2685 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2686 The number of windows in FORWARD is NCHILDREN, and the number that
2687 can shrink is SHRINKABLE.
2688 The minimum size a window can have is MIN_SIZE.
2689 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2690 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2693 This function returns an allocated array of new sizes that the caller
2694 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2695 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2696 the second, and so on.
2698 This function tries to keep windows at least at the minimum size
2699 and resize other windows before it resizes any window to zero (i.e.
2700 delete that window).
2702 Windows are resized proportional to their size, so bigger windows
2703 shrink more than smaller windows. */
2705 shrink_windows (total
, size
, nchildren
, shrinkable
,
2706 min_size
, resize_fixed_p
, forward
, width_p
)
2707 int total
, size
, nchildren
, shrinkable
, min_size
;
2708 int resize_fixed_p
, width_p
;
2709 Lisp_Object forward
;
2711 int available_resize
= 0;
2715 int smallest
= total
;
2716 int total_removed
= 0;
2717 int total_shrink
= total
- size
;
2720 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2722 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2726 c
= XWINDOW (child
);
2727 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2729 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2733 new_sizes
[i
] = child_size
;
2734 if (child_size
> min_size
)
2735 available_resize
+= child_size
- min_size
;
2738 /* We might need to shrink some windows to zero. Find the smallest
2739 windows and set them to 0 until we can fulfil the new size. */
2741 while (shrinkable
> 1 && size
+ available_resize
< total
)
2743 for (i
= 0; i
< nchildren
; ++i
)
2744 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2745 smallest
= new_sizes
[i
];
2747 for (i
= 0; i
< nchildren
; ++i
)
2748 if (new_sizes
[i
] == smallest
)
2750 /* Resize this window down to zero. */
2752 if (smallest
> min_size
)
2753 available_resize
-= smallest
- min_size
;
2754 available_resize
+= smallest
;
2756 total_removed
+= smallest
;
2758 /* We don't know what the smallest is now. */
2761 /* Out of for, just remove one window at the time and
2762 check again if we have enough space. */
2767 /* Now, calculate the new sizes. Try to shrink each window
2768 proportional to its size. */
2769 for (i
= 0; i
< nchildren
; ++i
)
2771 if (new_sizes
[i
] > min_size
)
2773 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2774 if (new_sizes
[i
] - to_shrink
< min_size
)
2775 to_shrink
= new_sizes
[i
] - min_size
;
2776 new_sizes
[i
] -= to_shrink
;
2777 total_removed
+= to_shrink
;
2781 /* Any reminder due to rounding, we just subtract from windows
2782 that are left and still can be shrunk. */
2783 while (total_shrink
> total_removed
)
2785 int nonzero_sizes
= 0;
2786 int nonzero_idx
= -1;
2788 for (i
= 0; i
< nchildren
; ++i
)
2789 if (new_sizes
[i
] > 0)
2795 for (i
= 0; i
< nchildren
; ++i
)
2796 if (new_sizes
[i
] > min_size
)
2801 /* Out of for, just shrink one window at the time and
2802 check again if we have enough space. */
2807 /* Special case, only one window left. */
2808 if (nonzero_sizes
== 1)
2812 /* Any surplus due to rounding, we add to windows that are left. */
2813 while (total_shrink
< total_removed
)
2815 for (i
= 0; i
< nchildren
; ++i
)
2817 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2829 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2830 WINDOW's width. Resize WINDOW's children, if any, so that they
2831 keep their proportionate size relative to WINDOW.
2833 If FIRST_ONLY is 1, change only the first of WINDOW's children when
2834 they are in series. If LAST_ONLY is 1, change only the last of
2835 WINDOW's children when they are in series.
2837 Propagate WINDOW's top or left edge position to children. Delete
2838 windows that become too small unless NODELETE_P is non-zero.
2840 If NODELETE_P is 2, that means we do delete windows that are
2841 too small, even if they were too small before! */
2844 size_window (window
, size
, width_p
, nodelete_p
, first_only
, last_only
)
2846 int size
, width_p
, nodelete_p
;
2847 int first_only
, last_only
;
2849 struct window
*w
= XWINDOW (window
);
2851 Lisp_Object child
, *forward
, *sideward
;
2852 int old_size
, min_size
, safe_min_size
;
2854 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2855 seems like it's too soon to do this here. ++KFS. */
2856 if (nodelete_p
== 2)
2859 check_min_window_sizes ();
2860 size
= max (0, size
);
2862 /* If the window has been "too small" at one point,
2863 don't delete it for being "too small" in the future.
2864 Preserve it as long as that is at all possible. */
2867 old_size
= WINDOW_TOTAL_COLS (w
);
2868 min_size
= window_min_width
;
2869 /* Ensure that there is room for the scroll bar and fringes!
2870 We may reduce display margins though. */
2871 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2872 + WINDOW_FRINGE_COLS (w
)
2873 + WINDOW_SCROLL_BAR_COLS (w
));
2877 old_size
= XINT (w
->total_lines
);
2878 min_size
= window_min_height
;
2879 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2882 if (old_size
< min_size
&& nodelete_p
!= 2)
2883 w
->too_small_ok
= Qt
;
2885 /* Maybe delete WINDOW if it's too small. */
2886 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2888 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2889 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2890 if (min_size
< safe_min_size
)
2891 min_size
= safe_min_size
;
2892 if (size
< min_size
)
2894 delete_window (window
);
2899 /* Set redisplay hints. */
2900 w
->last_modified
= make_number (0);
2901 w
->last_overlay_modified
= make_number (0);
2902 windows_or_buffers_changed
++;
2903 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2907 sideward
= &w
->vchild
;
2908 forward
= &w
->hchild
;
2909 w
->total_cols
= make_number (size
);
2910 adjust_window_margins (w
);
2914 sideward
= &w
->hchild
;
2915 forward
= &w
->vchild
;
2916 w
->total_lines
= make_number (size
);
2917 w
->orig_total_lines
= Qnil
;
2920 if (!NILP (*sideward
))
2922 /* We have a chain of parallel siblings whose size should all change. */
2923 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2925 c
= XWINDOW (child
);
2927 c
->left_col
= w
->left_col
;
2929 c
->top_line
= w
->top_line
;
2930 size_window (child
, size
, width_p
, nodelete_p
,
2931 first_only
, last_only
);
2934 else if (!NILP (*forward
) && last_only
)
2936 /* Change the last in a series of siblings. */
2937 Lisp_Object last_child
;
2940 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2942 c
= XWINDOW (child
);
2946 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
2947 size_window (last_child
,
2948 size
- old_size
+ child_size
,
2949 width_p
, nodelete_p
, first_only
, last_only
);
2951 else if (!NILP (*forward
) && first_only
)
2953 /* Change the first in a series of siblings. */
2957 c
= XWINDOW (child
);
2960 c
->left_col
= w
->left_col
;
2962 c
->top_line
= w
->top_line
;
2964 child_size
= XINT (width_p
? c
->total_cols
: c
->total_lines
);
2966 size
- old_size
+ child_size
,
2967 width_p
, nodelete_p
, first_only
, last_only
);
2969 else if (!NILP (*forward
))
2971 int fixed_size
, each
, extra
, n
;
2972 int resize_fixed_p
, nfixed
;
2973 int last_pos
, first_pos
, nchildren
, total
;
2974 int *new_sizes
= NULL
;
2976 /* Determine the fixed-size portion of this window, and the
2977 number of child windows. */
2978 fixed_size
= nchildren
= nfixed
= total
= 0;
2979 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2983 c
= XWINDOW (child
);
2984 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2985 total
+= child_size
;
2987 if (window_fixed_size_p (c
, width_p
, 0))
2989 fixed_size
+= child_size
;
2994 /* If the new size is smaller than fixed_size, or if there
2995 aren't any resizable windows, allow resizing fixed-size
2997 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2999 /* Compute how many lines/columns to add/remove to each child. The
3000 value of extra takes care of rounding errors. */
3001 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
3002 if (size
< total
&& n
> 1)
3003 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
3004 resize_fixed_p
, *forward
, width_p
);
3007 each
= (size
- total
) / n
;
3008 extra
= (size
- total
) - n
* each
;
3011 /* Compute new children heights and edge positions. */
3012 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
3013 last_pos
= first_pos
;
3014 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
3016 int new_size
, old_size
;
3018 c
= XWINDOW (child
);
3019 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
3020 new_size
= old_size
;
3022 /* The top or left edge position of this child equals the
3023 bottom or right edge of its predecessor. */
3025 c
->left_col
= make_number (last_pos
);
3027 c
->top_line
= make_number (last_pos
);
3029 /* If this child can be resized, do it. */
3030 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
3032 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
3036 /* Set new height. Note that size_window also propagates
3037 edge positions to children, so it's not a no-op if we
3038 didn't change the child's size. */
3039 size_window (child
, new_size
, width_p
, 1, first_only
, last_only
);
3041 /* Remember the bottom/right edge position of this child; it
3042 will be used to set the top/left edge of the next child. */
3043 last_pos
+= new_size
;
3046 if (new_sizes
) xfree (new_sizes
);
3048 /* We should have covered the parent exactly with child windows. */
3049 xassert (size
== last_pos
- first_pos
);
3051 /* Now delete any children that became too small. */
3053 for (child
= *forward
; !NILP (child
); child
= c
->next
)
3056 c
= XWINDOW (child
);
3057 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
3058 size_window (child
, child_size
, width_p
, 2, first_only
, last_only
);
3063 /* Set WINDOW's height to HEIGHT, and recursively change the height of
3064 WINDOW's children. NODELETE non-zero means don't delete windows
3065 that become too small in the process. (The caller should check
3066 later and do so if appropriate.) */
3069 set_window_height (window
, height
, nodelete
)
3074 size_window (window
, height
, 0, nodelete
, 0, 0);
3078 /* Set WINDOW's width to WIDTH, and recursively change the width of
3079 WINDOW's children. NODELETE non-zero means don't delete windows
3080 that become too small in the process. (The caller should check
3081 later and do so if appropriate.) */
3084 set_window_width (window
, width
, nodelete
)
3089 size_window (window
, width
, 1, nodelete
, 0, 0);
3092 /* Change window heights in windows rooted in WINDOW by N lines. */
3095 change_window_heights (window
, n
)
3099 struct window
*w
= XWINDOW (window
);
3101 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3102 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3104 if (INTEGERP (w
->orig_top_line
))
3105 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3106 if (INTEGERP (w
->orig_total_lines
))
3107 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3109 /* Handle just the top child in a vertical split. */
3110 if (!NILP (w
->vchild
))
3111 change_window_heights (w
->vchild
, n
);
3113 /* Adjust all children in a horizontal split. */
3114 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3116 w
= XWINDOW (window
);
3117 change_window_heights (window
, n
);
3122 int window_select_count
;
3125 Fset_window_buffer_unwind (obuf
)
3132 EXFUN (Fset_window_fringes
, 4);
3133 EXFUN (Fset_window_scroll_bars
, 4);
3135 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3136 means it's allowed to run hooks. See make_frame for a case where
3137 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3138 margins, fringes, and scroll-bar settings of the window are not
3139 reset from the buffer's local settings. */
3142 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3143 Lisp_Object window
, buffer
;
3144 int run_hooks_p
, keep_margins_p
;
3146 struct window
*w
= XWINDOW (window
);
3147 struct buffer
*b
= XBUFFER (buffer
);
3148 int count
= SPECPDL_INDEX ();
3152 if (EQ (window
, selected_window
))
3153 b
->last_selected_window
= window
;
3155 /* Let redisplay errors through. */
3156 b
->display_error_modiff
= 0;
3158 /* Update time stamps of buffer display. */
3159 if (INTEGERP (b
->display_count
))
3160 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3161 b
->display_time
= Fcurrent_time ();
3163 XSETFASTINT (w
->window_end_pos
, 0);
3164 XSETFASTINT (w
->window_end_vpos
, 0);
3165 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3166 w
->window_end_valid
= Qnil
;
3167 w
->hscroll
= w
->min_hscroll
= make_number (0);
3169 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3170 set_marker_restricted (w
->start
,
3171 make_number (b
->last_window_start
),
3173 w
->start_at_line_beg
= Qnil
;
3174 w
->force_start
= Qnil
;
3175 XSETFASTINT (w
->last_modified
, 0);
3176 XSETFASTINT (w
->last_overlay_modified
, 0);
3177 windows_or_buffers_changed
++;
3179 /* We must select BUFFER for running the window-scroll-functions.
3180 If WINDOW is selected, switch permanently.
3181 Otherwise, switch but go back to the ambient buffer afterward. */
3182 if (EQ (window
, selected_window
))
3183 Fset_buffer (buffer
);
3184 /* We can't check ! NILP (Vwindow_scroll_functions) here
3185 because that might itself be a local variable. */
3186 else if (window_initialized
)
3188 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3189 Fset_buffer (buffer
);
3192 if (!keep_margins_p
)
3194 /* Set left and right marginal area width etc. from buffer. */
3196 /* This may call adjust_window_margins three times, so
3197 temporarily disable window margins. */
3198 Lisp_Object save_left
= w
->left_margin_cols
;
3199 Lisp_Object save_right
= w
->right_margin_cols
;
3201 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3203 Fset_window_fringes (window
,
3204 b
->left_fringe_width
, b
->right_fringe_width
,
3205 b
->fringes_outside_margins
);
3207 Fset_window_scroll_bars (window
,
3208 b
->scroll_bar_width
,
3209 b
->vertical_scroll_bar_type
, Qnil
);
3211 w
->left_margin_cols
= save_left
;
3212 w
->right_margin_cols
= save_right
;
3214 Fset_window_margins (window
,
3215 b
->left_margin_cols
, b
->right_margin_cols
);
3220 if (! NILP (Vwindow_scroll_functions
))
3221 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3222 Fmarker_position (w
->start
));
3224 if (! NILP (Vwindow_configuration_change_hook
)
3225 && ! NILP (Vrun_hooks
))
3226 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3229 unbind_to (count
, Qnil
);
3233 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3234 doc
: /* Make WINDOW display BUFFER as its contents.
3235 BUFFER can be a buffer or the name of an existing buffer.
3236 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3237 display margins, fringe widths, and scroll bar settings are maintained;
3238 the default is to reset these from BUFFER's local settings or the frame
3241 This function runs the hook `window-scroll-functions'. */)
3242 (window
, buffer
, keep_margins
)
3243 register Lisp_Object window
, buffer
, keep_margins
;
3245 register Lisp_Object tem
;
3246 register struct window
*w
= decode_window (window
);
3248 XSETWINDOW (window
, w
);
3249 buffer
= Fget_buffer (buffer
);
3250 CHECK_BUFFER (buffer
);
3252 if (NILP (XBUFFER (buffer
)->name
))
3253 error ("Attempt to display deleted buffer");
3257 error ("Window is deleted");
3258 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3259 is first being set up. */
3261 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3262 error ("Window is dedicated to `%s'",
3263 SDATA (XBUFFER (tem
)->name
));
3268 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3272 /* Note that selected_window can be nil
3273 when this is called from Fset_window_configuration. */
3275 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3276 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3277 If WINDOW is not already selected, make WINDOW's buffer current
3278 and make WINDOW the frame's selected window. Return WINDOW.
3279 Optional second arg NORECORD non-nil means
3280 do not put this buffer at the front of the list of recently selected ones.
3282 Note that the main editor command loop
3283 selects the buffer of the selected window before each command. */)
3285 register Lisp_Object window
, norecord
;
3287 register struct window
*w
;
3288 register struct window
*ow
;
3291 CHECK_LIVE_WINDOW (window
);
3293 w
= XWINDOW (window
);
3294 w
->frozen_window_start_p
= 0;
3296 ++window_select_count
;
3297 XSETFASTINT (w
->use_time
, window_select_count
);
3298 if (EQ (window
, selected_window
))
3301 /* Store the current buffer's actual point into the
3302 old selected window. It belongs to that window,
3303 and when the window is not selected, must be in the window. */
3304 if (!NILP (selected_window
))
3306 ow
= XWINDOW (selected_window
);
3307 if (! NILP (ow
->buffer
))
3308 set_marker_both (ow
->pointm
, ow
->buffer
,
3309 BUF_PT (XBUFFER (ow
->buffer
)),
3310 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3313 selected_window
= window
;
3314 sf
= SELECTED_FRAME ();
3315 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3317 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3318 /* Use this rather than Fhandle_switch_frame
3319 so that FRAME_FOCUS_FRAME is moved appropriately as we
3320 move around in the state where a minibuffer in a separate
3322 Fselect_frame (WINDOW_FRAME (w
));
3325 sf
->selected_window
= window
;
3327 if (NILP (norecord
))
3328 record_buffer (w
->buffer
);
3329 Fset_buffer (w
->buffer
);
3331 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3333 /* Go to the point recorded in the window.
3334 This is important when the buffer is in more
3335 than one window. It also matters when
3336 redisplay_window has altered point after scrolling,
3337 because it makes the change only in the window. */
3339 register int new_point
= marker_position (w
->pointm
);
3340 if (new_point
< BEGV
)
3342 else if (new_point
> ZV
)
3348 windows_or_buffers_changed
++;
3353 select_window_norecord (window
)
3356 return Fselect_window (window
, Qt
);
3359 /* Deiconify the frame containing the window WINDOW,
3360 unless it is the selected frame;
3363 The reason for the exception for the selected frame
3364 is that it seems better not to change the selected frames visibility
3365 merely because of displaying a different buffer in it.
3366 The deiconification is useful when a buffer gets shown in
3367 another frame that you were not using lately. */
3370 display_buffer_1 (window
)
3373 Lisp_Object frame
= XWINDOW (window
)->frame
;
3374 FRAME_PTR f
= XFRAME (frame
);
3376 FRAME_SAMPLE_VISIBILITY (f
);
3378 if (EQ (frame
, selected_frame
))
3379 ; /* Assume the selected frame is already visible enough. */
3380 else if (minibuf_level
> 0
3381 && MINI_WINDOW_P (XWINDOW (selected_window
))
3382 && WINDOW_LIVE_P (minibuf_selected_window
)
3383 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3384 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3387 if (FRAME_ICONIFIED_P (f
))
3388 Fmake_frame_visible (frame
);
3389 else if (FRAME_VISIBLE_P (f
))
3390 Fraise_frame (frame
);
3396 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3397 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3398 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3399 special frame for that buffer using the default frame parameters.
3401 If the value is a list, it is a list of frame parameters that would be used
3402 to make a frame for that buffer.
3403 The variables `special-display-buffer-names'
3404 and `special-display-regexps' control this. */)
3406 Lisp_Object buffer_name
;
3410 CHECK_STRING (buffer_name
);
3412 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3416 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3420 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3422 Lisp_Object car
= XCAR (tem
);
3424 && fast_string_match (car
, buffer_name
) >= 0)
3426 else if (CONSP (car
)
3427 && STRINGP (XCAR (car
))
3428 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3434 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3435 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3436 More precisely, if `display-buffer' or `pop-to-buffer' would display
3437 that buffer in the selected window rather than (as usual) in some other window.
3438 See `same-window-buffer-names' and `same-window-regexps'. */)
3440 Lisp_Object buffer_name
;
3444 CHECK_STRING (buffer_name
);
3446 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3450 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3454 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3456 Lisp_Object car
= XCAR (tem
);
3458 && fast_string_match (car
, buffer_name
) >= 0)
3460 else if (CONSP (car
)
3461 && STRINGP (XCAR (car
))
3462 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3468 /* Use B so the default is (other-buffer). */
3469 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3470 "BDisplay buffer: \nP",
3471 doc
: /* Make BUFFER appear in some window but don't select it.
3472 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3474 If BUFFER is shown already in some window, just use that one,
3475 unless the window is the selected window and the optional second
3476 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3477 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3478 Returns the window displaying BUFFER.
3479 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3480 displaying BUFFER, then simply raise that frame.
3482 The variables `special-display-buffer-names',
3483 `special-display-regexps', `same-window-buffer-names', and
3484 `same-window-regexps' customize how certain buffer names are handled.
3485 The latter two take effect only if NOT-THIS-WINDOW is nil.
3487 If optional argument FRAME is `visible', search all visible frames.
3488 If FRAME is 0, search all visible and iconified frames.
3489 If FRAME is t, search all frames.
3490 If FRAME is a frame, search only that frame.
3491 If FRAME is nil, search only the selected frame
3492 (actually the last nonminibuffer frame),
3493 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3494 which means search visible and iconified frames.
3496 If a full-width window on a splittable frame is available to display
3497 the buffer, it may be split, subject to the value of the variable
3498 `split-height-threshold'.
3500 If `even-window-heights' is non-nil, window heights will be evened out
3501 if displaying the buffer causes two vertically adjacent windows to be
3503 (buffer
, not_this_window
, frame
)
3504 register Lisp_Object buffer
, not_this_window
, frame
;
3506 register Lisp_Object window
, tem
, swp
;
3510 buffer
= Fget_buffer (buffer
);
3511 CHECK_BUFFER (buffer
);
3513 if (!NILP (Vdisplay_buffer_function
))
3514 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3516 if (NILP (not_this_window
)
3517 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3518 return display_buffer_1 (selected_window
);
3520 /* See if the user has specified this buffer should appear
3521 in the selected window. */
3522 if (NILP (not_this_window
))
3524 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3525 if (!NILP (swp
) && !no_switch_window (selected_window
))
3527 Fswitch_to_buffer (buffer
, Qnil
);
3528 return display_buffer_1 (selected_window
);
3532 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3533 look for a window showing BUFFER on any visible or iconified frame.
3534 Otherwise search only the current frame. */
3537 else if (pop_up_frames
3538 || display_buffer_reuse_frames
3539 || last_nonminibuf_frame
== 0)
3540 XSETFASTINT (tem
, 0);
3542 XSETFRAME (tem
, last_nonminibuf_frame
);
3544 window
= Fget_buffer_window (buffer
, tem
);
3546 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3547 return display_buffer_1 (window
);
3549 /* Certain buffer names get special handling. */
3550 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3552 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3554 return call1 (Vspecial_display_function
, buffer
);
3556 return call2 (Vspecial_display_function
, buffer
, tem
);
3559 /* If there are no frames open that have more than a minibuffer,
3560 we need to create a new frame. */
3561 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3563 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3564 Fset_window_buffer (window
, buffer
, Qnil
);
3565 return display_buffer_1 (window
);
3568 f
= SELECTED_FRAME ();
3570 || FRAME_MINIBUF_ONLY_P (f
)
3571 /* If the current frame is a special display frame,
3572 don't try to reuse its windows. */
3573 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3578 if (FRAME_MINIBUF_ONLY_P (f
))
3579 XSETFRAME (frames
, last_nonminibuf_frame
);
3580 /* Don't try to create a window if we would get an error. */
3581 if (split_height_threshold
< window_min_height
<< 1)
3582 split_height_threshold
= window_min_height
<< 1;
3584 /* Note that both Fget_largest_window and Fget_lru_window
3585 ignore minibuffers and dedicated windows.
3586 This means they can return nil. */
3588 /* If the frame we would try to split cannot be split,
3589 try other frames. */
3590 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3592 /* Try visible frames first. */
3593 window
= Fget_largest_window (Qvisible
, Qt
);
3594 /* If that didn't work, try iconified frames. */
3596 window
= Fget_largest_window (make_number (0), Qt
);
3597 #if 0 /* Don't try windows on other displays. */
3599 window
= Fget_largest_window (Qt
, Qt
);
3603 window
= Fget_largest_window (frames
, Qt
);
3605 /* If we got a tall enough full-width window that can be split,
3608 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3609 && window_height (window
) >= split_height_threshold
3610 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3611 window
= Fsplit_window (window
, Qnil
, Qnil
);
3614 Lisp_Object upper
, lower
, other
;
3616 window
= Fget_lru_window (frames
, Qt
);
3617 /* If the LRU window is selected, and big enough,
3618 and can be split, split it. */
3620 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3621 && (EQ (window
, selected_window
)
3622 || EQ (XWINDOW (window
)->parent
, Qnil
))
3623 && window_height (window
) >= window_min_height
<< 1)
3624 window
= Fsplit_window (window
, Qnil
, Qnil
);
3626 window
= Fget_lru_window (frames
, Qnil
);
3627 /* If Fget_lru_window returned nil, try other approaches. */
3629 /* Try visible frames first. */
3631 window
= Fget_buffer_window (buffer
, Qvisible
);
3633 window
= Fget_largest_window (Qvisible
, Qnil
);
3634 /* If that didn't work, try iconified frames. */
3636 window
= Fget_buffer_window (buffer
, make_number (0));
3638 window
= Fget_largest_window (make_number (0), Qnil
);
3640 #if 0 /* Don't try frames on other displays. */
3642 window
= Fget_buffer_window (buffer
, Qt
);
3644 window
= Fget_largest_window (Qt
, Qnil
);
3646 /* As a last resort, make a new frame. */
3648 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3649 /* If window appears above or below another,
3650 even out their heights. */
3651 other
= upper
= lower
= Qnil
;
3652 if (!NILP (XWINDOW (window
)->prev
))
3653 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3654 if (!NILP (XWINDOW (window
)->next
))
3655 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3657 && !NILP (Veven_window_heights
)
3658 /* Check that OTHER and WINDOW are vertically arrayed. */
3659 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3660 && (XFASTINT (XWINDOW (other
)->total_lines
)
3661 > XFASTINT (XWINDOW (window
)->total_lines
)))
3663 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3664 + XFASTINT (XWINDOW (window
)->total_lines
));
3665 enlarge_window (upper
,
3666 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3672 window
= Fget_lru_window (Qnil
, Qnil
);
3674 Fset_window_buffer (window
, buffer
, Qnil
);
3675 return display_buffer_1 (window
);
3679 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3681 doc
: /* Force redisplay of all windows.
3682 If optional arg OBJECT is a window, force redisplay of that window only.
3683 If OBJECT is a buffer or buffer name, force redisplay of all windows
3684 displaying that buffer. */)
3690 windows_or_buffers_changed
++;
3691 update_mode_lines
++;
3695 if (WINDOWP (object
))
3697 struct window
*w
= XWINDOW (object
);
3698 mark_window_display_accurate (object
, 0);
3699 w
->update_mode_line
= Qt
;
3700 if (BUFFERP (w
->buffer
))
3701 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3702 ++update_mode_lines
;
3706 if (STRINGP (object
))
3707 object
= Fget_buffer (object
);
3708 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3710 /* Walk all windows looking for buffer, and force update
3711 of each of those windows. */
3713 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3714 return NILP (object
) ? Qnil
: Qt
;
3717 /* If nothing suitable was found, just return.
3718 We could signal an error, but this feature will typically be used
3719 asynchronously in timers or process sentinels, so we don't. */
3725 temp_output_buffer_show (buf
)
3726 register Lisp_Object buf
;
3728 register struct buffer
*old
= current_buffer
;
3729 register Lisp_Object window
;
3730 register struct window
*w
;
3732 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3735 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3739 #if 0 /* rms: there should be no reason for this. */
3740 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3742 set_buffer_internal (old
);
3744 if (!NILP (Vtemp_buffer_show_function
))
3745 call1 (Vtemp_buffer_show_function
, buf
);
3748 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3750 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3751 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3752 Vminibuf_scroll_window
= window
;
3753 w
= XWINDOW (window
);
3754 XSETFASTINT (w
->hscroll
, 0);
3755 XSETFASTINT (w
->min_hscroll
, 0);
3756 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3757 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3759 /* Run temp-buffer-show-hook, with the chosen window selected
3760 and its buffer current. */
3762 if (!NILP (Vrun_hooks
)
3763 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3764 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3766 int count
= SPECPDL_INDEX ();
3767 Lisp_Object prev_window
, prev_buffer
;
3768 prev_window
= selected_window
;
3769 XSETBUFFER (prev_buffer
, old
);
3771 /* Select the window that was chosen, for running the hook.
3772 Note: Both Fselect_window and select_window_norecord may
3773 set-buffer to the buffer displayed in the window,
3774 so we need to save the current buffer. --stef */
3775 record_unwind_protect (Fset_buffer
, prev_buffer
);
3776 record_unwind_protect (select_window_norecord
, prev_window
);
3777 Fselect_window (window
, Qt
);
3778 Fset_buffer (w
->buffer
);
3779 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3780 unbind_to (count
, Qnil
);
3786 make_dummy_parent (window
)
3790 register struct window
*o
, *p
;
3793 o
= XWINDOW (window
);
3794 p
= allocate_window ();
3795 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3796 ((struct Lisp_Vector
*) p
)->contents
[i
]
3797 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3798 XSETWINDOW (new, p
);
3801 XSETFASTINT (p
->sequence_number
, sequence_number
);
3803 /* Put new into window structure in place of window */
3804 replace_window (window
, new);
3817 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3818 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3819 WINDOW defaults to selected one and SIZE to half its size.
3820 If optional third arg HORFLAG is non-nil, split side by side
3821 and put SIZE columns in the first of the pair. In that case,
3822 SIZE includes that window's scroll bar, or the divider column to its right.
3823 Interactively, all arguments are nil.
3825 Returns the newly created window (which is the lower or rightmost one).
3826 The upper or leftmost window is the original one, and remains selected
3827 if it was selected before.
3829 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3830 (window
, size
, horflag
)
3831 Lisp_Object window
, size
, horflag
;
3833 register Lisp_Object
new;
3834 register struct window
*o
, *p
;
3836 register int size_int
;
3839 window
= selected_window
;
3841 CHECK_LIVE_WINDOW (window
);
3843 o
= XWINDOW (window
);
3844 fo
= XFRAME (WINDOW_FRAME (o
));
3848 if (!NILP (horflag
))
3849 /* Calculate the size of the left-hand window, by dividing
3850 the usable space in columns by two.
3851 We round up, since the left-hand window may include
3852 a dividing line, while the right-hand may not. */
3853 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3855 size_int
= XFASTINT (o
->total_lines
) >> 1;
3859 CHECK_NUMBER (size
);
3860 size_int
= XINT (size
);
3863 if (MINI_WINDOW_P (o
))
3864 error ("Attempt to split minibuffer window");
3865 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3866 error ("Attempt to split fixed-size window");
3868 check_min_window_sizes ();
3872 if (size_int
< window_min_height
)
3873 error ("Window height %d too small (after splitting)", size_int
);
3874 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3875 error ("Window height %d too small (after splitting)",
3876 XFASTINT (o
->total_lines
) - size_int
);
3877 if (NILP (o
->parent
)
3878 || NILP (XWINDOW (o
->parent
)->vchild
))
3880 make_dummy_parent (window
);
3882 XWINDOW (new)->vchild
= window
;
3887 if (size_int
< window_min_width
)
3888 error ("Window width %d too small (after splitting)", size_int
);
3890 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3891 error ("Window width %d too small (after splitting)",
3892 XFASTINT (o
->total_cols
) - size_int
);
3893 if (NILP (o
->parent
)
3894 || NILP (XWINDOW (o
->parent
)->hchild
))
3896 make_dummy_parent (window
);
3898 XWINDOW (new)->hchild
= window
;
3902 /* Now we know that window's parent is a vertical combination
3903 if we are dividing vertically, or a horizontal combination
3904 if we are making side-by-side windows */
3906 windows_or_buffers_changed
++;
3907 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3908 new = make_window ();
3911 p
->frame
= o
->frame
;
3913 if (!NILP (p
->next
))
3914 XWINDOW (p
->next
)->prev
= new;
3917 p
->parent
= o
->parent
;
3919 p
->window_end_valid
= Qnil
;
3920 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3922 /* Duplicate special geometry settings. */
3924 p
->left_margin_cols
= o
->left_margin_cols
;
3925 p
->right_margin_cols
= o
->right_margin_cols
;
3926 p
->left_fringe_width
= o
->left_fringe_width
;
3927 p
->right_fringe_width
= o
->right_fringe_width
;
3928 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3929 p
->scroll_bar_width
= o
->scroll_bar_width
;
3930 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3932 /* Apportion the available frame space among the two new windows */
3934 if (!NILP (horflag
))
3936 p
->total_lines
= o
->total_lines
;
3937 p
->top_line
= o
->top_line
;
3938 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3939 XSETFASTINT (o
->total_cols
, size_int
);
3940 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3941 adjust_window_margins (p
);
3942 adjust_window_margins (o
);
3946 p
->left_col
= o
->left_col
;
3947 p
->total_cols
= o
->total_cols
;
3948 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3949 XSETFASTINT (o
->total_lines
, size_int
);
3950 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3953 /* Adjust glyph matrices. */
3956 Fset_window_buffer (new, o
->buffer
, Qt
);
3960 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3961 doc
: /* Make current window ARG lines bigger.
3962 From program, optional second arg non-nil means grow sideways ARG columns.
3963 Interactively, if an argument is not given, make the window one line bigger.
3964 If HORIZONTAL is non-nil, enlarge horizontally instead of vertically.
3965 This function can delete windows, even the second window, if they get
3968 Lisp_Object arg
, horizontal
;
3971 enlarge_window (selected_window
, XINT (arg
), !NILP (horizontal
));
3973 if (! NILP (Vwindow_configuration_change_hook
))
3974 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3979 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3980 doc
: /* Make current window ARG lines smaller.
3981 From program, optional second arg non-nil means shrink sideways arg columns.
3982 Interactively, if an argument is not given, make the window one line smaller. Only
3983 siblings to the right or below are changed. */)
3985 Lisp_Object arg
, side
;
3988 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3990 if (! NILP (Vwindow_configuration_change_hook
))
3991 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3997 window_height (window
)
4000 register struct window
*p
= XWINDOW (window
);
4001 return WINDOW_TOTAL_LINES (p
);
4005 window_width (window
)
4008 register struct window
*p
= XWINDOW (window
);
4009 return WINDOW_TOTAL_COLS (p
);
4014 *(horiz_flag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
4016 #define CURSIZE(w) \
4017 *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
4020 /* Enlarge WINDOW by DELTA.
4021 HORIZ_FLAG nonzero means enlarge it horizontally;
4022 zero means do it vertically.
4024 Siblings of the selected window are resized to fulfill the size
4025 request. If they become too small in the process, they will be
4029 enlarge_window (window
, delta
, horiz_flag
)
4031 int delta
, horiz_flag
;
4033 Lisp_Object parent
, next
, prev
;
4037 int (*sizefun
) P_ ((Lisp_Object
))
4038 = horiz_flag
? window_width
: window_height
;
4039 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
4040 = (horiz_flag
? set_window_width
: set_window_height
);
4042 /* Check values of window_min_width and window_min_height for
4044 check_min_window_sizes ();
4046 /* Give up if this window cannot be resized. */
4047 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4048 error ("Window is not resizable");
4050 /* Find the parent of the selected window. */
4053 p
= XWINDOW (window
);
4059 error ("No other window to side of this one");
4064 ? !NILP (XWINDOW (parent
)->hchild
)
4065 : !NILP (XWINDOW (parent
)->vchild
))
4071 sizep
= &CURSIZE (window
);
4074 register int maxdelta
;
4076 /* Compute the maximum size increment this window can have. */
4078 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4079 /* This is a main window followed by a minibuffer. */
4080 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4081 - window_min_size (XWINDOW (p
->next
),
4083 /* This is a minibuffer following a main window. */
4084 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4085 - window_min_size (XWINDOW (p
->prev
),
4087 /* This is a frame with only one window, a minibuffer-only
4088 or a minibufferless frame. */
4091 if (delta
> maxdelta
)
4092 /* This case traps trying to make the minibuffer
4093 the full frame, or make the only window aside from the
4094 minibuffer the full frame. */
4098 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), horiz_flag
, 0, 0))
4100 delete_window (window
);
4107 /* Find the total we can get from other siblings without deleting them. */
4109 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4110 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4112 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4113 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4116 /* If we can get it all from them without deleting them, do so. */
4117 if (delta
<= maximum
)
4119 Lisp_Object first_unaffected
;
4120 Lisp_Object first_affected
;
4125 first_affected
= window
;
4126 /* Look at one sibling at a time,
4127 moving away from this window in both directions alternately,
4128 and take as much as we can get without deleting that sibling. */
4130 && (!NILP (next
) || !NILP (prev
)))
4134 int this_one
= ((*sizefun
) (next
)
4135 - window_min_size (XWINDOW (next
),
4136 horiz_flag
, 0, &fixed_p
));
4139 if (this_one
> delta
)
4142 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4143 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4148 next
= XWINDOW (next
)->next
;
4156 int this_one
= ((*sizefun
) (prev
)
4157 - window_min_size (XWINDOW (prev
),
4158 horiz_flag
, 0, &fixed_p
));
4161 if (this_one
> delta
)
4164 first_affected
= prev
;
4166 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4167 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4172 prev
= XWINDOW (prev
)->prev
;
4176 xassert (delta
== 0);
4178 /* Now recalculate the edge positions of all the windows affected,
4179 based on the new sizes. */
4180 first_unaffected
= next
;
4181 prev
= first_affected
;
4182 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4183 prev
= next
, next
= XWINDOW (next
)->next
)
4185 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4186 /* This does not change size of NEXT,
4187 but it propagates the new top edge to its children */
4188 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4193 register int delta1
;
4194 register int opht
= (*sizefun
) (parent
);
4196 if (opht
<= XINT (*sizep
) + delta
)
4198 /* If trying to grow this window to or beyond size of the parent,
4199 just delete all the sibling windows. */
4200 Lisp_Object start
, tem
, next
;
4202 start
= XWINDOW (parent
)->vchild
;
4204 start
= XWINDOW (parent
)->hchild
;
4206 /* Delete any siblings that come after WINDOW. */
4207 tem
= XWINDOW (window
)->next
;
4208 while (! NILP (tem
))
4210 next
= XWINDOW (tem
)->next
;
4211 delete_window (tem
);
4215 /* Delete any siblings that come after WINDOW.
4216 Note that if START is not WINDOW, then WINDOW still
4217 Fhas siblings, so WINDOW has not yet replaced its parent. */
4219 while (! EQ (tem
, window
))
4221 next
= XWINDOW (tem
)->next
;
4222 delete_window (tem
);
4228 /* Otherwise, make delta1 just right so that if we add
4229 delta1 lines to this window and to the parent, and then
4230 shrink the parent back to its original size, the new
4231 proportional size of this window will increase by delta.
4233 The function size_window will compute the new height h'
4234 of the window from delta1 as:
4237 x = delta1 - delta1/n * n for the 1st resizable child
4240 where n is the number of children that can be resized.
4241 We can ignore x by choosing a delta1 that is a multiple of
4242 n. We want the height of this window to come out as
4252 The number of children n equals the number of resizable
4253 children of this window + 1 because we know window itself
4254 is resizable (otherwise we would have signalled an error). */
4256 struct window
*w
= XWINDOW (window
);
4260 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4261 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4263 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4264 if (!window_fixed_size_p (XWINDOW (s
), horiz_flag
, 0))
4269 /* Add delta1 lines or columns to this window, and to the parent,
4270 keeping things consistent while not affecting siblings. */
4271 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4272 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4274 /* Squeeze out delta1 lines or columns from our parent,
4275 shriking this window and siblings proportionately.
4276 This brings parent back to correct size.
4277 Delta1 was calculated so this makes this window the desired size,
4278 taking it all out of the siblings. */
4279 (*setsizefun
) (parent
, opht
, 0);
4284 XSETFASTINT (p
->last_modified
, 0);
4285 XSETFASTINT (p
->last_overlay_modified
, 0);
4287 /* Adjust glyph matrices. */
4288 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4292 /* Adjust the size of WINDOW by DELTA, moving only its trailing edge.
4293 HORIZ_FLAG nonzero means adjust the width, moving the right edge.
4294 zero means adjust the height, moving the bottom edge.
4296 Following siblings of the selected window are resized to fulfill
4297 the size request. If they become too small in the process, they
4298 are not deleted; instead, we signal an error. */
4301 adjust_window_trailing_edge (window
, delta
, horiz_flag
)
4303 int delta
, horiz_flag
;
4305 Lisp_Object parent
, child
;
4307 Lisp_Object old_config
= Fcurrent_window_configuration (Qnil
);
4308 int delcount
= window_deletion_count
;
4310 /* Check values of window_min_width and window_min_height for
4312 check_min_window_sizes ();
4315 window
= Fselected_window ();
4317 CHECK_WINDOW (window
);
4319 /* Give up if this window cannot be resized. */
4320 if (window_fixed_size_p (XWINDOW (window
), horiz_flag
, 1))
4321 error ("Window is not resizable");
4325 Lisp_Object first_parallel
= Qnil
;
4329 /* This happens if WINDOW on the previous iteration was
4330 at top level of the window tree. */
4331 Fset_window_configuration (old_config
);
4332 error ("Specified window edge is fixed");
4335 p
= XWINDOW (window
);
4338 /* See if this level has windows in parallel in the specified
4339 direction. If so, set FIRST_PARALLEL to the first one. */
4342 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->vchild
))
4343 first_parallel
= XWINDOW (parent
)->vchild
;
4344 else if (NILP (parent
) && !NILP (p
->next
))
4346 /* Handle the vertical chain of main window and minibuffer
4347 which has no parent. */
4348 first_parallel
= window
;
4349 while (! NILP (XWINDOW (first_parallel
)->prev
))
4350 first_parallel
= XWINDOW (first_parallel
)->prev
;
4355 if (! NILP (parent
) && !NILP (XWINDOW (parent
)->hchild
))
4356 first_parallel
= XWINDOW (parent
)->hchild
;
4359 /* If this level's succession is in the desired dimension,
4360 and this window is the last one, and there is no higher level,
4361 its trailing edge is fixed. */
4362 if (NILP (XWINDOW (window
)->next
) && NILP (first_parallel
)
4365 Fset_window_configuration (old_config
);
4366 error ("Specified window edge is fixed");
4369 /* Don't make this window too small. */
4370 if (XINT (CURSIZE (window
)) + delta
4371 < (horiz_flag
? window_min_width
: window_min_height
))
4373 Fset_window_configuration (old_config
);
4374 error ("Cannot adjust window size as specified");
4377 /* Clear out some redisplay caches. */
4378 XSETFASTINT (p
->last_modified
, 0);
4379 XSETFASTINT (p
->last_overlay_modified
, 0);
4381 /* Adjust this window's edge. */
4382 XSETINT (CURSIZE (window
),
4383 XINT (CURSIZE (window
)) + delta
);
4385 /* If this window has following siblings in the desired dimension,
4386 make them smaller, and exit the loop.
4388 (If we reach the top of the tree and can never do this,
4389 we will fail and report an error, above.) */
4390 if (NILP (first_parallel
))
4392 if (!NILP (p
->next
))
4394 /* This may happen for the minibuffer. In that case
4395 the window_deletion_count check below does not work. */
4396 if (XINT (CURSIZE (p
->next
)) - delta
<= 0)
4398 Fset_window_configuration (old_config
);
4399 error ("Cannot adjust window size as specified");
4402 XSETINT (CURBEG (p
->next
),
4403 XINT (CURBEG (p
->next
)) + delta
);
4404 size_window (p
->next
, XINT (CURSIZE (p
->next
)) - delta
,
4405 horiz_flag
, 0, 1, 0);
4410 /* Here we have a chain of parallel siblings, in the other dimension.
4411 Change the size of the other siblings. */
4412 for (child
= first_parallel
;
4414 child
= XWINDOW (child
)->next
)
4415 if (! EQ (child
, window
))
4416 size_window (child
, XINT (CURSIZE (child
)) + delta
,
4417 horiz_flag
, 0, 0, 1);
4422 /* If we made a window so small it got deleted,
4423 we failed. Report failure. */
4424 if (delcount
!= window_deletion_count
)
4426 Fset_window_configuration (old_config
);
4427 error ("Cannot adjust window size as specified");
4430 /* Adjust glyph matrices. */
4431 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4437 DEFUN ("adjust-window-trailing-edge", Fadjust_window_trailing_edge
,
4438 Sadjust_window_trailing_edge
, 3, 3, 0,
4439 doc
: /* Adjust the bottom or right edge of WINDOW by DELTA.
4440 If HORIZONTAL is non-nil, that means adjust the width, moving the right edge.
4441 Otherwise, adjust the height, moving the bottom edge.
4443 Following siblings of the selected window are resized to fulfill
4444 the size request. If they become too small in the process, they
4445 are not deleted; instead, we signal an error. */)
4446 (window
, delta
, horizontal
)
4447 Lisp_Object window
, delta
, horizontal
;
4449 CHECK_NUMBER (delta
);
4450 adjust_window_trailing_edge (window
, XINT (delta
), !NILP (horizontal
));
4452 if (! NILP (Vwindow_configuration_change_hook
))
4453 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
4460 /***********************************************************************
4461 Resizing Mini-Windows
4462 ***********************************************************************/
4464 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4466 enum save_restore_action
4473 static int save_restore_orig_size
P_ ((struct window
*,
4474 enum save_restore_action
));
4476 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4477 from lowest windows first. */
4480 shrink_window_lowest_first (w
, height
)
4488 xassert (!MINI_WINDOW_P (w
));
4490 /* Set redisplay hints. */
4491 XSETFASTINT (w
->last_modified
, 0);
4492 XSETFASTINT (w
->last_overlay_modified
, 0);
4493 windows_or_buffers_changed
++;
4494 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4496 old_height
= XFASTINT (w
->total_lines
);
4497 XSETFASTINT (w
->total_lines
, height
);
4499 if (!NILP (w
->hchild
))
4501 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4503 c
= XWINDOW (child
);
4504 c
->top_line
= w
->top_line
;
4505 shrink_window_lowest_first (c
, height
);
4508 else if (!NILP (w
->vchild
))
4510 Lisp_Object last_child
;
4511 int delta
= old_height
- height
;
4516 /* Find the last child. We are taking space from lowest windows
4517 first, so we iterate over children from the last child
4519 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4522 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4523 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4527 c
= XWINDOW (child
);
4528 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4530 if (this_one
> delta
)
4533 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4537 /* Compute new positions. */
4538 last_top
= XINT (w
->top_line
);
4539 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4541 c
= XWINDOW (child
);
4542 c
->top_line
= make_number (last_top
);
4543 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4544 last_top
+= XFASTINT (c
->total_lines
);
4550 /* Save, restore, or check positions and sizes in the window tree
4551 rooted at W. ACTION says what to do.
4553 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4554 orig_total_lines members are valid for all windows in the window
4555 tree. Value is non-zero if they are valid.
4557 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4558 orig_top_line and orig_total_lines for all windows in the tree.
4560 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4561 stored in orig_top_line and orig_total_lines for all windows. */
4564 save_restore_orig_size (w
, action
)
4566 enum save_restore_action action
;
4572 if (!NILP (w
->hchild
))
4574 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4577 else if (!NILP (w
->vchild
))
4579 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4585 case CHECK_ORIG_SIZES
:
4586 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4590 case SAVE_ORIG_SIZES
:
4591 w
->orig_top_line
= w
->top_line
;
4592 w
->orig_total_lines
= w
->total_lines
;
4593 XSETFASTINT (w
->last_modified
, 0);
4594 XSETFASTINT (w
->last_overlay_modified
, 0);
4597 case RESTORE_ORIG_SIZES
:
4598 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4599 w
->top_line
= w
->orig_top_line
;
4600 w
->total_lines
= w
->orig_total_lines
;
4601 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4602 XSETFASTINT (w
->last_modified
, 0);
4603 XSETFASTINT (w
->last_overlay_modified
, 0);
4610 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4617 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4618 without deleting other windows. */
4621 grow_mini_window (w
, delta
)
4625 struct frame
*f
= XFRAME (w
->frame
);
4626 struct window
*root
;
4628 xassert (MINI_WINDOW_P (w
));
4629 xassert (delta
>= 0);
4631 /* Check values of window_min_width and window_min_height for
4633 check_min_window_sizes ();
4635 /* Compute how much we can enlarge the mini-window without deleting
4637 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4640 int min_height
= window_min_size (root
, 0, 0, 0);
4641 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4642 /* Note that the root window may already be smaller than
4644 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4649 /* Save original window sizes and positions, if not already done. */
4650 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4651 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4653 /* Shrink other windows. */
4654 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4656 /* Grow the mini-window. */
4657 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4658 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4659 XSETFASTINT (w
->last_modified
, 0);
4660 XSETFASTINT (w
->last_overlay_modified
, 0);
4667 /* Shrink mini-window W. If there is recorded info about window sizes
4668 before a call to grow_mini_window, restore recorded window sizes.
4669 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4673 shrink_mini_window (w
)
4676 struct frame
*f
= XFRAME (w
->frame
);
4677 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4679 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4681 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4683 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4684 windows_or_buffers_changed
= 1;
4686 else if (XFASTINT (w
->total_lines
) > 1)
4688 /* Distribute the additional lines of the mini-window
4689 among the other windows. */
4691 XSETWINDOW (window
, w
);
4692 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0);
4698 /* Mark window cursors off for all windows in the window tree rooted
4699 at W by setting their phys_cursor_on_p flag to zero. Called from
4700 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4701 the frame are cleared. */
4704 mark_window_cursors_off (w
)
4709 if (!NILP (w
->hchild
))
4710 mark_window_cursors_off (XWINDOW (w
->hchild
));
4711 else if (!NILP (w
->vchild
))
4712 mark_window_cursors_off (XWINDOW (w
->vchild
));
4714 w
->phys_cursor_on_p
= 0;
4716 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4721 /* Return number of lines of text (not counting mode lines) in W. */
4724 window_internal_height (w
)
4727 int ht
= XFASTINT (w
->total_lines
);
4729 if (!MINI_WINDOW_P (w
))
4731 if (!NILP (w
->parent
)
4732 || !NILP (w
->vchild
)
4733 || !NILP (w
->hchild
)
4736 || WINDOW_WANTS_MODELINE_P (w
))
4739 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4747 /* Return the number of columns in W.
4748 Don't count columns occupied by scroll bars or the vertical bar
4749 separating W from the sibling to its right. */
4752 window_box_text_cols (w
)
4755 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4756 int width
= XINT (w
->total_cols
);
4758 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4759 /* Scroll bars occupy a few columns. */
4760 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4761 else if (!FRAME_WINDOW_P (f
)
4762 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4763 /* The column of `|' characters separating side-by-side windows
4764 occupies one column only. */
4767 if (FRAME_WINDOW_P (f
))
4768 /* On window-systems, fringes and display margins cannot be
4769 used for normal text. */
4770 width
-= (WINDOW_FRINGE_COLS (w
)
4771 + WINDOW_LEFT_MARGIN_COLS (w
)
4772 + WINDOW_RIGHT_MARGIN_COLS (w
));
4778 /************************************************************************
4780 ***********************************************************************/
4782 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4783 N screen-fulls, which is defined as the height of the window minus
4784 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4785 instead. Negative values of N mean scroll down. NOERROR non-zero
4786 means don't signal an error if we try to move over BEGV or ZV,
4790 window_scroll (window
, n
, whole
, noerror
)
4798 /* If we must, use the pixel-based version which is much slower than
4799 the line-based one but can handle varying line heights. */
4800 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4801 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4803 window_scroll_line_based (window
, n
, whole
, noerror
);
4809 /* Implementation of window_scroll that works based on pixel line
4810 heights. See the comment of window_scroll for parameter
4814 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4821 struct window
*w
= XWINDOW (window
);
4822 struct text_pos start
;
4824 int this_scroll_margin
;
4825 /* True if we fiddled the window vscroll field without really scrolling. */
4828 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4830 /* If PT is not visible in WINDOW, move back one half of
4831 the screen. Allow PT to be partially visible, otherwise
4832 something like (scroll-down 1) with PT in the line before
4833 the partially visible one would recenter. */
4834 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4837 /* Move backward half the height of the window. Performance note:
4838 vmotion used here is about 10% faster, but would give wrong
4839 results for variable height lines. */
4840 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4841 it
.current_y
= it
.last_visible_y
;
4842 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4844 /* The function move_iterator_vertically may move over more than
4845 the specified y-distance. If it->w is small, e.g. a
4846 mini-buffer window, we may end up in front of the window's
4847 display area. This is the case when Start displaying at the
4848 start of the line containing PT in this case. */
4849 if (it
.current_y
<= 0)
4851 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4852 move_it_vertically_backward (&it
, 0);
4856 start
= it
.current
.pos
;
4858 else if (auto_window_vscroll_p
)
4860 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4863 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4865 dy
= max ((window_box_height (w
)
4866 - next_screen_context_lines
* dy
),
4870 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4872 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4873 Fset_window_vscroll (window
, make_number (px
), Qt
);
4876 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4878 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4879 Fset_window_vscroll (window
, make_number (px
), Qt
);
4883 Fset_window_vscroll (window
, make_number (0), Qt
);
4886 /* If scroll_preserve_screen_position is non-nil, we try to set
4887 point in the same window line as it is now, so get that line. */
4888 if (!NILP (Vscroll_preserve_screen_position
))
4890 /* We preserve the goal pixel coordinate across consecutive
4891 calls to scroll-up or scroll-down. This avoids the
4892 possibility of point becoming "stuck" on a tall line when
4893 scrolling by one line. */
4894 if (window_scroll_pixel_based_preserve_y
< 0
4895 || (!EQ (current_kboard
->Vlast_command
, Qscroll_up
)
4896 && !EQ (current_kboard
->Vlast_command
, Qscroll_down
)))
4898 start_display (&it
, w
, start
);
4899 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4900 window_scroll_pixel_based_preserve_y
= it
.current_y
;
4904 window_scroll_pixel_based_preserve_y
= -1;
4906 /* Move iterator it from start the specified distance forward or
4907 backward. The result is the new window start. */
4908 start_display (&it
, w
, start
);
4911 int start_pos
= IT_CHARPOS (it
);
4912 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4913 dy
= max ((window_box_height (w
)
4914 - next_screen_context_lines
* dy
),
4917 /* Note that move_it_vertically always moves the iterator to the
4918 start of a line. So, if the last line doesn't have a newline,
4919 we would end up at the start of the line ending at ZV. */
4922 move_it_vertically_backward (&it
, -dy
);
4923 /* Ensure we actually does move, e.g. in case we are currently
4924 looking at an image that is taller that the window height. */
4925 while (start_pos
== IT_CHARPOS (it
)
4926 && start_pos
> BEGV
)
4927 move_it_by_lines (&it
, -1, 1);
4931 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4932 MOVE_TO_POS
| MOVE_TO_Y
);
4933 /* Ensure we actually does move, e.g. in case we are currently
4934 looking at an image that is taller that the window height. */
4935 while (start_pos
== IT_CHARPOS (it
)
4937 move_it_by_lines (&it
, 1, 1);
4941 move_it_by_lines (&it
, n
, 1);
4943 /* We failed if we find ZV is already on the screen (scrolling up,
4944 means there's nothing past the end), or if we can't start any
4945 earlier (scrolling down, means there's nothing past the top). */
4946 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4947 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4949 if (IT_CHARPOS (it
) == ZV
)
4951 if (it
.current_y
< it
.last_visible_y
4952 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4953 > it
.last_visible_y
))
4955 /* The last line was only partially visible, make it fully
4957 w
->vscroll
= (it
.last_visible_y
4958 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4959 adjust_glyphs (it
.f
);
4963 else if (n
< 0) /* could happen with empty buffers */
4964 Fsignal (Qbeginning_of_buffer
, Qnil
);
4966 Fsignal (Qend_of_buffer
, Qnil
);
4970 if (w
->vscroll
!= 0)
4971 /* The first line was only partially visible, make it fully
4977 Fsignal (Qbeginning_of_buffer
, Qnil
);
4980 /* If control gets here, then we vscrolled. */
4982 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4984 /* Don't try to change the window start below. */
4990 int pos
= IT_CHARPOS (it
);
4993 /* If in the middle of a multi-glyph character move forward to
4994 the next character. */
4995 if (in_display_vector_p (&it
))
4998 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
5001 /* Set the window start, and set up the window for redisplay. */
5002 set_marker_restricted (w
->start
, make_number (pos
),
5004 bytepos
= XMARKER (w
->start
)->bytepos
;
5005 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
5007 w
->update_mode_line
= Qt
;
5008 XSETFASTINT (w
->last_modified
, 0);
5009 XSETFASTINT (w
->last_overlay_modified
, 0);
5010 /* Set force_start so that redisplay_window will run the
5011 window-scroll-functions. */
5012 w
->force_start
= Qt
;
5015 /* The rest of this function uses current_y in a nonstandard way,
5016 not including the height of the header line if any. */
5017 it
.current_y
= it
.vpos
= 0;
5019 /* Move PT out of scroll margins.
5020 This code wants current_y to be zero at the window start position
5021 even if there is a header line. */
5022 this_scroll_margin
= max (0, scroll_margin
);
5023 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
5024 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
5028 /* We moved the window start towards ZV, so PT may be now
5029 in the scroll margin at the top. */
5030 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
5031 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
5032 && (NILP (Vscroll_preserve_screen_position
)
5033 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5034 /* We found PT at a legitimate height. Leave it alone. */
5036 else if (window_scroll_pixel_based_preserve_y
>= 0)
5038 /* If we have a header line, take account of it.
5039 This is necessary because we set it.current_y to 0, above. */
5040 move_it_to (&it
, -1, -1,
5041 window_scroll_pixel_based_preserve_y
5042 - (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0 ),
5044 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5048 while (it
.current_y
< this_scroll_margin
)
5050 int prev
= it
.current_y
;
5051 move_it_by_lines (&it
, 1, 1);
5052 if (prev
== it
.current_y
)
5055 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5060 int charpos
, bytepos
;
5063 /* Save our position, for the
5064 window_scroll_pixel_based_preserve_y case. */
5065 charpos
= IT_CHARPOS (it
);
5066 bytepos
= IT_BYTEPOS (it
);
5068 /* We moved the window start towards BEGV, so PT may be now
5069 in the scroll margin at the bottom. */
5070 move_it_to (&it
, PT
, -1,
5071 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
5072 - this_scroll_margin
- 1),
5074 MOVE_TO_POS
| MOVE_TO_Y
);
5076 /* Save our position, in case it's correct. */
5077 charpos
= IT_CHARPOS (it
);
5078 bytepos
= IT_BYTEPOS (it
);
5080 /* See if point is on a partially visible line at the end. */
5081 if (it
.what
== IT_EOB
)
5082 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
5085 move_it_by_lines (&it
, 1, 1);
5086 partial_p
= it
.current_y
> it
.last_visible_y
;
5089 if (charpos
== PT
&& !partial_p
5090 && (NILP (Vscroll_preserve_screen_position
)
5091 || EQ (Vscroll_preserve_screen_position
, Qt
)))
5092 /* We found PT before we found the display margin, so PT is ok. */
5094 else if (window_scroll_pixel_based_preserve_y
>= 0)
5096 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5097 start_display (&it
, w
, start
);
5098 /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
5099 here because we called start_display again and did not
5100 alter it.current_y this time. */
5101 move_it_to (&it
, -1, -1, window_scroll_pixel_based_preserve_y
, -1,
5103 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5108 /* The last line was only partially visible, so back up two
5109 lines to make sure we're on a fully visible line. */
5111 move_it_by_lines (&it
, -2, 0);
5112 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
5115 /* No, the position we saved is OK, so use it. */
5116 SET_PT_BOTH (charpos
, bytepos
);
5122 /* Implementation of window_scroll that works based on screen lines.
5123 See the comment of window_scroll for parameter descriptions. */
5126 window_scroll_line_based (window
, n
, whole
, noerror
)
5132 register struct window
*w
= XWINDOW (window
);
5133 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
5134 register int pos
, pos_byte
;
5135 register int ht
= window_internal_height (w
);
5136 register Lisp_Object tem
;
5140 struct position posit
;
5143 /* If scrolling screen-fulls, compute the number of lines to
5144 scroll from the window's height. */
5146 n
*= max (1, ht
- next_screen_context_lines
);
5148 startpos
= marker_position (w
->start
);
5150 posit
= *compute_motion (startpos
, 0, 0, 0,
5152 -1, XINT (w
->hscroll
),
5154 original_vpos
= posit
.vpos
;
5156 XSETFASTINT (tem
, PT
);
5157 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
5161 Fvertical_motion (make_number (- (ht
/ 2)), window
);
5166 lose
= n
< 0 && PT
== BEGV
;
5167 Fvertical_motion (make_number (n
), window
);
5171 SET_PT_BOTH (opoint
, opoint_byte
);
5178 Fsignal (Qbeginning_of_buffer
, Qnil
);
5183 int this_scroll_margin
= scroll_margin
;
5185 /* Don't use a scroll margin that is negative or too large. */
5186 if (this_scroll_margin
< 0)
5187 this_scroll_margin
= 0;
5189 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
5190 this_scroll_margin
= XINT (w
->total_lines
) / 4;
5192 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
5193 w
->start_at_line_beg
= bolp
;
5194 w
->update_mode_line
= Qt
;
5195 XSETFASTINT (w
->last_modified
, 0);
5196 XSETFASTINT (w
->last_overlay_modified
, 0);
5197 /* Set force_start so that redisplay_window will run
5198 the window-scroll-functions. */
5199 w
->force_start
= Qt
;
5201 if (!NILP (Vscroll_preserve_screen_position
)
5202 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
5204 SET_PT_BOTH (pos
, pos_byte
);
5205 Fvertical_motion (make_number (original_vpos
), window
);
5207 /* If we scrolled forward, put point enough lines down
5208 that it is outside the scroll margin. */
5213 if (this_scroll_margin
> 0)
5215 SET_PT_BOTH (pos
, pos_byte
);
5216 Fvertical_motion (make_number (this_scroll_margin
), window
);
5222 if (top_margin
<= opoint
)
5223 SET_PT_BOTH (opoint
, opoint_byte
);
5224 else if (!NILP (Vscroll_preserve_screen_position
))
5226 SET_PT_BOTH (pos
, pos_byte
);
5227 Fvertical_motion (make_number (original_vpos
), window
);
5230 SET_PT (top_margin
);
5236 /* If we scrolled backward, put point near the end of the window
5237 but not within the scroll margin. */
5238 SET_PT_BOTH (pos
, pos_byte
);
5239 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5240 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5243 bottom_margin
= PT
+ 1;
5245 if (bottom_margin
> opoint
)
5246 SET_PT_BOTH (opoint
, opoint_byte
);
5249 if (!NILP (Vscroll_preserve_screen_position
))
5251 SET_PT_BOTH (pos
, pos_byte
);
5252 Fvertical_motion (make_number (original_vpos
), window
);
5255 Fvertical_motion (make_number (-1), window
);
5264 Fsignal (Qend_of_buffer
, Qnil
);
5269 /* Scroll selected_window up or down. If N is nil, scroll a
5270 screen-full which is defined as the height of the window minus
5271 next_screen_context_lines. If N is the symbol `-', scroll.
5272 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5273 up. This is the guts of Fscroll_up and Fscroll_down. */
5276 scroll_command (n
, direction
)
5280 int count
= SPECPDL_INDEX ();
5282 xassert (abs (direction
) == 1);
5284 /* If selected window's buffer isn't current, make it current for
5285 the moment. But don't screw up if window_scroll gets an error. */
5286 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5288 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5289 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5291 /* Make redisplay consider other windows than just selected_window. */
5292 ++windows_or_buffers_changed
;
5296 window_scroll (selected_window
, direction
, 1, 0);
5297 else if (EQ (n
, Qminus
))
5298 window_scroll (selected_window
, -direction
, 1, 0);
5301 n
= Fprefix_numeric_value (n
);
5302 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5305 unbind_to (count
, Qnil
);
5308 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5309 doc
: /* Scroll text of current window upward ARG lines.
5310 If ARG is omitted or nil, scroll upward by a near full screen.
5311 A near full screen is `next-screen-context-lines' less than a full screen.
5312 Negative ARG means scroll downward.
5313 If ARG is the atom `-', scroll downward by nearly full screen.
5314 When calling from a program, supply as argument a number, nil, or `-'. */)
5318 scroll_command (arg
, 1);
5322 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5323 doc
: /* Scroll text of current window down ARG lines.
5324 If ARG is omitted or nil, scroll down by a near full screen.
5325 A near full screen is `next-screen-context-lines' less than a full screen.
5326 Negative ARG means scroll upward.
5327 If ARG is the atom `-', scroll upward by nearly full screen.
5328 When calling from a program, supply as argument a number, nil, or `-'. */)
5332 scroll_command (arg
, -1);
5336 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5337 doc
: /* Return the other window for \"other window scroll\" commands.
5338 If `other-window-scroll-buffer' is non-nil, a window
5339 showing that buffer is used.
5340 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5341 specifies the window. This takes precedence over
5342 `other-window-scroll-buffer'. */)
5347 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5348 && !NILP (Vminibuf_scroll_window
))
5349 window
= Vminibuf_scroll_window
;
5350 /* If buffer is specified, scroll that buffer. */
5351 else if (!NILP (Vother_window_scroll_buffer
))
5353 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5355 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5359 /* Nothing specified; look for a neighboring window on the same
5361 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5363 if (EQ (window
, selected_window
))
5364 /* That didn't get us anywhere; look for a window on another
5367 window
= Fnext_window (window
, Qnil
, Qt
);
5368 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5369 && ! EQ (window
, selected_window
));
5372 CHECK_LIVE_WINDOW (window
);
5374 if (EQ (window
, selected_window
))
5375 error ("There is no other window");
5380 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5381 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5382 A near full screen is `next-screen-context-lines' less than a full screen.
5383 The next window is the one below the current one; or the one at the top
5384 if the current one is at the bottom. Negative ARG means scroll downward.
5385 If ARG is the atom `-', scroll downward by nearly full screen.
5386 When calling from a program, supply as argument a number, nil, or `-'.
5388 If `other-window-scroll-buffer' is non-nil, scroll the window
5389 showing that buffer, popping the buffer up if necessary.
5390 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5391 specifies the window to scroll. This takes precedence over
5392 `other-window-scroll-buffer'. */)
5398 int count
= SPECPDL_INDEX ();
5400 window
= Fother_window_for_scrolling ();
5401 w
= XWINDOW (window
);
5403 /* Don't screw up if window_scroll gets an error. */
5404 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5405 ++windows_or_buffers_changed
;
5407 Fset_buffer (w
->buffer
);
5408 SET_PT (marker_position (w
->pointm
));
5411 window_scroll (window
, 1, 1, 1);
5412 else if (EQ (arg
, Qminus
))
5413 window_scroll (window
, -1, 1, 1);
5419 window_scroll (window
, XINT (arg
), 0, 1);
5422 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5423 unbind_to (count
, Qnil
);
5428 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5429 doc
: /* Scroll selected window display ARG columns left.
5430 Default for ARG is window width minus 2.
5431 Value is the total amount of leftward horizontal scrolling in
5432 effect after the change.
5433 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5434 lower bound for automatic scrolling, i.e. automatic scrolling
5435 will not scroll a window to a column less than the value returned
5436 by this function. This happens in an interactive call. */)
5438 register Lisp_Object arg
, set_minimum
;
5442 struct window
*w
= XWINDOW (selected_window
);
5445 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5447 arg
= Fprefix_numeric_value (arg
);
5449 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5450 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5452 if (!NILP (set_minimum
))
5453 w
->min_hscroll
= w
->hscroll
;
5458 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5459 doc
: /* Scroll selected window display ARG columns right.
5460 Default for ARG is window width minus 2.
5461 Value is the total amount of leftward horizontal scrolling in
5462 effect after the change.
5463 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5464 lower bound for automatic scrolling, i.e. automatic scrolling
5465 will not scroll a window to a column less than the value returned
5466 by this function. This happens in an interactive call. */)
5468 register Lisp_Object arg
, set_minimum
;
5472 struct window
*w
= XWINDOW (selected_window
);
5475 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5477 arg
= Fprefix_numeric_value (arg
);
5479 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5480 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5482 if (!NILP (set_minimum
))
5483 w
->min_hscroll
= w
->hscroll
;
5488 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5489 doc
: /* Return the window which was selected when entering the minibuffer.
5490 Returns nil, if current window is not a minibuffer window. */)
5493 if (minibuf_level
> 0
5494 && MINI_WINDOW_P (XWINDOW (selected_window
))
5495 && WINDOW_LIVE_P (minibuf_selected_window
))
5496 return minibuf_selected_window
;
5501 /* Value is the number of lines actually displayed in window W,
5502 as opposed to its height. */
5505 displayed_window_lines (w
)
5509 struct text_pos start
;
5510 int height
= window_box_height (w
);
5511 struct buffer
*old_buffer
;
5514 if (XBUFFER (w
->buffer
) != current_buffer
)
5516 old_buffer
= current_buffer
;
5517 set_buffer_internal (XBUFFER (w
->buffer
));
5522 /* In case W->start is out of the accessible range, do something
5523 reasonable. This happens in Info mode when Info-scroll-down
5524 calls (recenter -1) while W->start is 1. */
5525 if (XMARKER (w
->start
)->charpos
< BEGV
)
5526 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5527 else if (XMARKER (w
->start
)->charpos
> ZV
)
5528 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5530 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5532 start_display (&it
, w
, start
);
5533 move_it_vertically (&it
, height
);
5534 bottom_y
= line_bottom_y (&it
);
5536 /* rms: On a non-window display,
5537 the value of it.vpos at the bottom of the screen
5538 seems to be 1 larger than window_box_height (w).
5539 This kludge fixes a bug whereby (move-to-window-line -1)
5540 when ZV is on the last screen line
5541 moves to the previous screen line instead of the last one. */
5542 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5545 /* Add in empty lines at the bottom of the window. */
5546 if (bottom_y
< height
)
5548 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5549 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5553 set_buffer_internal (old_buffer
);
5559 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5560 doc
: /* Center point in window and redisplay frame.
5561 With prefix argument ARG, recenter putting point on screen line ARG
5562 relative to the current window. If ARG is negative, it counts up from the
5563 bottom of the window. (ARG should be less than the height of the window.)
5565 If ARG is omitted or nil, erase the entire frame and then
5566 redraw with point in the center of the current window.
5567 Just C-u as prefix means put point in the center of the window
5568 and redisplay normally--don't erase and redraw the frame. */)
5570 register Lisp_Object arg
;
5572 struct window
*w
= XWINDOW (selected_window
);
5573 struct buffer
*buf
= XBUFFER (w
->buffer
);
5574 struct buffer
*obuf
= current_buffer
;
5576 int charpos
, bytepos
;
5578 int this_scroll_margin
;
5580 /* If redisplay is suppressed due to an error, try again. */
5581 obuf
->display_error_modiff
= 0;
5587 /* Invalidate pixel data calculated for all compositions. */
5588 for (i
= 0; i
< n_compositions
; i
++)
5589 composition_table
[i
]->font
= NULL
;
5591 Fredraw_frame (w
->frame
);
5592 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5595 else if (CONSP (arg
)) /* Just C-u. */
5599 arg
= Fprefix_numeric_value (arg
);
5604 set_buffer_internal (buf
);
5606 /* Do this after making BUF current
5607 in case scroll_margin is buffer-local. */
5608 this_scroll_margin
= max (0, scroll_margin
);
5609 this_scroll_margin
= min (this_scroll_margin
,
5610 XFASTINT (w
->total_lines
) / 4);
5612 /* Handle centering on a graphical frame specially. Such frames can
5613 have variable-height lines and centering point on the basis of
5614 line counts would lead to strange effects. */
5615 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5622 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5623 start_display (&it
, w
, pt
);
5624 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5625 charpos
= IT_CHARPOS (it
);
5626 bytepos
= IT_BYTEPOS (it
);
5633 int extra_line_spacing
;
5634 int h
= window_box_height (w
);
5636 iarg
= - max (-iarg
, this_scroll_margin
);
5638 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5639 start_display (&it
, w
, pt
);
5641 /* Be sure we have the exact height of the full line containing PT. */
5642 move_it_by_lines (&it
, 0, 1);
5644 /* The amount of pixels we have to move back is the window
5645 height minus what's displayed in the line containing PT,
5646 and the lines below. */
5649 move_it_by_lines (&it
, nlines
, 1);
5651 if (it
.vpos
== nlines
)
5655 /* Last line has no newline */
5656 h
-= line_bottom_y (&it
);
5660 /* Don't reserve space for extra line spacing of last line. */
5661 extra_line_spacing
= it
.max_extra_line_spacing
;
5663 /* If we can't move down NLINES lines because we hit
5664 the end of the buffer, count in some empty lines. */
5665 if (it
.vpos
< nlines
)
5668 extra_line_spacing
= it
.extra_line_spacing
;
5669 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5674 /* Now find the new top line (starting position) of the window. */
5675 start_display (&it
, w
, pt
);
5677 move_it_vertically_backward (&it
, h
);
5679 /* If extra line spacing is present, we may move too far
5680 back. This causes the last line to be only partially
5681 visible (which triggers redisplay to recenter that line
5682 in the middle), so move forward.
5683 But ignore extra line spacing on last line, as it is not
5684 considered to be part of the visible height of the line.
5686 h
+= extra_line_spacing
;
5687 while (-it
.current_y
> h
)
5688 move_it_by_lines (&it
, 1, 1);
5690 charpos
= IT_CHARPOS (it
);
5691 bytepos
= IT_BYTEPOS (it
);
5695 struct position pos
;
5697 iarg
= max (iarg
, this_scroll_margin
);
5699 pos
= *vmotion (PT
, -iarg
, w
);
5700 charpos
= pos
.bufpos
;
5701 bytepos
= pos
.bytepos
;
5706 struct position pos
;
5707 int ht
= window_internal_height (w
);
5714 /* Don't let it get into the margin at either top or bottom. */
5715 iarg
= max (iarg
, this_scroll_margin
);
5716 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5718 pos
= *vmotion (PT
, - iarg
, w
);
5719 charpos
= pos
.bufpos
;
5720 bytepos
= pos
.bytepos
;
5723 /* Set the new window start. */
5724 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5725 w
->window_end_valid
= Qnil
;
5727 w
->optional_new_start
= Qt
;
5729 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5730 w
->start_at_line_beg
= Qt
;
5732 w
->start_at_line_beg
= Qnil
;
5734 set_buffer_internal (obuf
);
5739 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5741 doc
: /* Return the height in lines of the text display area of WINDOW.
5742 This doesn't include the mode-line (or header-line if any) or any
5743 partial-height lines in the text display area. */)
5747 struct window
*w
= decode_window (window
);
5748 int pixel_height
= window_box_height (w
);
5749 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5750 return make_number (line_height
);
5755 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5757 doc
: /* Position point relative to window.
5758 With no argument, position point at center of window.
5759 An argument specifies vertical position within the window;
5760 zero means top of window, negative means relative to bottom of window. */)
5764 struct window
*w
= XWINDOW (selected_window
);
5768 int this_scroll_margin
;
5771 window
= selected_window
;
5772 start
= marker_position (w
->start
);
5773 if (start
< BEGV
|| start
> ZV
)
5775 int height
= window_internal_height (w
);
5776 Fvertical_motion (make_number (- (height
/ 2)), window
);
5777 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5778 w
->start_at_line_beg
= Fbolp ();
5779 w
->force_start
= Qt
;
5782 Fgoto_char (w
->start
);
5784 lines
= displayed_window_lines (w
);
5787 this_scroll_margin
= max (0, scroll_margin
);
5788 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5792 XSETFASTINT (arg
, lines
/ 2);
5795 int iarg
= XINT (Fprefix_numeric_value (arg
));
5798 iarg
= iarg
+ lines
;
5800 #if 0 /* This code would prevent move-to-window-line from moving point
5801 to a place inside the scroll margins (which would cause the
5802 next redisplay to scroll). I wrote this code, but then concluded
5803 it is probably better not to install it. However, it is here
5804 inside #if 0 so as not to lose it. -- rms. */
5806 /* Don't let it get into the margin at either top or bottom. */
5807 iarg
= max (iarg
, this_scroll_margin
);
5808 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5811 arg
= make_number (iarg
);
5814 /* Skip past a partially visible first line. */
5816 XSETINT (arg
, XINT (arg
) + 1);
5818 return Fvertical_motion (arg
, window
);
5823 /***********************************************************************
5824 Window Configuration
5825 ***********************************************************************/
5827 struct save_window_data
5829 EMACS_INT size_from_Lisp_Vector_struct
;
5830 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5831 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5832 Lisp_Object frame_tool_bar_lines
;
5833 Lisp_Object selected_frame
;
5834 Lisp_Object current_window
;
5835 Lisp_Object current_buffer
;
5836 Lisp_Object minibuf_scroll_window
;
5837 Lisp_Object minibuf_selected_window
;
5838 Lisp_Object root_window
;
5839 Lisp_Object focus_frame
;
5840 /* Record the values of window-min-width and window-min-height
5841 so that window sizes remain consistent with them. */
5842 Lisp_Object min_width
, min_height
;
5843 /* A vector, each of whose elements is a struct saved_window
5845 Lisp_Object saved_windows
;
5848 /* This is saved as a Lisp_Vector */
5851 /* these first two must agree with struct Lisp_Vector in lisp.h */
5852 EMACS_INT size_from_Lisp_Vector_struct
;
5853 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5856 Lisp_Object buffer
, start
, pointm
, mark
;
5857 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5858 Lisp_Object hscroll
, min_hscroll
;
5859 Lisp_Object parent
, prev
;
5860 Lisp_Object start_at_line_beg
;
5861 Lisp_Object display_table
;
5862 Lisp_Object orig_top_line
, orig_total_lines
;
5863 Lisp_Object left_margin_cols
, right_margin_cols
;
5864 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5865 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5866 Lisp_Object dedicated
;
5869 #define SAVED_WINDOW_N(swv,n) \
5870 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5872 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5873 doc
: /* Return t if OBJECT is a window-configuration object. */)
5877 return WINDOW_CONFIGURATIONP (object
) ? Qt
: Qnil
;
5880 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5881 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5885 register struct save_window_data
*data
;
5886 struct Lisp_Vector
*saved_windows
;
5888 if (! WINDOW_CONFIGURATIONP (config
))
5889 wrong_type_argument (Qwindow_configuration_p
, config
);
5891 data
= (struct save_window_data
*) XVECTOR (config
);
5892 saved_windows
= XVECTOR (data
->saved_windows
);
5893 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5896 DEFUN ("set-window-configuration", Fset_window_configuration
,
5897 Sset_window_configuration
, 1, 1, 0,
5898 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5899 CONFIGURATION must be a value previously returned
5900 by `current-window-configuration' (which see).
5901 If CONFIGURATION was made from a frame that is now deleted,
5902 only frame-independent values can be restored. In this case,
5903 the return value is nil. Otherwise the value is t. */)
5905 Lisp_Object configuration
;
5907 register struct save_window_data
*data
;
5908 struct Lisp_Vector
*saved_windows
;
5909 Lisp_Object new_current_buffer
;
5914 while (!WINDOW_CONFIGURATIONP (configuration
))
5915 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5917 data
= (struct save_window_data
*) XVECTOR (configuration
);
5918 saved_windows
= XVECTOR (data
->saved_windows
);
5920 new_current_buffer
= data
->current_buffer
;
5921 if (NILP (XBUFFER (new_current_buffer
)->name
))
5922 new_current_buffer
= Qnil
;
5925 if (XBUFFER (new_current_buffer
) == current_buffer
)
5926 /* The code further down "preserves point" by saving here PT in
5927 old_point and then setting it later back into PT. When the
5928 current-selected-window and the final-selected-window both show
5929 the current buffer, this suffers from the problem that the
5930 current PT is the window-point of the current-selected-window,
5931 while the final PT is the point of the final-selected-window, so
5932 this copy from one PT to the other would end up moving the
5933 window-point of the final-selected-window to the window-point of
5934 the current-selected-window. So we have to be careful which
5935 point of the current-buffer we copy into old_point. */
5936 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5937 && WINDOWP (selected_window
)
5938 && EQ (XWINDOW (selected_window
)->buffer
, new_current_buffer
)
5939 && !EQ (selected_window
, data
->current_window
))
5940 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5944 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5945 point in new_current_buffer as of the last time this buffer was
5946 used. This can be non-deterministic since it can be changed by
5947 things like jit-lock by mere temporary selection of some random
5948 window that happens to show this buffer.
5949 So if possible we want this arbitrary choice of "which point" to
5950 be the one from the to-be-selected-window so as to prevent this
5951 window's cursor from being copied from another window. */
5952 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5953 /* If current_window = selected_window, its point is in BUF_PT. */
5954 && !EQ (selected_window
, data
->current_window
))
5955 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5957 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5960 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5963 /* If f is a dead frame, don't bother rebuilding its window tree.
5964 However, there is other stuff we should still try to do below. */
5965 if (FRAME_LIVE_P (f
))
5967 register struct window
*w
;
5968 register struct saved_window
*p
;
5969 struct window
*root_window
;
5970 struct window
**leaf_windows
;
5974 /* If the frame has been resized since this window configuration was
5975 made, we change the frame to the size specified in the
5976 configuration, restore the configuration, and then resize it
5977 back. We keep track of the prevailing height in these variables. */
5978 int previous_frame_lines
= FRAME_LINES (f
);
5979 int previous_frame_cols
= FRAME_COLS (f
);
5980 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5981 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5983 /* The mouse highlighting code could get screwed up
5984 if it runs during this. */
5987 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5988 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5989 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5990 XFASTINT (data
->frame_cols
), 0, 0, 0);
5991 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5992 if (XFASTINT (data
->frame_menu_bar_lines
)
5993 != previous_frame_menu_bar_lines
)
5994 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5995 #ifdef HAVE_WINDOW_SYSTEM
5996 if (XFASTINT (data
->frame_tool_bar_lines
)
5997 != previous_frame_tool_bar_lines
)
5998 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
6002 /* "Swap out" point from the selected window's buffer
6003 into the window itself. (Normally the pointm of the selected
6004 window holds garbage.) We do this now, before
6005 restoring the window contents, and prevent it from
6006 being done later on when we select a new window. */
6007 if (! NILP (XWINDOW (selected_window
)->buffer
))
6009 w
= XWINDOW (selected_window
);
6010 set_marker_both (w
->pointm
,
6012 BUF_PT (XBUFFER (w
->buffer
)),
6013 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6016 windows_or_buffers_changed
++;
6017 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
6019 /* Problem: Freeing all matrices and later allocating them again
6020 is a serious redisplay flickering problem. What we would
6021 really like to do is to free only those matrices not reused
6023 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6025 = (struct window
**) alloca (count_windows (root_window
)
6026 * sizeof (struct window
*));
6027 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
6029 /* Temporarily avoid any problems with windows that are smaller
6030 than they are supposed to be. */
6031 window_min_height
= 1;
6032 window_min_width
= 1;
6035 Mark all windows now on frame as "deleted".
6036 Restoring the new configuration "undeletes" any that are in it.
6038 Save their current buffers in their height fields, since we may
6039 need it later, if a buffer saved in the configuration is now
6041 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6043 for (k
= 0; k
< saved_windows
->size
; k
++)
6045 p
= SAVED_WINDOW_N (saved_windows
, k
);
6046 w
= XWINDOW (p
->window
);
6049 if (!NILP (p
->parent
))
6050 w
->parent
= SAVED_WINDOW_N (saved_windows
,
6051 XFASTINT (p
->parent
))->window
;
6055 if (!NILP (p
->prev
))
6057 w
->prev
= SAVED_WINDOW_N (saved_windows
,
6058 XFASTINT (p
->prev
))->window
;
6059 XWINDOW (w
->prev
)->next
= p
->window
;
6064 if (!NILP (w
->parent
))
6066 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
6068 XWINDOW (w
->parent
)->vchild
= p
->window
;
6069 XWINDOW (w
->parent
)->hchild
= Qnil
;
6073 XWINDOW (w
->parent
)->hchild
= p
->window
;
6074 XWINDOW (w
->parent
)->vchild
= Qnil
;
6079 /* If we squirreled away the buffer in the window's height,
6081 if (BUFFERP (w
->total_lines
))
6082 w
->buffer
= w
->total_lines
;
6083 w
->left_col
= p
->left_col
;
6084 w
->top_line
= p
->top_line
;
6085 w
->total_cols
= p
->total_cols
;
6086 w
->total_lines
= p
->total_lines
;
6087 w
->hscroll
= p
->hscroll
;
6088 w
->min_hscroll
= p
->min_hscroll
;
6089 w
->display_table
= p
->display_table
;
6090 w
->orig_top_line
= p
->orig_top_line
;
6091 w
->orig_total_lines
= p
->orig_total_lines
;
6092 w
->left_margin_cols
= p
->left_margin_cols
;
6093 w
->right_margin_cols
= p
->right_margin_cols
;
6094 w
->left_fringe_width
= p
->left_fringe_width
;
6095 w
->right_fringe_width
= p
->right_fringe_width
;
6096 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
6097 w
->scroll_bar_width
= p
->scroll_bar_width
;
6098 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
6099 w
->dedicated
= p
->dedicated
;
6100 XSETFASTINT (w
->last_modified
, 0);
6101 XSETFASTINT (w
->last_overlay_modified
, 0);
6103 /* Reinstall the saved buffer and pointers into it. */
6104 if (NILP (p
->buffer
))
6105 w
->buffer
= p
->buffer
;
6108 if (!NILP (XBUFFER (p
->buffer
)->name
))
6109 /* If saved buffer is alive, install it. */
6111 w
->buffer
= p
->buffer
;
6112 w
->start_at_line_beg
= p
->start_at_line_beg
;
6113 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
6114 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
6115 Fset_marker (XBUFFER (w
->buffer
)->mark
,
6116 p
->mark
, w
->buffer
);
6118 /* As documented in Fcurrent_window_configuration, don't
6119 restore the location of point in the buffer which was
6120 current when the window configuration was recorded. */
6121 if (!EQ (p
->buffer
, new_current_buffer
)
6122 && XBUFFER (p
->buffer
) == current_buffer
)
6123 Fgoto_char (w
->pointm
);
6125 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
6126 /* Else unless window has a live buffer, get one. */
6128 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
6129 /* This will set the markers to beginning of visible
6131 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
6132 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
6133 w
->start_at_line_beg
= Qt
;
6136 /* Keeping window's old buffer; make sure the markers
6139 /* Set window markers at start of visible range. */
6140 if (XMARKER (w
->start
)->buffer
== 0)
6141 set_marker_restricted (w
->start
, make_number (0),
6143 if (XMARKER (w
->pointm
)->buffer
== 0)
6144 set_marker_restricted_both (w
->pointm
, w
->buffer
,
6145 BUF_PT (XBUFFER (w
->buffer
)),
6146 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6147 w
->start_at_line_beg
= Qt
;
6152 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
6153 /* Prevent "swapping out point" in the old selected window
6154 using the buffer that has been restored into it.
6155 We already swapped out point that from that window's old buffer. */
6156 selected_window
= Qnil
;
6158 /* Arrange *not* to restore point in the buffer that was
6159 current when the window configuration was saved. */
6160 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
6161 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
6162 make_number (old_point
),
6163 XWINDOW (data
->current_window
)->buffer
);
6165 Fselect_window (data
->current_window
, Qnil
);
6166 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
6169 if (NILP (data
->focus_frame
)
6170 || (FRAMEP (data
->focus_frame
)
6171 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
6172 Fredirect_frame_focus (frame
, data
->focus_frame
);
6174 #if 0 /* I don't understand why this is needed, and it causes problems
6175 when the frame's old selected window has been deleted. */
6176 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
6177 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
6181 /* Set the screen height to the value it had before this function. */
6182 if (previous_frame_lines
!= FRAME_LINES (f
)
6183 || previous_frame_cols
!= FRAME_COLS (f
))
6184 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
6186 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
6187 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
6188 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
6190 #ifdef HAVE_WINDOW_SYSTEM
6191 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
6192 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
6197 /* Now, free glyph matrices in windows that were not reused. */
6198 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
6200 if (NILP (leaf_windows
[i
]->buffer
))
6202 /* Assert it's not reused as a combination. */
6203 xassert (NILP (leaf_windows
[i
]->hchild
)
6204 && NILP (leaf_windows
[i
]->vchild
));
6205 free_window_matrices (leaf_windows
[i
]);
6207 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
6215 /* Fselect_window will have made f the selected frame, so we
6216 reselect the proper frame here. Fhandle_switch_frame will change the
6217 selected window too, but that doesn't make the call to
6218 Fselect_window above totally superfluous; it still sets f's
6220 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
6221 do_switch_frame (data
->selected_frame
, 0, 0);
6223 if (! NILP (Vwindow_configuration_change_hook
)
6224 && ! NILP (Vrun_hooks
))
6225 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
6228 if (!NILP (new_current_buffer
))
6229 Fset_buffer (new_current_buffer
);
6231 /* Restore the minimum heights recorded in the configuration. */
6232 window_min_height
= XINT (data
->min_height
);
6233 window_min_width
= XINT (data
->min_width
);
6235 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
6236 minibuf_selected_window
= data
->minibuf_selected_window
;
6238 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
6241 /* Mark all windows now on frame as deleted
6242 by setting their buffers to nil. */
6245 delete_all_subwindows (w
)
6246 register struct window
*w
;
6248 if (!NILP (w
->next
))
6249 delete_all_subwindows (XWINDOW (w
->next
));
6250 if (!NILP (w
->vchild
))
6251 delete_all_subwindows (XWINDOW (w
->vchild
));
6252 if (!NILP (w
->hchild
))
6253 delete_all_subwindows (XWINDOW (w
->hchild
));
6255 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6257 if (!NILP (w
->buffer
))
6260 /* We set all three of these fields to nil, to make sure that we can
6261 distinguish this dead window from any live window. Live leaf
6262 windows will have buffer set, and combination windows will have
6263 vchild or hchild set. */
6268 Vwindow_list
= Qnil
;
6272 count_windows (window
)
6273 register struct window
*window
;
6275 register int count
= 1;
6276 if (!NILP (window
->next
))
6277 count
+= count_windows (XWINDOW (window
->next
));
6278 if (!NILP (window
->vchild
))
6279 count
+= count_windows (XWINDOW (window
->vchild
));
6280 if (!NILP (window
->hchild
))
6281 count
+= count_windows (XWINDOW (window
->hchild
));
6286 /* Fill vector FLAT with leaf windows under W, starting at index I.
6287 Value is last index + 1. */
6290 get_leaf_windows (w
, flat
, i
)
6292 struct window
**flat
;
6297 if (!NILP (w
->hchild
))
6298 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6299 else if (!NILP (w
->vchild
))
6300 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6304 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6311 /* Return a pointer to the glyph W's physical cursor is on. Value is
6312 null if W's current matrix is invalid, so that no meaningfull glyph
6316 get_phys_cursor_glyph (w
)
6319 struct glyph_row
*row
;
6320 struct glyph
*glyph
;
6322 if (w
->phys_cursor
.vpos
>= 0
6323 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6324 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6326 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6327 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6336 save_window_save (window
, vector
, i
)
6338 struct Lisp_Vector
*vector
;
6341 register struct saved_window
*p
;
6342 register struct window
*w
;
6343 register Lisp_Object tem
;
6345 for (;!NILP (window
); window
= w
->next
)
6347 p
= SAVED_WINDOW_N (vector
, i
);
6348 w
= XWINDOW (window
);
6350 XSETFASTINT (w
->temslot
, i
); i
++;
6352 p
->buffer
= w
->buffer
;
6353 p
->left_col
= w
->left_col
;
6354 p
->top_line
= w
->top_line
;
6355 p
->total_cols
= w
->total_cols
;
6356 p
->total_lines
= w
->total_lines
;
6357 p
->hscroll
= w
->hscroll
;
6358 p
->min_hscroll
= w
->min_hscroll
;
6359 p
->display_table
= w
->display_table
;
6360 p
->orig_top_line
= w
->orig_top_line
;
6361 p
->orig_total_lines
= w
->orig_total_lines
;
6362 p
->left_margin_cols
= w
->left_margin_cols
;
6363 p
->right_margin_cols
= w
->right_margin_cols
;
6364 p
->left_fringe_width
= w
->left_fringe_width
;
6365 p
->right_fringe_width
= w
->right_fringe_width
;
6366 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6367 p
->scroll_bar_width
= w
->scroll_bar_width
;
6368 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6369 p
->dedicated
= w
->dedicated
;
6370 if (!NILP (w
->buffer
))
6372 /* Save w's value of point in the window configuration.
6373 If w is the selected window, then get the value of point
6374 from the buffer; pointm is garbage in the selected window. */
6375 if (EQ (window
, selected_window
))
6377 p
->pointm
= Fmake_marker ();
6378 set_marker_both (p
->pointm
, w
->buffer
,
6379 BUF_PT (XBUFFER (w
->buffer
)),
6380 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6383 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6385 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6386 p
->start_at_line_beg
= w
->start_at_line_beg
;
6388 tem
= XBUFFER (w
->buffer
)->mark
;
6389 p
->mark
= Fcopy_marker (tem
, Qnil
);
6396 p
->start_at_line_beg
= Qnil
;
6399 if (NILP (w
->parent
))
6402 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6407 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6409 if (!NILP (w
->vchild
))
6410 i
= save_window_save (w
->vchild
, vector
, i
);
6411 if (!NILP (w
->hchild
))
6412 i
= save_window_save (w
->hchild
, vector
, i
);
6418 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6419 Scurrent_window_configuration
, 0, 1, 0,
6420 doc
: /* Return an object representing the current window configuration of FRAME.
6421 If FRAME is nil or omitted, use the selected frame.
6422 This describes the number of windows, their sizes and current buffers,
6423 and for each displayed buffer, where display starts, and the positions of
6424 point and mark. An exception is made for point in the current buffer:
6425 its value is -not- saved.
6426 This also records the currently selected frame, and FRAME's focus
6427 redirection (see `redirect-frame-focus'). */)
6431 register Lisp_Object tem
;
6432 register int n_windows
;
6433 register struct save_window_data
*data
;
6434 register struct Lisp_Vector
*vec
;
6439 frame
= selected_frame
;
6440 CHECK_LIVE_FRAME (frame
);
6443 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6444 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6445 data
= (struct save_window_data
*)vec
;
6447 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6448 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6449 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6450 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6451 data
->selected_frame
= selected_frame
;
6452 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6453 XSETBUFFER (data
->current_buffer
, current_buffer
);
6454 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6455 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6456 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6457 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6458 XSETINT (data
->min_height
, window_min_height
);
6459 XSETINT (data
->min_width
, window_min_width
);
6460 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6461 data
->saved_windows
= tem
;
6462 for (i
= 0; i
< n_windows
; i
++)
6463 XVECTOR (tem
)->contents
[i
]
6464 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6465 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6466 XSETWINDOW_CONFIGURATION (tem
, data
);
6470 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6472 doc
: /* Execute BODY, preserving window sizes and contents.
6473 Return the value of the last form in BODY.
6474 Restore which buffer appears in which window, where display starts,
6475 and the value of point and mark for each window.
6476 Also restore the choice of selected window.
6477 Also restore which buffer is current.
6478 Does not restore the value of point in current buffer.
6479 usage: (save-window-excursion BODY ...) */)
6483 register Lisp_Object val
;
6484 register int count
= SPECPDL_INDEX ();
6486 record_unwind_protect (Fset_window_configuration
,
6487 Fcurrent_window_configuration (Qnil
));
6488 val
= Fprogn (args
);
6489 return unbind_to (count
, val
);
6494 /***********************************************************************
6496 ***********************************************************************/
6502 Lisp_Object tail
= Qnil
;
6503 Lisp_Object result
= Qnil
;
6510 if (!NILP (w
->hchild
))
6511 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6512 window_tree (XWINDOW (w
->hchild
))));
6513 else if (!NILP (w
->vchild
))
6514 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6515 window_tree (XWINDOW (w
->vchild
))));
6519 result
= tail
= Fcons (wn
, Qnil
);
6523 XSETCDR (tail
, Fcons (wn
, Qnil
));
6527 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6535 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6537 doc
: /* Return the window tree for frame FRAME.
6539 The return value is a list of the form (ROOT MINI), where ROOT
6540 represents the window tree of the frame's root window, and MINI
6541 is the frame's minibuffer window.
6543 If the root window is not split, ROOT is the root window itself.
6544 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6545 horizontal split, and t for a vertical split, EDGES gives the combined
6546 size and position of the subwindows in the split, and the rest of the
6547 elements are the subwindows in the split. Each of the subwindows may
6548 again be a window or a list representing a window split, and so on.
6549 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6551 If FRAME is nil or omitted, return information on the currently
6559 frame
= selected_frame
;
6561 CHECK_FRAME (frame
);
6564 if (!FRAME_LIVE_P (f
))
6567 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6571 /***********************************************************************
6573 ***********************************************************************/
6575 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6577 doc
: /* Set width of marginal areas of window WINDOW.
6578 If WINDOW is nil, set margins of the currently selected window.
6579 Second arg LEFT-WIDTH specifies the number of character cells to
6580 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6581 does the same for the right marginal area. A nil width parameter
6582 means no margin. */)
6583 (window
, left_width
, right_width
)
6584 Lisp_Object window
, left_width
, right_width
;
6586 struct window
*w
= decode_window (window
);
6588 /* Translate negative or zero widths to nil.
6589 Margins that are too wide have to be checked elsewhere. */
6591 if (!NILP (left_width
))
6593 CHECK_NUMBER (left_width
);
6594 if (XINT (left_width
) <= 0)
6598 if (!NILP (right_width
))
6600 CHECK_NUMBER (right_width
);
6601 if (XINT (right_width
) <= 0)
6605 if (!EQ (w
->left_margin_cols
, left_width
)
6606 || !EQ (w
->right_margin_cols
, right_width
))
6608 w
->left_margin_cols
= left_width
;
6609 w
->right_margin_cols
= right_width
;
6611 adjust_window_margins (w
);
6613 ++windows_or_buffers_changed
;
6614 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6621 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6623 doc
: /* Get width of marginal areas of window WINDOW.
6624 If WINDOW is omitted or nil, use the currently selected window.
6625 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6626 If a marginal area does not exist, its width will be returned
6631 struct window
*w
= decode_window (window
);
6632 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6637 /***********************************************************************
6639 ***********************************************************************/
6641 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6643 doc
: /* Set the fringe widths of window WINDOW.
6644 If WINDOW is nil, set the fringe widths of the currently selected
6646 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6647 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6648 fringe width. If a fringe width arg is nil, that means to use the
6649 frame's default fringe width. Default fringe widths can be set with
6650 the command `set-fringe-style'.
6651 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6652 outside of the display margins. By default, fringes are drawn between
6653 display marginal areas and the text area. */)
6654 (window
, left_width
, right_width
, outside_margins
)
6655 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6657 struct window
*w
= decode_window (window
);
6659 if (!NILP (left_width
))
6660 CHECK_NATNUM (left_width
);
6661 if (!NILP (right_width
))
6662 CHECK_NATNUM (right_width
);
6664 if (!EQ (w
->left_fringe_width
, left_width
)
6665 || !EQ (w
->right_fringe_width
, right_width
)
6666 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6668 w
->left_fringe_width
= left_width
;
6669 w
->right_fringe_width
= right_width
;
6670 w
->fringes_outside_margins
= outside_margins
;
6672 adjust_window_margins (w
);
6674 clear_glyph_matrix (w
->current_matrix
);
6675 w
->window_end_valid
= Qnil
;
6677 ++windows_or_buffers_changed
;
6678 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6685 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6687 doc
: /* Get width of fringes of window WINDOW.
6688 If WINDOW is omitted or nil, use the currently selected window.
6689 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6693 struct window
*w
= decode_window (window
);
6694 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6695 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6696 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6697 Qt
: Qnil
), Qnil
)));
6702 /***********************************************************************
6704 ***********************************************************************/
6706 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6708 doc
: /* Set width and type of scroll bars of window WINDOW.
6709 If window is nil, set scroll bars of the currently selected window.
6710 Second parameter WIDTH specifies the pixel width for the scroll bar;
6711 this is automatically adjusted to a multiple of the frame column width.
6712 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6713 bar: left, right, or nil.
6714 If WIDTH is nil, use the frame's scroll-bar width.
6715 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
6716 Fourth parameter HORIZONTAL-TYPE is currently unused. */)
6717 (window
, width
, vertical_type
, horizontal_type
)
6718 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6720 struct window
*w
= decode_window (window
);
6724 CHECK_NATNUM (width
);
6726 if (XINT (width
) == 0)
6727 vertical_type
= Qnil
;
6730 if (!(EQ (vertical_type
, Qnil
)
6731 || EQ (vertical_type
, Qleft
)
6732 || EQ (vertical_type
, Qright
)
6733 || EQ (vertical_type
, Qt
)))
6734 error ("Invalid type of vertical scroll bar");
6736 if (!EQ (w
->scroll_bar_width
, width
)
6737 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6739 w
->scroll_bar_width
= width
;
6740 w
->vertical_scroll_bar_type
= vertical_type
;
6742 adjust_window_margins (w
);
6744 clear_glyph_matrix (w
->current_matrix
);
6745 w
->window_end_valid
= Qnil
;
6747 ++windows_or_buffers_changed
;
6748 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6755 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6757 doc
: /* Get width and type of scroll bars of window WINDOW.
6758 If WINDOW is omitted or nil, use the currently selected window.
6759 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6760 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6765 struct window
*w
= decode_window (window
);
6766 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6767 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6768 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6769 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6770 Fcons (w
->vertical_scroll_bar_type
,
6771 Fcons (Qnil
, Qnil
))));
6776 /***********************************************************************
6778 ***********************************************************************/
6780 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6781 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6782 Use the selected window if WINDOW is nil or omitted.
6783 Normally, value is a multiple of the canonical character height of WINDOW;
6784 optional second arg PIXELS-P means value is measured in pixels. */)
6786 Lisp_Object window
, pixels_p
;
6793 window
= selected_window
;
6795 CHECK_WINDOW (window
);
6796 w
= XWINDOW (window
);
6797 f
= XFRAME (w
->frame
);
6799 if (FRAME_WINDOW_P (f
))
6800 result
= (NILP (pixels_p
)
6801 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6802 : make_number (-w
->vscroll
));
6804 result
= make_number (0);
6809 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6811 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6812 WINDOW nil means use the selected window. Normally, VSCROLL is a
6813 non-negative multiple of the canonical character height of WINDOW;
6814 optional third arg PIXELS-P non-nil means that VSCROLL is in pixels.
6815 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6816 corresponds to an integral number of pixels. The return value is the
6817 result of this rounding.
6818 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6819 (window
, vscroll
, pixels_p
)
6820 Lisp_Object window
, vscroll
, pixels_p
;
6826 window
= selected_window
;
6828 CHECK_WINDOW (window
);
6829 CHECK_NUMBER_OR_FLOAT (vscroll
);
6831 w
= XWINDOW (window
);
6832 f
= XFRAME (w
->frame
);
6834 if (FRAME_WINDOW_P (f
))
6836 int old_dy
= w
->vscroll
;
6838 w
->vscroll
= - (NILP (pixels_p
)
6839 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6840 : XFLOATINT (vscroll
));
6841 w
->vscroll
= min (w
->vscroll
, 0);
6843 if (w
->vscroll
!= old_dy
)
6845 /* Adjust glyph matrix of the frame if the virtual display
6846 area becomes larger than before. */
6847 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6850 /* Prevent redisplay shortcuts. */
6851 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6855 return Fwindow_vscroll (window
, pixels_p
);
6859 /* Call FN for all leaf windows on frame F. FN is called with the
6860 first argument being a pointer to the leaf window, and with
6861 additional argument USER_DATA. Stops when FN returns 0. */
6864 foreach_window (f
, fn
, user_data
)
6866 int (* fn
) P_ ((struct window
*, void *));
6869 /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
6870 if (WINDOWP (FRAME_ROOT_WINDOW (f
)))
6871 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6875 /* Helper function for foreach_window. Call FN for all leaf windows
6876 reachable from W. FN is called with the first argument being a
6877 pointer to the leaf window, and with additional argument USER_DATA.
6878 Stop when FN returns 0. Value is 0 if stopped by FN. */
6881 foreach_window_1 (w
, fn
, user_data
)
6883 int (* fn
) P_ ((struct window
*, void *));
6888 for (cont
= 1; w
&& cont
;)
6890 if (!NILP (w
->hchild
))
6891 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6892 else if (!NILP (w
->vchild
))
6893 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6895 cont
= fn (w
, user_data
);
6897 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6904 /* Freeze or unfreeze the window start of W unless it is a
6905 mini-window or the selected window. FREEZE_P non-null means freeze
6906 the window start. */
6909 freeze_window_start (w
, freeze_p
)
6913 if (w
== XWINDOW (selected_window
)
6914 || MINI_WINDOW_P (w
)
6915 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6916 && ! NILP (Vminibuf_scroll_window
)
6917 && w
== XWINDOW (Vminibuf_scroll_window
)))
6920 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6925 /* Freeze or unfreeze the window starts of all leaf windows on frame
6926 F, except the selected window and a mini-window. FREEZE_P non-zero
6927 means freeze the window start. */
6930 freeze_window_starts (f
, freeze_p
)
6934 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6938 /***********************************************************************
6940 ***********************************************************************/
6942 /* Return 1 if window configurations C1 and C2
6943 describe the same state of affairs. This is used by Fequal. */
6946 compare_window_configurations (c1
, c2
, ignore_positions
)
6948 int ignore_positions
;
6950 register struct save_window_data
*d1
, *d2
;
6951 struct Lisp_Vector
*sw1
, *sw2
;
6954 if (!WINDOW_CONFIGURATIONP (c1
))
6955 wrong_type_argument (Qwindow_configuration_p
, c1
);
6956 if (!WINDOW_CONFIGURATIONP (c2
))
6957 wrong_type_argument (Qwindow_configuration_p
, c2
);
6959 d1
= (struct save_window_data
*) XVECTOR (c1
);
6960 d2
= (struct save_window_data
*) XVECTOR (c2
);
6961 sw1
= XVECTOR (d1
->saved_windows
);
6962 sw2
= XVECTOR (d2
->saved_windows
);
6964 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6966 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6968 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6970 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6972 /* Don't compare the current_window field directly.
6973 Instead see w1_is_current and w2_is_current, below. */
6974 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6976 if (! ignore_positions
)
6978 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6980 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6983 /* Don't compare the root_window field.
6984 We don't require the two configurations
6985 to use the same window object,
6986 and the two root windows must be equivalent
6987 if everything else compares equal. */
6988 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6990 if (! EQ (d1
->min_width
, d2
->min_width
))
6992 if (! EQ (d1
->min_height
, d2
->min_height
))
6995 /* Verify that the two confis have the same number of windows. */
6996 if (sw1
->size
!= sw2
->size
)
6999 for (i
= 0; i
< sw1
->size
; i
++)
7001 struct saved_window
*p1
, *p2
;
7002 int w1_is_current
, w2_is_current
;
7004 p1
= SAVED_WINDOW_N (sw1
, i
);
7005 p2
= SAVED_WINDOW_N (sw2
, i
);
7007 /* Verify that the current windows in the two
7008 configurations correspond to each other. */
7009 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
7010 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
7012 if (w1_is_current
!= w2_is_current
)
7015 /* Verify that the corresponding windows do match. */
7016 if (! EQ (p1
->buffer
, p2
->buffer
))
7018 if (! EQ (p1
->left_col
, p2
->left_col
))
7020 if (! EQ (p1
->top_line
, p2
->top_line
))
7022 if (! EQ (p1
->total_cols
, p2
->total_cols
))
7024 if (! EQ (p1
->total_lines
, p2
->total_lines
))
7026 if (! EQ (p1
->display_table
, p2
->display_table
))
7028 if (! EQ (p1
->parent
, p2
->parent
))
7030 if (! EQ (p1
->prev
, p2
->prev
))
7032 if (! ignore_positions
)
7034 if (! EQ (p1
->hscroll
, p2
->hscroll
))
7036 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
7038 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
7040 if (NILP (Fequal (p1
->start
, p2
->start
)))
7042 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
7044 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
7047 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
7049 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
7051 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
7053 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
7055 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
7057 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
7059 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
7066 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
7067 Scompare_window_configurations
, 2, 2, 0,
7068 doc
: /* Compare two window configurations as regards the structure of windows.
7069 This function ignores details such as the values of point and mark
7070 and scrolling positions. */)
7074 if (compare_window_configurations (x
, y
, 1))
7082 struct frame
*f
= make_initial_frame ();
7083 XSETFRAME (selected_frame
, f
);
7084 Vterminal_frame
= selected_frame
;
7085 minibuf_window
= f
->minibuffer_window
;
7086 selected_window
= f
->selected_window
;
7087 last_nonminibuf_frame
= f
;
7089 window_initialized
= 1;
7095 Vwindow_list
= Qnil
;
7101 Qscroll_up
= intern ("scroll-up");
7102 staticpro (&Qscroll_up
);
7104 Qscroll_down
= intern ("scroll-down");
7105 staticpro (&Qscroll_down
);
7107 Qwindow_size_fixed
= intern ("window-size-fixed");
7108 staticpro (&Qwindow_size_fixed
);
7109 Fset (Qwindow_size_fixed
, Qnil
);
7111 staticpro (&Qwindow_configuration_change_hook
);
7112 Qwindow_configuration_change_hook
7113 = intern ("window-configuration-change-hook");
7115 Qwindowp
= intern ("windowp");
7116 staticpro (&Qwindowp
);
7118 Qwindow_configuration_p
= intern ("window-configuration-p");
7119 staticpro (&Qwindow_configuration_p
);
7121 Qwindow_live_p
= intern ("window-live-p");
7122 staticpro (&Qwindow_live_p
);
7124 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
7125 staticpro (&Qtemp_buffer_show_hook
);
7127 staticpro (&Vwindow_list
);
7129 minibuf_selected_window
= Qnil
;
7130 staticpro (&minibuf_selected_window
);
7132 window_scroll_pixel_based_preserve_y
= -1;
7134 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
7135 doc
: /* Non-nil means call as function to display a help buffer.
7136 The function is called with one argument, the buffer to be displayed.
7137 Used by `with-output-to-temp-buffer'.
7138 If this function is used, then it must do the entire job of showing
7139 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
7140 Vtemp_buffer_show_function
= Qnil
;
7142 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
7143 doc
: /* If non-nil, function to call to handle `display-buffer'.
7144 It will receive two args, the buffer and a flag which if non-nil means
7145 that the currently selected window is not acceptable.
7146 It should choose or create a window, display the specified buffer in it,
7147 and return the window.
7148 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
7149 work using this function. */);
7150 Vdisplay_buffer_function
= Qnil
;
7152 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
7153 doc
: /* *If non-nil, `display-buffer' should even the window heights.
7154 If nil, `display-buffer' will leave the window configuration alone. */);
7155 Veven_window_heights
= Qt
;
7157 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
7158 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
7159 Vminibuf_scroll_window
= Qnil
;
7161 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
7162 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
7163 If the minibuffer is active, the `minibuffer-scroll-window' mode line
7164 is displayed in the `mode-line' face. */);
7165 mode_line_in_non_selected_windows
= 1;
7167 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
7168 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
7169 Vother_window_scroll_buffer
= Qnil
;
7171 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
7172 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
7175 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
7176 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
7177 auto_window_vscroll_p
= 1;
7179 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
7180 doc
: /* *Non-nil means `display-buffer' should reuse frames.
7181 If the buffer in question is already displayed in a frame, raise that frame. */);
7182 display_buffer_reuse_frames
= 0;
7184 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
7185 doc
: /* Function to call to handle automatic new frame creation.
7186 It is called with no arguments and should return a newly created frame.
7188 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
7189 where `pop-up-frame-alist' would hold the default frame parameters. */);
7190 Vpop_up_frame_function
= Qnil
;
7192 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
7193 doc
: /* *List of buffer names that should have their own special frames.
7194 Displaying a buffer with `display-buffer' or `pop-to-buffer',
7195 if its name is in this list, makes a special frame for it
7196 using `special-display-function'. See also `special-display-regexps'.
7198 An element of the list can be a list instead of just a string.
7199 There are two ways to use a list as an element:
7200 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
7201 In the first case, the FRAME-PARAMETERS are pairs of the form
7202 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7203 In the second case, FUNCTION is called with BUFFER as the first argument,
7204 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
7205 All this is done by the function found in `special-display-function'.
7207 If the specified frame parameters include (same-buffer . t), the
7208 buffer is displayed in the currently selected window. Otherwise, if
7209 they include (same-frame . t), the buffer is displayed in a new window
7210 in the currently selected frame.
7212 If this variable appears \"not to work\", because you add a name to it
7213 but that buffer still appears in the selected window, look at the
7214 values of `same-window-buffer-names' and `same-window-regexps'.
7215 Those variables take precedence over this one. */);
7216 Vspecial_display_buffer_names
= Qnil
;
7218 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
7219 doc
: /* *List of regexps saying which buffers should have their own special frames.
7220 When displaying a buffer with `display-buffer' or `pop-to-buffer',
7221 if any regexp in this list matches the buffer name, it makes a
7222 special frame for the buffer by calling `special-display-function'.
7224 An element of the list can be a list instead of just a string.
7225 There are two ways to use a list as an element:
7226 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
7227 In the first case, the FRAME-PARAMETERS are pairs of the form
7228 \(PARAMETER . VALUE); these parameter values are used to create the frame.
7229 In the second case, FUNCTION is called with BUFFER as the first argument,
7230 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
7231 All this is done by the function found in `special-display-function'.
7233 If the specified frame parameters include (same-buffer . t), the
7234 buffer is displayed in the currently selected window. Otherwise, if
7235 they include (same-frame . t), the buffer is displayed in a new window
7236 in the currently selected frame.
7238 If this variable appears \"not to work\", because you add a regexp to it
7239 but the matching buffers still appear in the selected window, look at the
7240 values of `same-window-buffer-names' and `same-window-regexps'.
7241 Those variables take precedence over this one. */);
7242 Vspecial_display_regexps
= Qnil
;
7244 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
7245 doc
: /* Function to call to make a new frame for a special buffer.
7246 It is called with two arguments, the buffer and optional buffer specific
7247 data, and should return a window displaying that buffer.
7248 The default value normally makes a separate frame for the buffer,
7249 using `special-display-frame-alist' to specify the frame parameters.
7250 But if the buffer specific data includes (same-buffer . t) then the
7251 buffer is displayed in the current selected window.
7252 Otherwise if it includes (same-frame . t) then the buffer is displayed in
7253 a new window in the currently selected frame.
7255 A buffer is special if it is listed in `special-display-buffer-names'
7256 or matches a regexp in `special-display-regexps'. */);
7257 Vspecial_display_function
= Qnil
;
7259 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
7260 doc
: /* *List of buffer names that should appear in the selected window.
7261 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
7262 switches to it in the selected window, rather than making it appear
7263 in some other window.
7265 An element of the list can be a cons cell instead of just a string.
7266 Then the car must be a string, which specifies the buffer name.
7267 This is for compatibility with `special-display-buffer-names';
7268 the cdr of the cons cell is ignored.
7270 See also `same-window-regexps'. */);
7271 Vsame_window_buffer_names
= Qnil
;
7273 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7274 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7275 If a buffer name matches one of these regexps, then displaying it
7276 using `display-buffer' or `pop-to-buffer' switches to it
7277 in the selected window, rather than making it appear in some other window.
7279 An element of the list can be a cons cell instead of just a string.
7280 Then the car must be a string, which specifies the buffer name.
7281 This is for compatibility with `special-display-buffer-names';
7282 the cdr of the cons cell is ignored.
7284 See also `same-window-buffer-names'. */);
7285 Vsame_window_regexps
= Qnil
;
7287 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7288 doc
: /* *Non-nil means display-buffer should make new windows. */);
7291 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7292 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7293 next_screen_context_lines
= 2;
7295 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7296 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
7297 If there is only one window, it is split regardless of this value. */);
7298 split_height_threshold
= 500;
7300 DEFVAR_INT ("window-min-height", &window_min_height
,
7301 doc
: /* *Delete any window less than this tall (including its mode line). */);
7302 window_min_height
= 4;
7304 DEFVAR_INT ("window-min-width", &window_min_width
,
7305 doc
: /* *Delete any window less than this wide. */);
7306 window_min_width
= 10;
7308 DEFVAR_LISP ("scroll-preserve-screen-position",
7309 &Vscroll_preserve_screen_position
,
7310 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7311 A value of nil means point does not keep its screen position except
7312 at the scroll margin or window boundary respectively.
7313 A value of t means point keeps its screen position if the scroll
7314 command moved it vertically out of the window, e.g. when scrolling
7316 Any other value means point always keeps its screen position. */);
7317 Vscroll_preserve_screen_position
= Qnil
;
7319 DEFVAR_LISP ("window-configuration-change-hook",
7320 &Vwindow_configuration_change_hook
,
7321 doc
: /* Functions to call when window configuration changes.
7322 The selected frame is the one whose configuration has changed. */);
7323 Vwindow_configuration_change_hook
= Qnil
;
7325 defsubr (&Sselected_window
);
7326 defsubr (&Sminibuffer_window
);
7327 defsubr (&Swindow_minibuffer_p
);
7328 defsubr (&Swindowp
);
7329 defsubr (&Swindow_live_p
);
7330 defsubr (&Spos_visible_in_window_p
);
7331 defsubr (&Swindow_buffer
);
7332 defsubr (&Swindow_height
);
7333 defsubr (&Swindow_width
);
7334 defsubr (&Swindow_hscroll
);
7335 defsubr (&Sset_window_hscroll
);
7336 defsubr (&Swindow_redisplay_end_trigger
);
7337 defsubr (&Sset_window_redisplay_end_trigger
);
7338 defsubr (&Swindow_edges
);
7339 defsubr (&Swindow_pixel_edges
);
7340 defsubr (&Swindow_inside_edges
);
7341 defsubr (&Swindow_inside_pixel_edges
);
7342 defsubr (&Scoordinates_in_window_p
);
7343 defsubr (&Swindow_at
);
7344 defsubr (&Swindow_point
);
7345 defsubr (&Swindow_start
);
7346 defsubr (&Swindow_end
);
7347 defsubr (&Sset_window_point
);
7348 defsubr (&Sset_window_start
);
7349 defsubr (&Swindow_dedicated_p
);
7350 defsubr (&Sset_window_dedicated_p
);
7351 defsubr (&Swindow_display_table
);
7352 defsubr (&Sset_window_display_table
);
7353 defsubr (&Snext_window
);
7354 defsubr (&Sprevious_window
);
7355 defsubr (&Sother_window
);
7356 defsubr (&Sget_lru_window
);
7357 defsubr (&Sget_largest_window
);
7358 defsubr (&Sget_buffer_window
);
7359 defsubr (&Sdelete_other_windows
);
7360 defsubr (&Sdelete_windows_on
);
7361 defsubr (&Sreplace_buffer_in_windows
);
7362 defsubr (&Sdelete_window
);
7363 defsubr (&Sset_window_buffer
);
7364 defsubr (&Sselect_window
);
7365 defsubr (&Sspecial_display_p
);
7366 defsubr (&Ssame_window_p
);
7367 defsubr (&Sdisplay_buffer
);
7368 defsubr (&Sforce_window_update
);
7369 defsubr (&Ssplit_window
);
7370 defsubr (&Senlarge_window
);
7371 defsubr (&Sshrink_window
);
7372 defsubr (&Sadjust_window_trailing_edge
);
7373 defsubr (&Sscroll_up
);
7374 defsubr (&Sscroll_down
);
7375 defsubr (&Sscroll_left
);
7376 defsubr (&Sscroll_right
);
7377 defsubr (&Sother_window_for_scrolling
);
7378 defsubr (&Sscroll_other_window
);
7379 defsubr (&Sminibuffer_selected_window
);
7380 defsubr (&Srecenter
);
7381 defsubr (&Swindow_text_height
);
7382 defsubr (&Smove_to_window_line
);
7383 defsubr (&Swindow_configuration_p
);
7384 defsubr (&Swindow_configuration_frame
);
7385 defsubr (&Sset_window_configuration
);
7386 defsubr (&Scurrent_window_configuration
);
7387 defsubr (&Ssave_window_excursion
);
7388 defsubr (&Swindow_tree
);
7389 defsubr (&Sset_window_margins
);
7390 defsubr (&Swindow_margins
);
7391 defsubr (&Sset_window_fringes
);
7392 defsubr (&Swindow_fringes
);
7393 defsubr (&Sset_window_scroll_bars
);
7394 defsubr (&Swindow_scroll_bars
);
7395 defsubr (&Swindow_vscroll
);
7396 defsubr (&Sset_window_vscroll
);
7397 defsubr (&Scompare_window_configurations
);
7398 defsubr (&Swindow_list
);
7404 initial_define_key (control_x_map
, '1', "delete-other-windows");
7405 initial_define_key (control_x_map
, '2', "split-window");
7406 initial_define_key (control_x_map
, '0', "delete-window");
7407 initial_define_key (control_x_map
, 'o', "other-window");
7408 initial_define_key (control_x_map
, '^', "enlarge-window");
7409 initial_define_key (control_x_map
, '<', "scroll-left");
7410 initial_define_key (control_x_map
, '>', "scroll-right");
7412 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7413 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7414 initial_define_key (meta_map
, 'v', "scroll-down");
7416 initial_define_key (global_map
, Ctl('L'), "recenter");
7417 initial_define_key (meta_map
, 'r', "move-to-window-line");
7420 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7421 (do not change this comment) */