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 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
52 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
53 Lisp_Object Qwindow_size_fixed
;
54 extern Lisp_Object Qleft_margin
, Qright_margin
;
56 static int displayed_window_lines
P_ ((struct window
*));
57 static struct window
*decode_window
P_ ((Lisp_Object
));
58 static int count_windows
P_ ((struct window
*));
59 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
60 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
61 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
62 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
63 static int window_min_size_1
P_ ((struct window
*, int));
64 static int window_min_size
P_ ((struct window
*, int, int, int *));
65 static void size_window
P_ ((Lisp_Object
, int, int, int));
66 static int freeze_window_start
P_ ((struct window
*, void *));
67 static int window_fixed_size_p
P_ ((struct window
*, int, int));
68 static void enlarge_window
P_ ((Lisp_Object
, int, int, int));
69 static Lisp_Object window_list
P_ ((void));
70 static int add_window_to_list
P_ ((struct window
*, void *));
71 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
73 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
75 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
77 static int foreach_window_1
P_ ((struct window
*,
78 int (* fn
) (struct window
*, void *),
80 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
82 /* This is the window in which the terminal's cursor should
83 be left when nothing is being done with it. This must
84 always be a leaf window, and its buffer is selected by
85 the top level editing loop at the end of each command.
87 This value is always the same as
88 FRAME_SELECTED_WINDOW (selected_frame). */
90 Lisp_Object selected_window
;
92 /* A list of all windows for use by next_window and Fwindow_list.
93 Functions creating or deleting windows should invalidate this cache
94 by setting it to nil. */
96 Lisp_Object Vwindow_list
;
98 /* The mini-buffer window of the selected frame.
99 Note that you cannot test for mini-bufferness of an arbitrary window
100 by comparing against this; but you can test for mini-bufferness of
101 the selected window. */
103 Lisp_Object minibuf_window
;
105 /* Non-nil means it is the window whose mode line should be
106 shown as the selected window when the minibuffer is selected. */
108 Lisp_Object minibuf_selected_window
;
110 /* Non-nil means it is the window for C-M-v to scroll
111 when the mini-buffer is selected. */
113 Lisp_Object Vminibuf_scroll_window
;
115 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
117 Lisp_Object Vother_window_scroll_buffer
;
119 /* Non-nil means it's function to call to display temp buffers. */
121 Lisp_Object Vtemp_buffer_show_function
;
123 /* Non-zero means line and page scrolling on tall lines (with images)
124 does partial scrolling by modifying window-vscroll. */
126 int auto_window_vscroll_p
;
128 /* Non-zero means to use mode-line-inactive face in all windows but the
129 selected-window and the minibuffer-scroll-window when the
130 minibuffer is active. */
131 int mode_line_in_non_selected_windows
;
133 /* If a window gets smaller than either of these, it is removed. */
135 EMACS_INT window_min_height
;
136 EMACS_INT window_min_width
;
138 /* Nonzero implies Fdisplay_buffer should create windows. */
142 /* Nonzero implies make new frames for Fdisplay_buffer. */
146 /* Nonzero means reuse existing frames for displaying buffers. */
148 int display_buffer_reuse_frames
;
150 /* Non-nil means use this function instead of default */
152 Lisp_Object Vpop_up_frame_function
;
154 /* Function to call to handle Fdisplay_buffer. */
156 Lisp_Object Vdisplay_buffer_function
;
158 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
160 Lisp_Object Veven_window_heights
;
162 /* List of buffer *names* for buffers that should have their own frames. */
164 Lisp_Object Vspecial_display_buffer_names
;
166 /* List of regexps for buffer names that should have their own frames. */
168 Lisp_Object Vspecial_display_regexps
;
170 /* Function to pop up a special frame. */
172 Lisp_Object Vspecial_display_function
;
174 /* List of buffer *names* for buffers to appear in selected window. */
176 Lisp_Object Vsame_window_buffer_names
;
178 /* List of regexps for buffer names to appear in selected window. */
180 Lisp_Object Vsame_window_regexps
;
182 /* Hook run at end of temp_output_buffer_show. */
184 Lisp_Object Qtemp_buffer_show_hook
;
186 /* Fdisplay_buffer always splits the largest window
187 if that window is more than this high. */
189 EMACS_INT split_height_threshold
;
191 /* Number of lines of continuity in scrolling by screenfuls. */
193 EMACS_INT next_screen_context_lines
;
195 /* Incremented for each window created. */
197 static int sequence_number
;
199 /* Nonzero after init_window_once has finished. */
201 static int window_initialized
;
203 /* Hook to run when window config changes. */
205 Lisp_Object Qwindow_configuration_change_hook
;
206 Lisp_Object Vwindow_configuration_change_hook
;
208 /* Non-nil means scroll commands try to put point
209 at the same screen height as previously. */
211 Lisp_Object Vscroll_preserve_screen_position
;
213 #if 0 /* This isn't used anywhere. */
214 /* Nonzero means we can split a frame even if it is "unsplittable". */
215 static int inhibit_frame_unsplittable
;
218 extern EMACS_INT scroll_margin
;
220 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
222 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
223 doc
: /* Returns t if OBJECT is a window. */)
227 return WINDOWP (object
) ? Qt
: Qnil
;
230 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
231 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
235 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
242 register struct window
*p
;
244 p
= allocate_window ();
246 XSETFASTINT (p
->sequence_number
, sequence_number
);
247 XSETFASTINT (p
->left_col
, 0);
248 XSETFASTINT (p
->top_line
, 0);
249 XSETFASTINT (p
->total_lines
, 0);
250 XSETFASTINT (p
->total_cols
, 0);
251 XSETFASTINT (p
->hscroll
, 0);
252 XSETFASTINT (p
->min_hscroll
, 0);
253 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
254 p
->start
= Fmake_marker ();
255 p
->pointm
= Fmake_marker ();
256 XSETFASTINT (p
->use_time
, 0);
258 p
->display_table
= Qnil
;
260 p
->pseudo_window_p
= 0;
261 bzero (&p
->cursor
, sizeof (p
->cursor
));
262 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
263 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
264 p
->desired_matrix
= p
->current_matrix
= 0;
265 p
->nrows_scale_factor
= p
->ncols_scale_factor
= 1;
266 p
->phys_cursor_type
= -1;
267 p
->phys_cursor_width
= -1;
268 p
->must_be_updated_p
= 0;
269 XSETFASTINT (p
->window_end_vpos
, 0);
270 XSETFASTINT (p
->window_end_pos
, 0);
271 p
->window_end_valid
= Qnil
;
274 XSETFASTINT (p
->last_point
, 0);
275 p
->frozen_window_start_p
= 0;
276 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
277 p
->left_margin_cols
= Qnil
;
278 p
->right_margin_cols
= Qnil
;
279 p
->left_fringe_width
= Qnil
;
280 p
->right_fringe_width
= Qnil
;
281 p
->fringes_outside_margins
= Qnil
;
282 p
->scroll_bar_width
= Qnil
;
283 p
->vertical_scroll_bar_type
= Qt
;
289 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
290 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
293 return selected_window
;
296 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
297 doc
: /* Return the window used now for minibuffers.
298 If the optional argument FRAME is specified, return the minibuffer window
299 used by that frame. */)
304 frame
= selected_frame
;
305 CHECK_LIVE_FRAME (frame
);
306 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
309 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
310 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
311 WINDOW defaults to the selected window. */)
315 struct window
*w
= decode_window (window
);
316 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
320 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
321 Spos_visible_in_window_p
, 0, 3, 0,
322 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
323 Return nil if that position is scrolled vertically out of view.
324 If a character is only partially visible, nil is returned, unless the
325 optional argument PARTIALLY is non-nil.
326 If POS is only out of view because of horizontal scrolling, return non-nil.
327 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
329 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
330 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
331 relative to the top left corner of the window. PARTIAL is nil if the character
332 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
333 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
334 (pos
, window
, partially
)
335 Lisp_Object pos
, window
, partially
;
337 register struct window
*w
;
339 register struct buffer
*buf
;
341 Lisp_Object in_window
= Qnil
;
342 int rtop
, rbot
, fully_p
= 1;
345 w
= decode_window (window
);
346 buf
= XBUFFER (w
->buffer
);
347 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
351 CHECK_NUMBER_COERCE_MARKER (pos
);
354 else if (w
== XWINDOW (selected_window
))
357 posint
= XMARKER (w
->pointm
)->charpos
;
359 /* If position is above window start or outside buffer boundaries,
360 or if window start is out of range, position is not visible. */
361 if (posint
>= CHARPOS (top
)
362 && posint
<= BUF_ZV (buf
)
363 && CHARPOS (top
) >= BUF_BEGV (buf
)
364 && CHARPOS (top
) <= BUF_ZV (buf
)
365 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
366 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
369 if (!NILP (in_window
) && !NILP (partially
))
370 in_window
= Fcons (make_number (x
),
371 Fcons (make_number (y
),
372 Fcons ((fully_p
? Qnil
373 : Fcons (make_number (rtop
),
374 make_number (rbot
))),
380 static struct window
*
381 decode_window (window
)
382 register Lisp_Object window
;
385 return XWINDOW (selected_window
);
387 CHECK_LIVE_WINDOW (window
);
388 return XWINDOW (window
);
391 static struct window
*
392 decode_any_window (window
)
393 register Lisp_Object window
;
396 return XWINDOW (selected_window
);
398 CHECK_WINDOW (window
);
399 return XWINDOW (window
);
402 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
403 doc
: /* Return the buffer that WINDOW is displaying.
404 WINDOW defaults to the selected window. */)
408 return decode_window (window
)->buffer
;
411 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
412 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
416 return decode_any_window (window
)->total_lines
;
419 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
420 doc
: /* Return the number of display columns in WINDOW.
421 This is the width that is usable columns available for text in WINDOW.
422 If you want to find out how many columns WINDOW takes up,
423 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
427 return make_number (window_box_text_cols (decode_any_window (window
)));
430 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
431 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
435 return decode_window (window
)->hscroll
;
438 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
439 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
440 Return NCOL. NCOL should be zero or positive.
442 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
443 window so that the location of point becomes invisible. */)
445 Lisp_Object window
, ncol
;
447 struct window
*w
= decode_window (window
);
451 hscroll
= max (0, XINT (ncol
));
453 /* Prevent redisplay shortcuts when changing the hscroll. */
454 if (XINT (w
->hscroll
) != hscroll
)
455 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
457 w
->hscroll
= make_number (hscroll
);
461 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
462 Swindow_redisplay_end_trigger
, 0, 1, 0,
463 doc
: /* Return WINDOW's redisplay end trigger value.
464 See `set-window-redisplay-end-trigger' for more information. */)
468 return decode_window (window
)->redisplay_end_trigger
;
471 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
472 Sset_window_redisplay_end_trigger
, 2, 2, 0,
473 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
474 VALUE should be a buffer position (typically a marker) or nil.
475 If it is a buffer position, then if redisplay in WINDOW reaches a position
476 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
477 with two arguments: WINDOW, and the end trigger value.
478 Afterwards the end-trigger value is reset to nil. */)
480 register Lisp_Object window
, value
;
482 register struct window
*w
;
484 w
= decode_window (window
);
485 w
->redisplay_end_trigger
= value
;
489 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
490 doc
: /* Return a list of the edge coordinates of WINDOW.
491 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
492 RIGHT is one more than the rightmost column occupied by WINDOW,
493 and BOTTOM is one more than the bottommost row occupied by WINDOW.
494 The edges include the space used by the window's scroll bar,
495 display margins, fringes, header line, and mode line, if it has them.
496 To get the edges of the actual text area, use `window-inside-edges'. */)
500 register struct window
*w
= decode_any_window (window
);
502 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
503 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
504 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
505 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
509 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
510 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
511 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
512 RIGHT is one more than the rightmost x position occupied by WINDOW,
513 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
514 The pixel edges include the space used by the window's scroll bar,
515 display margins, fringes, header line, and mode line, if it has them.
516 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
520 register struct window
*w
= decode_any_window (window
);
522 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
523 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
524 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
525 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
529 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
530 doc
: /* Return a list of the edge coordinates of WINDOW.
531 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
532 RIGHT is one more than the rightmost column used by text in WINDOW,
533 and BOTTOM is one more than the bottommost row used by text in WINDOW.
534 The inside edges do not include the space used by the window's scroll bar,
535 display margins, fringes, header line, and/or mode line. */)
539 register struct window
*w
= decode_any_window (window
);
541 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
542 + WINDOW_LEFT_MARGIN_COLS (w
)
543 + WINDOW_LEFT_FRINGE_COLS (w
)),
544 make_number (WINDOW_TOP_EDGE_LINE (w
)
545 + WINDOW_HEADER_LINE_LINES (w
)),
546 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
547 - WINDOW_RIGHT_MARGIN_COLS (w
)
548 - WINDOW_RIGHT_FRINGE_COLS (w
)),
549 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
550 - WINDOW_MODE_LINE_LINES (w
)));
553 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
554 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
555 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
556 RIGHT is one more than the rightmost x position used by text in WINDOW,
557 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
558 The inside edges do not include the space used by the window's scroll bar,
559 display margins, fringes, header line, and/or mode line. */)
563 register struct window
*w
= decode_any_window (window
);
565 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
566 + WINDOW_LEFT_MARGIN_WIDTH (w
)
567 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
568 make_number (WINDOW_TOP_EDGE_Y (w
)
569 + WINDOW_HEADER_LINE_HEIGHT (w
)),
570 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
571 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
572 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
573 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
574 - WINDOW_MODE_LINE_HEIGHT (w
)));
577 /* Test if the character at column *X, row *Y is within window W.
578 If it is not, return ON_NOTHING;
579 if it is in the window's text area,
580 set *x and *y to its location relative to the upper left corner
583 if it is on the window's modeline, return ON_MODE_LINE;
584 if it is on the border between the window and its right sibling,
585 return ON_VERTICAL_BORDER.
586 if it is on a scroll bar,
587 return ON_SCROLL_BAR.
588 if it is on the window's top line, return ON_HEADER_LINE;
589 if it is in left or right fringe of the window,
590 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
591 to window-relative coordinates;
592 if it is in the marginal area to the left/right of the window,
593 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
594 to window-relative coordinates.
596 X and Y are frame relative pixel coordinates. */
598 static enum window_part
599 coordinates_in_window (w
, x
, y
)
600 register struct window
*w
;
603 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
604 int left_x
, right_x
, top_y
, bottom_y
;
605 enum window_part part
;
606 int ux
= FRAME_COLUMN_WIDTH (f
);
607 int x0
= WINDOW_LEFT_EDGE_X (w
);
608 int x1
= WINDOW_RIGHT_EDGE_X (w
);
609 /* The width of the area where the vertical line can be dragged.
610 (Between mode lines for instance. */
611 int grabbable_width
= ux
;
612 int lmargin_width
, rmargin_width
, text_left
, text_right
;
614 /* In what's below, we subtract 1 when computing right_x because we
615 want the rightmost pixel, which is given by left_pixel+width-1. */
616 if (w
->pseudo_window_p
)
619 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
620 top_y
= WINDOW_TOP_EDGE_Y (w
);
621 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
625 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
626 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
627 top_y
= WINDOW_TOP_EDGE_Y (w
);
628 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
631 /* Outside any interesting row? */
632 if (*y
< top_y
|| *y
>= bottom_y
)
635 /* On the mode line or header line? If it's near the start of
636 the mode or header line of window that's has a horizontal
637 sibling, say it's on the vertical line. That's to be able
638 to resize windows horizontally in case we're using toolkit
641 if (WINDOW_WANTS_MODELINE_P (w
)
642 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
646 header_vertical_border_check
:
647 /* We're somewhere on the mode line. We consider the place
648 between mode lines of horizontally adjacent mode lines
649 as the vertical border. If scroll bars on the left,
650 return the right window. */
651 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
652 || WINDOW_RIGHTMOST_P (w
))
654 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
655 return ON_VERTICAL_BORDER
;
659 if (abs (*x
- x1
) < grabbable_width
)
660 return ON_VERTICAL_BORDER
;
663 if (*x
< x0
|| *x
>= x1
)
666 /* Convert X and Y to window relative coordinates.
667 Mode line starts at left edge of window. */
673 if (WINDOW_WANTS_HEADER_LINE_P (w
)
674 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
676 part
= ON_HEADER_LINE
;
677 goto header_vertical_border_check
;
680 if (*x
< x0
|| *x
>= x1
)
683 /* Outside any interesting column? */
684 if (*x
< left_x
|| *x
> right_x
)
687 return ON_SCROLL_BAR
;
690 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
691 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
693 text_left
= window_box_left (w
, TEXT_AREA
);
694 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
696 if (FRAME_WINDOW_P (f
))
698 if (!w
->pseudo_window_p
699 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
700 && !WINDOW_RIGHTMOST_P (w
)
701 && (abs (*x
- right_x
) < grabbable_width
))
702 return ON_VERTICAL_BORDER
;
706 /* Need to say "*x > right_x" rather than >=, since on character
707 terminals, the vertical line's x coordinate is right_x. */
708 if (!w
->pseudo_window_p
709 && !WINDOW_RIGHTMOST_P (w
)
710 && *x
> right_x
- ux
)
712 /* On the border on the right side of the window? Assume that
713 this area begins at RIGHT_X minus a canonical char width. */
714 return ON_VERTICAL_BORDER
;
720 if (lmargin_width
> 0
721 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
722 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
723 : (*x
< left_x
+ lmargin_width
)))
726 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
727 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
729 return ON_LEFT_MARGIN
;
732 /* Convert X and Y to window-relative pixel coordinates. */
735 return ON_LEFT_FRINGE
;
738 if (*x
>= text_right
)
740 if (rmargin_width
> 0
741 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
742 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
743 : (*x
>= right_x
- rmargin_width
)))
745 *x
-= right_x
- rmargin_width
;
746 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
747 *x
+= WINDOW_RIGHT_FRINGE_WIDTH (w
);
749 return ON_RIGHT_MARGIN
;
752 /* Convert X and Y to window-relative pixel coordinates. */
753 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
755 return ON_RIGHT_FRINGE
;
758 /* Everything special ruled out - must be on text area */
765 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
766 Scoordinates_in_window_p
, 2, 2, 0,
767 doc
: /* Return non-nil if COORDINATES are in WINDOW.
768 COORDINATES is a cons of the form (X . Y), X and Y being distances
769 measured in characters from the upper-left corner of the frame.
770 \(0 . 0) denotes the character in the upper left corner of the
772 If COORDINATES are in the text portion of WINDOW,
773 the coordinates relative to the window are returned.
774 If they are in the mode line of WINDOW, `mode-line' is returned.
775 If they are in the top mode line of WINDOW, `header-line' is returned.
776 If they are in the left fringe of WINDOW, `left-fringe' is returned.
777 If they are in the right fringe of WINDOW, `right-fringe' is returned.
778 If they are on the border between WINDOW and its right sibling,
779 `vertical-line' is returned.
780 If they are in the windows's left or right marginal areas, `left-margin'\n\
781 or `right-margin' is returned. */)
782 (coordinates
, window
)
783 register Lisp_Object coordinates
, window
;
790 CHECK_WINDOW (window
);
791 w
= XWINDOW (window
);
792 f
= XFRAME (w
->frame
);
793 CHECK_CONS (coordinates
);
794 lx
= Fcar (coordinates
);
795 ly
= Fcdr (coordinates
);
796 CHECK_NUMBER_OR_FLOAT (lx
);
797 CHECK_NUMBER_OR_FLOAT (ly
);
798 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
799 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
801 switch (coordinates_in_window (w
, &x
, &y
))
807 /* X and Y are now window relative pixel coordinates. Convert
808 them to canonical char units before returning them. */
809 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
810 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
815 case ON_VERTICAL_BORDER
:
816 return Qvertical_line
;
824 case ON_RIGHT_FRINGE
:
825 return Qright_fringe
;
830 case ON_RIGHT_MARGIN
:
831 return Qright_margin
;
834 /* Historically we are supposed to return nil in this case. */
843 /* Callback for foreach_window, used in window_from_coordinates.
844 Check if window W contains coordinates specified by USER_DATA which
845 is actually a pointer to a struct check_window_data CW.
847 Check if window W contains coordinates *CW->x and *CW->y. If it
848 does, return W in *CW->window, as Lisp_Object, and return in
849 *CW->part the part of the window under coordinates *X,*Y. Return
850 zero from this function to stop iterating over windows. */
852 struct check_window_data
856 enum window_part
*part
;
860 check_window_containing (w
, user_data
)
864 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
865 enum window_part found
;
868 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
869 if (found
!= ON_NOTHING
)
872 XSETWINDOW (*cw
->window
, w
);
880 /* Find the window containing frame-relative pixel position X/Y and
881 return it as a Lisp_Object.
883 If X, Y is on one of the window's special `window_part' elements,
884 set *PART to the id of that element, and return X and Y converted
885 to window relative coordinates in WX and WY.
887 If there is no window under X, Y return nil and leave *PART
888 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
890 This function was previously implemented with a loop cycling over
891 windows with Fnext_window, and starting with the frame's selected
892 window. It turned out that this doesn't work with an
893 implementation of next_window using Vwindow_list, because
894 FRAME_SELECTED_WINDOW (F) is not always contained in the window
895 tree of F when this function is called asynchronously from
896 note_mouse_highlight. The original loop didn't terminate in this
900 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
903 enum window_part
*part
;
908 struct check_window_data cw
;
909 enum window_part dummy
;
915 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
916 foreach_window (f
, check_window_containing
, &cw
);
918 /* If not found above, see if it's in the tool bar window, if a tool
922 && WINDOWP (f
->tool_bar_window
)
923 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
924 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
928 window
= f
->tool_bar_window
;
937 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
938 doc
: /* Return window containing coordinates X and Y on FRAME.
939 If omitted, FRAME defaults to the currently selected frame.
940 The top left corner of the frame is considered to be row 0,
943 Lisp_Object x
, y
, frame
;
948 frame
= selected_frame
;
949 CHECK_LIVE_FRAME (frame
);
952 /* Check that arguments are integers or floats. */
953 CHECK_NUMBER_OR_FLOAT (x
);
954 CHECK_NUMBER_OR_FLOAT (y
);
956 return window_from_coordinates (f
,
957 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
958 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
959 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
960 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
964 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
965 doc
: /* Return current value of point in WINDOW.
966 For a nonselected window, this is the value point would have
967 if that window were selected.
969 Note that, when WINDOW is the selected window and its buffer
970 is also currently selected, the value returned is the same as (point).
971 It would be more strictly correct to return the `top-level' value
972 of point, outside of any save-excursion forms.
973 But that is hard to define. */)
977 register struct window
*w
= decode_window (window
);
979 if (w
== XWINDOW (selected_window
)
980 && current_buffer
== XBUFFER (w
->buffer
))
982 return Fmarker_position (w
->pointm
);
985 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
986 doc
: /* Return position at which display currently starts in WINDOW.
987 This is updated by redisplay or by calling `set-window-start'. */)
991 return Fmarker_position (decode_window (window
)->start
);
994 /* This is text temporarily removed from the doc string below.
996 This function returns nil if the position is not currently known.
997 That happens when redisplay is preempted and doesn't finish.
998 If in that case you want to compute where the end of the window would
999 have been if redisplay had finished, do this:
1001 (goto-char (window-start window))
1002 (vertical-motion (1- (window-height window)) window)
1005 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1006 doc
: /* Return position at which display currently ends in WINDOW.
1007 This is updated by redisplay, when it runs to completion.
1008 Simply changing the buffer text or setting `window-start'
1009 does not update this value.
1010 Return nil if there is no recorded value. \(This can happen if the
1011 last redisplay of WINDOW was preempted, and did not finish.)
1012 If UPDATE is non-nil, compute the up-to-date position
1013 if it isn't already recorded. */)
1015 Lisp_Object window
, update
;
1018 struct window
*w
= decode_window (window
);
1024 #if 0 /* This change broke some things. We should make it later. */
1025 /* If we don't know the end position, return nil.
1026 The user can compute it with vertical-motion if he wants to.
1027 It would be nicer to do it automatically,
1028 but that's so slow that it would probably bother people. */
1029 if (NILP (w
->window_end_valid
))
1034 && ! (! NILP (w
->window_end_valid
)
1035 && XFASTINT (w
->last_modified
) >= MODIFF
)
1038 struct text_pos startp
;
1040 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1042 /* In case W->start is out of the range, use something
1043 reasonable. This situation occurred when loading a file with
1044 `-l' containing a call to `rmail' with subsequent other
1045 commands. At the end, W->start happened to be BEG, while
1046 rmail had already narrowed the buffer. */
1047 if (XMARKER (w
->start
)->charpos
< BEGV
)
1048 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1049 else if (XMARKER (w
->start
)->charpos
> ZV
)
1050 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1052 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1054 /* Cannot use Fvertical_motion because that function doesn't
1055 cope with variable-height lines. */
1056 if (b
!= current_buffer
)
1058 old_buffer
= current_buffer
;
1059 set_buffer_internal (b
);
1062 start_display (&it
, w
, startp
);
1063 move_it_vertically (&it
, window_box_height (w
));
1064 if (it
.current_y
< it
.last_visible_y
)
1065 move_it_past_eol (&it
);
1066 value
= make_number (IT_CHARPOS (it
));
1069 set_buffer_internal (old_buffer
);
1072 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1077 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1078 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1081 Lisp_Object window
, pos
;
1083 register struct window
*w
= decode_window (window
);
1085 CHECK_NUMBER_COERCE_MARKER (pos
);
1086 if (w
== XWINDOW (selected_window
)
1087 && XBUFFER (w
->buffer
) == current_buffer
)
1090 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1092 /* We have to make sure that redisplay updates the window to show
1093 the new value of point. */
1094 if (!EQ (window
, selected_window
))
1095 ++windows_or_buffers_changed
;
1100 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1101 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1103 Optional third arg NOFORCE non-nil inhibits next redisplay
1104 from overriding motion of point in order to display at this exact start. */)
1105 (window
, pos
, noforce
)
1106 Lisp_Object window
, pos
, noforce
;
1108 register struct window
*w
= decode_window (window
);
1110 CHECK_NUMBER_COERCE_MARKER (pos
);
1111 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1112 /* this is not right, but much easier than doing what is right. */
1113 w
->start_at_line_beg
= Qnil
;
1115 w
->force_start
= Qt
;
1116 w
->update_mode_line
= Qt
;
1117 XSETFASTINT (w
->last_modified
, 0);
1118 XSETFASTINT (w
->last_overlay_modified
, 0);
1119 if (!EQ (window
, selected_window
))
1120 windows_or_buffers_changed
++;
1125 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1127 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1128 See also `set-window-dedicated-p'. */)
1132 return decode_window (window
)->dedicated
;
1135 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1136 Sset_window_dedicated_p
, 2, 2, 0,
1137 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1138 If it is dedicated, Emacs will not automatically change
1139 which buffer appears in it.
1140 The second argument is the new value for the dedication flag;
1141 non-nil means yes. */)
1143 Lisp_Object window
, arg
;
1145 register struct window
*w
= decode_window (window
);
1149 return w
->dedicated
;
1152 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1154 doc
: /* Return the display-table that WINDOW is using. */)
1158 return decode_window (window
)->display_table
;
1161 /* Get the display table for use on window W. This is either W's
1162 display table or W's buffer's display table. Ignore the specified
1163 tables if they are not valid; if no valid table is specified,
1166 struct Lisp_Char_Table
*
1167 window_display_table (w
)
1170 struct Lisp_Char_Table
*dp
= NULL
;
1172 if (DISP_TABLE_P (w
->display_table
))
1173 dp
= XCHAR_TABLE (w
->display_table
);
1174 else if (BUFFERP (w
->buffer
))
1176 struct buffer
*b
= XBUFFER (w
->buffer
);
1178 if (DISP_TABLE_P (b
->display_table
))
1179 dp
= XCHAR_TABLE (b
->display_table
);
1180 else if (DISP_TABLE_P (Vstandard_display_table
))
1181 dp
= XCHAR_TABLE (Vstandard_display_table
);
1187 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1188 doc
: /* Set WINDOW's display-table to TABLE. */)
1190 register Lisp_Object window
, table
;
1192 register struct window
*w
;
1194 w
= decode_window (window
);
1195 w
->display_table
= table
;
1199 /* Record info on buffer window w is displaying
1200 when it is about to cease to display that buffer. */
1203 register struct window
*w
;
1210 if (b
!= XMARKER (w
->pointm
)->buffer
)
1214 if (w
== XWINDOW (selected_window
)
1215 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1216 /* Do this except when the selected window's buffer
1217 is being removed from some other window. */
1219 /* last_window_start records the start position that this buffer
1220 had in the last window to be disconnected from it.
1221 Now that this statement is unconditional,
1222 it is possible for the buffer to be displayed in the
1223 selected window, while last_window_start reflects another
1224 window which was recently showing the same buffer.
1225 Some people might say that might be a good thing. Let's see. */
1226 b
->last_window_start
= marker_position (w
->start
);
1228 /* Point in the selected window's buffer
1229 is actually stored in that buffer, and the window's pointm isn't used.
1230 So don't clobber point in that buffer. */
1231 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1232 /* This line helps to fix Horsley's testbug.el bug. */
1233 && !(WINDOWP (b
->last_selected_window
)
1234 && w
!= XWINDOW (b
->last_selected_window
)
1235 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1236 temp_set_point_both (b
,
1237 clip_to_bounds (BUF_BEGV (b
),
1238 XMARKER (w
->pointm
)->charpos
,
1240 clip_to_bounds (BUF_BEGV_BYTE (b
),
1241 marker_byte_position (w
->pointm
),
1244 if (WINDOWP (b
->last_selected_window
)
1245 && w
== XWINDOW (b
->last_selected_window
))
1246 b
->last_selected_window
= Qnil
;
1249 /* Put replacement into the window structure in place of old. */
1251 replace_window (old
, replacement
)
1252 Lisp_Object old
, replacement
;
1254 register Lisp_Object tem
;
1255 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1257 /* If OLD is its frame's root_window, then replacement is the new
1258 root_window for that frame. */
1260 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1261 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1263 p
->left_col
= o
->left_col
;
1264 p
->top_line
= o
->top_line
;
1265 p
->total_cols
= o
->total_cols
;
1266 p
->total_lines
= o
->total_lines
;
1267 p
->desired_matrix
= p
->current_matrix
= 0;
1269 bzero (&p
->cursor
, sizeof (p
->cursor
));
1270 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1271 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1272 p
->phys_cursor_type
= -1;
1273 p
->phys_cursor_width
= -1;
1274 p
->must_be_updated_p
= 0;
1275 p
->pseudo_window_p
= 0;
1276 XSETFASTINT (p
->window_end_vpos
, 0);
1277 XSETFASTINT (p
->window_end_pos
, 0);
1278 p
->window_end_valid
= Qnil
;
1279 p
->frozen_window_start_p
= 0;
1280 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1282 p
->next
= tem
= o
->next
;
1284 XWINDOW (tem
)->prev
= replacement
;
1286 p
->prev
= tem
= o
->prev
;
1288 XWINDOW (tem
)->next
= replacement
;
1290 p
->parent
= tem
= o
->parent
;
1293 if (EQ (XWINDOW (tem
)->vchild
, old
))
1294 XWINDOW (tem
)->vchild
= replacement
;
1295 if (EQ (XWINDOW (tem
)->hchild
, old
))
1296 XWINDOW (tem
)->hchild
= replacement
;
1299 /*** Here, if replacement is a vertical combination
1300 and so is its new parent, we should make replacement's
1301 children be children of that parent instead. ***/
1304 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1305 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1307 register Lisp_Object window
;
1309 delete_window (window
);
1311 if (! NILP (Vwindow_configuration_change_hook
)
1312 && ! NILP (Vrun_hooks
))
1313 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1319 delete_window (window
)
1320 register Lisp_Object window
;
1322 register Lisp_Object tem
, parent
, sib
;
1323 register struct window
*p
;
1324 register struct window
*par
;
1327 /* Because this function is called by other C code on non-leaf
1328 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1329 so we can't decode_window here. */
1331 window
= selected_window
;
1333 CHECK_WINDOW (window
);
1334 p
= XWINDOW (window
);
1336 /* It's okay to delete an already-deleted window. */
1337 if (NILP (p
->buffer
)
1339 && NILP (p
->vchild
))
1344 error ("Attempt to delete minibuffer or sole ordinary window");
1345 par
= XWINDOW (parent
);
1347 windows_or_buffers_changed
++;
1348 Vwindow_list
= Qnil
;
1349 f
= XFRAME (WINDOW_FRAME (p
));
1350 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1352 /* Are we trying to delete any frame's selected window? */
1354 Lisp_Object swindow
, pwindow
;
1356 /* See if the frame's selected window is either WINDOW
1357 or any subwindow of it, by finding all that window's parents
1358 and comparing each one with WINDOW. */
1359 swindow
= FRAME_SELECTED_WINDOW (f
);
1364 while (!NILP (pwindow
))
1366 if (EQ (window
, pwindow
))
1368 pwindow
= XWINDOW (pwindow
)->parent
;
1371 /* If the window being deleted is not a parent of SWINDOW,
1372 then SWINDOW is ok as the new selected window. */
1373 if (!EQ (window
, pwindow
))
1375 /* Otherwise, try another window for SWINDOW. */
1376 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1378 /* If we get back to the frame's selected window,
1379 it means there was no acceptable alternative,
1380 so we cannot delete. */
1381 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1382 error ("Cannot delete window");
1385 /* If we need to change SWINDOW, do it. */
1386 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1388 /* If we're about to delete the selected window on the
1389 selected frame, then we should use Fselect_window to select
1390 the new window. On the other hand, if we're about to
1391 delete the selected window on any other frame, we shouldn't do
1392 anything but set the frame's selected_window slot. */
1393 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1394 Fselect_window (swindow
, Qnil
);
1396 FRAME_SELECTED_WINDOW (f
) = swindow
;
1401 /* tem is null for dummy parent windows
1402 (which have inferiors but not any contents themselves) */
1406 unchain_marker (XMARKER (p
->pointm
));
1407 unchain_marker (XMARKER (p
->start
));
1410 /* Free window glyph matrices. It is sure that they are allocated
1411 again when ADJUST_GLYPHS is called. Block input so that expose
1412 events and other events that access glyph matrices are not
1413 processed while we are changing them. */
1415 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1419 XWINDOW (tem
)->prev
= p
->prev
;
1423 XWINDOW (tem
)->next
= p
->next
;
1425 if (EQ (window
, par
->hchild
))
1426 par
->hchild
= p
->next
;
1427 if (EQ (window
, par
->vchild
))
1428 par
->vchild
= p
->next
;
1430 /* Find one of our siblings to give our space to. */
1434 /* If p gives its space to its next sibling, that sibling needs
1435 to have its top/left side pulled back to where p's is.
1436 set_window_{height,width} will re-position the sibling's
1439 XWINDOW (sib
)->top_line
= p
->top_line
;
1440 XWINDOW (sib
)->left_col
= p
->left_col
;
1443 /* Stretch that sibling. */
1444 if (!NILP (par
->vchild
))
1445 set_window_height (sib
,
1446 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1448 if (!NILP (par
->hchild
))
1449 set_window_width (sib
,
1450 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1453 /* If parent now has only one child,
1454 put the child into the parent's place. */
1458 if (NILP (XWINDOW (tem
)->next
)) {
1459 replace_window (parent
, tem
);
1460 par
= XWINDOW (tem
);
1463 /* Since we may be deleting combination windows, we must make sure that
1464 not only p but all its children have been marked as deleted. */
1465 if (! NILP (p
->hchild
))
1466 delete_all_subwindows (XWINDOW (p
->hchild
));
1467 else if (! NILP (p
->vchild
))
1468 delete_all_subwindows (XWINDOW (p
->vchild
));
1470 /* Mark this window as deleted. */
1471 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1473 if (! NILP (par
->parent
))
1474 par
= XWINDOW (par
->parent
);
1476 /* Check if we have a v/hchild with a v/hchild. In that case remove
1479 if (! NILP (par
->vchild
) && ! NILP (XWINDOW (par
->vchild
)->vchild
))
1481 p
= XWINDOW (par
->vchild
);
1482 par
->vchild
= p
->vchild
;
1485 else if (! NILP (par
->hchild
) && ! NILP (XWINDOW (par
->hchild
)->hchild
))
1487 p
= XWINDOW (par
->hchild
);
1488 par
->hchild
= p
->hchild
;
1496 while (! NILP (tem
)) {
1497 XWINDOW (tem
)->parent
= p
->parent
;
1498 if (NILP (XWINDOW (tem
)->next
))
1500 tem
= XWINDOW (tem
)->next
;
1503 /* The next of the v/hchild we are removing is now the next of the
1504 last child for the v/hchild:
1505 Before v/hchild -> v/hchild -> next1 -> next2
1508 After: v/hchild -> next1 -> next2 -> next3
1510 XWINDOW (tem
)->next
= p
->next
;
1511 if (! NILP (p
->next
))
1512 XWINDOW (p
->next
)->prev
= tem
;
1514 p
->next
= p
->prev
= p
->vchild
= p
->hchild
= p
->buffer
= Qnil
;
1518 /* Adjust glyph matrices. */
1525 /***********************************************************************
1527 ***********************************************************************/
1529 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1530 pointer. This is a callback function for foreach_window, used in
1531 function window_list. */
1534 add_window_to_list (w
, user_data
)
1538 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1540 XSETWINDOW (window
, w
);
1541 *list
= Fcons (window
, *list
);
1546 /* Return a list of all windows, for use by next_window. If
1547 Vwindow_list is a list, return that list. Otherwise, build a new
1548 list, cache it in Vwindow_list, and return that. */
1553 if (!CONSP (Vwindow_list
))
1557 Vwindow_list
= Qnil
;
1558 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1560 Lisp_Object args
[2];
1562 /* We are visiting windows in canonical order, and add
1563 new windows at the front of args[1], which means we
1564 have to reverse this list at the end. */
1566 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1567 args
[0] = Vwindow_list
;
1568 args
[1] = Fnreverse (args
[1]);
1569 Vwindow_list
= Fnconc (2, args
);
1573 return Vwindow_list
;
1577 /* Value is non-zero if WINDOW satisfies the constraints given by
1578 OWINDOW, MINIBUF and ALL_FRAMES.
1580 MINIBUF t means WINDOW may be minibuffer windows.
1581 `lambda' means WINDOW may not be a minibuffer window.
1582 a window means a specific minibuffer window
1584 ALL_FRAMES t means search all frames,
1585 nil means search just current frame,
1586 `visible' means search just visible frames,
1587 0 means search visible and iconified frames,
1588 a window means search the frame that window belongs to,
1589 a frame means consider windows on that frame, only. */
1592 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1593 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1595 struct window
*w
= XWINDOW (window
);
1596 struct frame
*f
= XFRAME (w
->frame
);
1597 int candidate_p
= 1;
1599 if (!BUFFERP (w
->buffer
))
1601 else if (MINI_WINDOW_P (w
)
1602 && (EQ (minibuf
, Qlambda
)
1603 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1605 /* If MINIBUF is `lambda' don't consider any mini-windows.
1606 If it is a window, consider only that one. */
1609 else if (EQ (all_frames
, Qt
))
1611 else if (NILP (all_frames
))
1613 xassert (WINDOWP (owindow
));
1614 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1616 else if (EQ (all_frames
, Qvisible
))
1618 FRAME_SAMPLE_VISIBILITY (f
);
1619 candidate_p
= FRAME_VISIBLE_P (f
);
1621 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1623 FRAME_SAMPLE_VISIBILITY (f
);
1624 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1626 else if (WINDOWP (all_frames
))
1627 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1628 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1629 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1630 else if (FRAMEP (all_frames
))
1631 candidate_p
= EQ (all_frames
, w
->frame
);
1637 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1638 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1642 decode_next_window_args (window
, minibuf
, all_frames
)
1643 Lisp_Object
*window
, *minibuf
, *all_frames
;
1646 *window
= selected_window
;
1648 CHECK_LIVE_WINDOW (*window
);
1650 /* MINIBUF nil may or may not include minibuffers. Decide if it
1652 if (NILP (*minibuf
))
1653 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1654 else if (!EQ (*minibuf
, Qt
))
1657 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1658 => count none of them, or a specific minibuffer window (the
1659 active one) to count. */
1661 /* ALL_FRAMES nil doesn't specify which frames to include. */
1662 if (NILP (*all_frames
))
1663 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1664 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1666 else if (EQ (*all_frames
, Qvisible
))
1668 else if (EQ (*all_frames
, make_number (0)))
1670 else if (FRAMEP (*all_frames
))
1672 else if (!EQ (*all_frames
, Qt
))
1675 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1676 search just current frame, `visible' meaning search just visible
1677 frames, 0 meaning search visible and iconified frames, or a
1678 window, meaning search the frame that window belongs to, or a
1679 frame, meaning consider windows on that frame, only. */
1683 /* Return the next or previous window of WINDOW in canonical ordering
1684 of windows. NEXT_P non-zero means return the next window. See the
1685 documentation string of next-window for the meaning of MINIBUF and
1689 next_window (window
, minibuf
, all_frames
, next_p
)
1690 Lisp_Object window
, minibuf
, all_frames
;
1693 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1695 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1696 return the first window on the frame. */
1697 if (FRAMEP (all_frames
)
1698 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1699 return Fframe_first_window (all_frames
);
1705 /* Find WINDOW in the list of all windows. */
1706 list
= Fmemq (window
, window_list ());
1708 /* Scan forward from WINDOW to the end of the window list. */
1710 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1711 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1714 /* Scan from the start of the window list up to WINDOW. */
1716 for (list
= Vwindow_list
;
1717 CONSP (list
) && !EQ (XCAR (list
), window
);
1719 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1723 window
= XCAR (list
);
1727 Lisp_Object candidate
, list
;
1729 /* Scan through the list of windows for candidates. If there are
1730 candidate windows in front of WINDOW, the last one of these
1731 is the one we want. If there are candidates following WINDOW
1732 in the list, again the last one of these is the one we want. */
1734 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1736 if (EQ (XCAR (list
), window
))
1738 if (WINDOWP (candidate
))
1741 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1743 candidate
= XCAR (list
);
1746 if (WINDOWP (candidate
))
1754 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1755 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1756 If omitted, WINDOW defaults to the selected window.
1758 Optional second arg MINIBUF t means count the minibuffer window even
1759 if not active. MINIBUF nil or omitted means count the minibuffer iff
1760 it is active. MINIBUF neither t nor nil means not to count the
1761 minibuffer even if it is active.
1763 Several frames may share a single minibuffer; if the minibuffer
1764 counts, all windows on all frames that share that minibuffer count
1765 too. Therefore, `next-window' can be used to iterate through the
1766 set of windows even when the minibuffer is on another frame. If the
1767 minibuffer does not count, only windows from WINDOW's frame count.
1769 Optional third arg ALL-FRAMES t means include windows on all frames.
1770 ALL-FRAMES nil or omitted means cycle within the frames as specified
1771 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1772 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1773 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1774 Anything else means restrict to WINDOW's frame.
1776 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1777 `next-window' to iterate through the entire cycle of acceptable
1778 windows, eventually ending up back at the window you started with.
1779 `previous-window' traverses the same cycle, in the reverse order. */)
1780 (window
, minibuf
, all_frames
)
1781 Lisp_Object window
, minibuf
, all_frames
;
1783 return next_window (window
, minibuf
, all_frames
, 1);
1787 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1788 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1789 If omitted, WINDOW defaults to the selected window.
1791 Optional second arg MINIBUF t means count the minibuffer window even
1792 if not active. MINIBUF nil or omitted means count the minibuffer iff
1793 it is active. MINIBUF neither t nor nil means not to count the
1794 minibuffer even if it is active.
1796 Several frames may share a single minibuffer; if the minibuffer
1797 counts, all windows on all frames that share that minibuffer count
1798 too. Therefore, `previous-window' can be used to iterate through
1799 the set of windows even when the minibuffer is on another frame. If
1800 the minibuffer does not count, only windows from WINDOW's frame count
1802 Optional third arg ALL-FRAMES t means include windows on all frames.
1803 ALL-FRAMES nil or omitted means cycle within the frames as specified
1804 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1805 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1806 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1807 Anything else means restrict to WINDOW's frame.
1809 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1810 `previous-window' to iterate through the entire cycle of acceptable
1811 windows, eventually ending up back at the window you started with.
1812 `next-window' traverses the same cycle, in the reverse order. */)
1813 (window
, minibuf
, all_frames
)
1814 Lisp_Object window
, minibuf
, all_frames
;
1816 return next_window (window
, minibuf
, all_frames
, 0);
1820 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1821 doc
: /* Select the ARG'th different window on this frame.
1822 All windows on current frame are arranged in a cyclic order.
1823 This command selects the window ARG steps away in that order.
1824 A negative ARG moves in the opposite order. The optional second
1825 argument ALL_FRAMES has the same meaning as in `next-window', which see. */)
1827 Lisp_Object arg
, all_frames
;
1833 window
= selected_window
;
1835 for (i
= XINT (arg
); i
> 0; --i
)
1836 window
= Fnext_window (window
, Qnil
, all_frames
);
1838 window
= Fprevious_window (window
, Qnil
, all_frames
);
1840 Fselect_window (window
, Qnil
);
1845 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1846 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1847 FRAME nil or omitted means use the selected frame.
1848 WINDOW nil or omitted means use the selected window.
1849 MINIBUF t means include the minibuffer window, even if it isn't active.
1850 MINIBUF nil or omitted means include the minibuffer window only
1852 MINIBUF neither nil nor t means never include the minibuffer window. */)
1853 (frame
, minibuf
, window
)
1854 Lisp_Object frame
, minibuf
, window
;
1857 window
= selected_window
;
1859 frame
= selected_frame
;
1861 if (!EQ (frame
, XWINDOW (window
)->frame
))
1862 error ("Window is on a different frame");
1864 return window_list_1 (window
, minibuf
, frame
);
1868 /* Return a list of windows in canonical ordering. Arguments are like
1869 for `next-window'. */
1872 window_list_1 (window
, minibuf
, all_frames
)
1873 Lisp_Object window
, minibuf
, all_frames
;
1875 Lisp_Object tail
, list
, rest
;
1877 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1880 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1881 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1882 list
= Fcons (XCAR (tail
), list
);
1884 /* Rotate the list to start with WINDOW. */
1885 list
= Fnreverse (list
);
1886 rest
= Fmemq (window
, list
);
1887 if (!NILP (rest
) && !EQ (rest
, list
))
1889 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1891 XSETCDR (tail
, Qnil
);
1892 list
= nconc2 (rest
, list
);
1899 /* Look at all windows, performing an operation specified by TYPE
1901 If FRAMES is Qt, look at all frames;
1902 Qnil, look at just the selected frame;
1903 Qvisible, look at visible frames;
1904 a frame, just look at windows on that frame.
1905 If MINI is non-zero, perform the operation on minibuffer windows too. */
1910 GET_BUFFER_WINDOW
, /* Arg is buffer */
1911 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1912 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1913 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1915 UNSHOW_BUFFER
, /* Arg is buffer */
1916 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1921 window_loop (type
, obj
, mini
, frames
)
1922 enum window_loop type
;
1923 Lisp_Object obj
, frames
;
1926 Lisp_Object window
, windows
, best_window
, frame_arg
;
1928 struct gcpro gcpro1
;
1930 /* If we're only looping through windows on a particular frame,
1931 frame points to that frame. If we're looping through windows
1932 on all frames, frame is 0. */
1933 if (FRAMEP (frames
))
1934 f
= XFRAME (frames
);
1935 else if (NILP (frames
))
1936 f
= SELECTED_FRAME ();
1941 frame_arg
= Qlambda
;
1942 else if (EQ (frames
, make_number (0)))
1944 else if (EQ (frames
, Qvisible
))
1949 /* frame_arg is Qlambda to stick to one frame,
1950 Qvisible to consider all visible frames,
1953 /* Pick a window to start with. */
1957 window
= FRAME_SELECTED_WINDOW (f
);
1959 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1961 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1965 for (; CONSP (windows
); windows
= CDR (windows
))
1969 window
= XCAR (windows
);
1970 w
= XWINDOW (window
);
1972 /* Note that we do not pay attention here to whether the frame
1973 is visible, since Fwindow_list skips non-visible frames if
1974 that is desired, under the control of frame_arg. */
1975 if (!MINI_WINDOW_P (w
)
1976 /* For UNSHOW_BUFFER, we must always consider all windows. */
1977 || type
== UNSHOW_BUFFER
1978 || (mini
&& minibuf_level
> 0))
1981 case GET_BUFFER_WINDOW
:
1982 if (EQ (w
->buffer
, obj
)
1983 /* Don't find any minibuffer window
1984 except the one that is currently in use. */
1985 && (MINI_WINDOW_P (w
)
1986 ? EQ (window
, minibuf_window
)
1989 if (NILP (best_window
))
1990 best_window
= window
;
1991 else if (EQ (window
, selected_window
))
1992 /* For compatibility with 20.x, prefer to return
1994 best_window
= window
;
1998 case GET_LRU_WINDOW
:
1999 /* t as arg means consider only full-width windows */
2000 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
2002 /* Ignore dedicated windows and minibuffers. */
2003 if (MINI_WINDOW_P (w
) || (!mini
&& EQ (w
->dedicated
, Qt
)))
2005 if (NILP (best_window
)
2006 || (XFASTINT (XWINDOW (best_window
)->use_time
)
2007 > XFASTINT (w
->use_time
)))
2008 best_window
= window
;
2011 case DELETE_OTHER_WINDOWS
:
2012 if (!EQ (window
, obj
))
2013 Fdelete_window (window
);
2016 case DELETE_BUFFER_WINDOWS
:
2017 if (EQ (w
->buffer
, obj
))
2019 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2021 /* If this window is dedicated, and in a frame of its own,
2023 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2024 && !NILP (w
->dedicated
)
2025 && other_visible_frames (f
))
2027 /* Skip the other windows on this frame.
2028 There might be one, the minibuffer! */
2029 while (CONSP (XCDR (windows
))
2030 && EQ (XWINDOW (XCAR (windows
))->frame
,
2031 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2032 windows
= XCDR (windows
);
2034 /* Now we can safely delete the frame. */
2035 Fdelete_frame (w
->frame
, Qnil
);
2037 else if (NILP (w
->parent
))
2039 /* If we're deleting the buffer displayed in the
2040 only window on the frame, find a new buffer to
2043 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2044 Fset_window_buffer (window
, buffer
, Qnil
);
2045 if (EQ (window
, selected_window
))
2046 Fset_buffer (w
->buffer
);
2049 Fdelete_window (window
);
2053 case GET_LARGEST_WINDOW
:
2055 /* Ignore dedicated windows and minibuffers. */
2056 if (MINI_WINDOW_P (w
) || (!mini
&& EQ (w
->dedicated
, Qt
)))
2059 if (NILP (best_window
))
2060 best_window
= window
;
2063 struct window
*b
= XWINDOW (best_window
);
2064 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2065 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2066 best_window
= window
;
2072 if (EQ (w
->buffer
, obj
))
2075 struct frame
*f
= XFRAME (w
->frame
);
2077 /* Find another buffer to show in this window. */
2078 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2080 /* If this window is dedicated, and in a frame of its own,
2082 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2083 && !NILP (w
->dedicated
)
2084 && other_visible_frames (f
))
2086 /* Skip the other windows on this frame.
2087 There might be one, the minibuffer! */
2088 while (CONSP (XCDR (windows
))
2089 && EQ (XWINDOW (XCAR (windows
))->frame
,
2090 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2091 windows
= XCDR (windows
);
2093 /* Now we can safely delete the frame. */
2094 Fdelete_frame (w
->frame
, Qnil
);
2096 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2099 XSETWINDOW (window
, w
);
2100 /* If this window is dedicated and not the only window
2101 in its frame, then kill it. */
2102 Fdelete_window (window
);
2106 /* Otherwise show a different buffer in the window. */
2107 w
->dedicated
= Qnil
;
2108 Fset_window_buffer (window
, buffer
, Qnil
);
2109 if (EQ (window
, selected_window
))
2110 Fset_buffer (w
->buffer
);
2115 case REDISPLAY_BUFFER_WINDOWS
:
2116 if (EQ (w
->buffer
, obj
))
2118 mark_window_display_accurate (window
, 0);
2119 w
->update_mode_line
= Qt
;
2120 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2121 ++update_mode_lines
;
2122 best_window
= window
;
2126 /* Check for a window that has a killed buffer. */
2127 case CHECK_ALL_WINDOWS
:
2128 if (! NILP (w
->buffer
)
2129 && NILP (XBUFFER (w
->buffer
)->name
))
2133 case WINDOW_LOOP_UNUSED
:
2142 /* Used for debugging. Abort if any window has a dead buffer. */
2145 check_all_windows ()
2147 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2150 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 2, 0,
2151 doc
: /* Return the window least recently selected or used for display.
2152 Return a full-width window if possible.
2153 A minibuffer window is never a candidate.
2154 A dedicated window is never a candidate, unless DEDICATED is non-nil,
2155 so if all windows are dedicated, the value is nil.
2156 If optional argument FRAME is `visible', search all visible frames.
2157 If FRAME is 0, search all visible and iconified frames.
2158 If FRAME is t, search all frames.
2159 If FRAME is nil, search only the selected frame.
2160 If FRAME is a frame, search only that frame. */)
2162 Lisp_Object frame
, dedicated
;
2164 register Lisp_Object w
;
2165 /* First try for a window that is full-width */
2166 w
= window_loop (GET_LRU_WINDOW
, Qt
, !NILP (dedicated
), frame
);
2167 if (!NILP (w
) && !EQ (w
, selected_window
))
2169 /* If none of them, try the rest */
2170 return window_loop (GET_LRU_WINDOW
, Qnil
, !NILP (dedicated
), frame
);
2173 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 2, 0,
2174 doc
: /* Return the largest window in area.
2175 A minibuffer window is never a candidate.
2176 A dedicated window is never a candidate unless DEDICATED is non-nil,
2177 so if all windows are dedicated, the value is nil.
2178 If optional argument FRAME is `visible', search all visible frames.
2179 If FRAME is 0, search all visible and iconified frames.
2180 If FRAME is t, search all frames.
2181 If FRAME is nil, search only the selected frame.
2182 If FRAME is a frame, search only that frame. */)
2184 Lisp_Object frame
, dedicated
;
2186 return window_loop (GET_LARGEST_WINDOW
, Qnil
, !NILP (dedicated
),
2190 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2191 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2192 BUFFER can be a buffer or a buffer name.
2193 If optional argument FRAME is `visible', search all visible frames.
2194 If optional argument 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 buffer
, frame
;
2201 buffer
= Fget_buffer (buffer
);
2202 if (BUFFERP (buffer
))
2203 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2208 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2210 doc
: /* Make WINDOW (or the selected window) fill its frame.
2211 Only the frame WINDOW is on is affected.
2212 This function tries to reduce display jumps
2213 by keeping the text previously visible in WINDOW
2214 in the same place on the frame. Doing this depends on
2215 the value of (window-start WINDOW), so if calling this function
2216 in a program gives strange scrolling, make sure the window-start
2217 value is reasonable when this function is called. */)
2226 window
= selected_window
;
2228 CHECK_LIVE_WINDOW (window
);
2229 w
= XWINDOW (window
);
2231 startpos
= marker_position (w
->start
);
2232 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2234 if (MINI_WINDOW_P (w
) && top
> 0)
2235 error ("Can't expand minibuffer to full frame");
2237 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2239 /* Try to minimize scrolling, by setting the window start to the point
2240 will cause the text at the old window start to be at the same place
2241 on the frame. But don't try to do this if the window start is
2242 outside the visible portion (as might happen when the display is
2243 not current, due to typeahead). */
2244 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2246 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2247 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2249 struct position pos
;
2250 struct buffer
*obuf
= current_buffer
;
2252 Fset_buffer (w
->buffer
);
2253 /* This computation used to temporarily move point, but that can
2254 have unwanted side effects due to text properties. */
2255 pos
= *vmotion (startpos
, -top
, w
);
2257 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2258 w
->window_end_valid
= Qnil
;
2259 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2260 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2262 /* We need to do this, so that the window-scroll-functions
2264 w
->optional_new_start
= Qt
;
2266 set_buffer_internal (obuf
);
2272 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2273 1, 2, "bDelete windows on (buffer): ",
2274 doc
: /* Delete all windows showing BUFFER.
2275 BUFFER must be a buffer or the name of an existing buffer.
2276 Optional second argument FRAME controls which frames are affected.
2277 If optional argument FRAME is `visible', search all visible frames.
2278 If FRAME is 0, search all visible and iconified frames.
2279 If FRAME is nil, search all frames.
2280 If FRAME is t, search only the selected frame.
2281 If FRAME is a frame, search only that frame. */)
2283 Lisp_Object buffer
, frame
;
2285 /* FRAME uses t and nil to mean the opposite of what window_loop
2289 else if (EQ (frame
, Qt
))
2294 buffer
= Fget_buffer (buffer
);
2295 CHECK_BUFFER (buffer
);
2296 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2302 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2303 Sreplace_buffer_in_windows
,
2304 1, 1, "bReplace buffer in windows: ",
2305 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2306 BUFFER may be a buffer or the name of an existing buffer. */)
2312 buffer
= Fget_buffer (buffer
);
2313 CHECK_BUFFER (buffer
);
2314 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2319 /* Replace BUFFER with some other buffer in all windows
2320 of all frames, even those on other keyboards. */
2323 replace_buffer_in_all_windows (buffer
)
2327 Lisp_Object tail
, frame
;
2329 /* A single call to window_loop won't do the job
2330 because it only considers frames on the current keyboard.
2331 So loop manually over frames, and handle each one. */
2332 FOR_EACH_FRAME (tail
, frame
)
2333 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2335 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2339 /* Set the height of WINDOW and all its inferiors. */
2341 /* The smallest acceptable dimensions for a window. Anything smaller
2342 might crash Emacs. */
2344 #define MIN_SAFE_WINDOW_WIDTH (2)
2345 #define MIN_SAFE_WINDOW_HEIGHT (1)
2347 /* Make sure that window_min_height and window_min_width are
2348 not too small; if they are, set them to safe minima. */
2351 check_min_window_sizes ()
2353 /* Smaller values might permit a crash. */
2354 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2355 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2356 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2357 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2360 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2361 minimum allowable size. */
2364 check_frame_size (frame
, rows
, cols
)
2368 /* For height, we have to see:
2369 how many windows the frame has at minimum (one or two),
2370 and whether it has a menu bar or other special stuff at the top. */
2372 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2373 ? MIN_SAFE_WINDOW_HEIGHT
2374 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2376 if (FRAME_TOP_MARGIN (frame
) > 0)
2377 min_height
+= FRAME_TOP_MARGIN (frame
);
2379 if (*rows
< min_height
)
2381 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2382 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2386 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2387 check if W's width can be changed, otherwise check W's height.
2388 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2389 siblings, too. If none of the siblings is resizable, WINDOW isn't
2393 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2395 int width_p
, check_siblings_p
;
2400 if (!NILP (w
->hchild
))
2402 c
= XWINDOW (w
->hchild
);
2406 /* A horiz. combination is fixed-width if all of if its
2408 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2409 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2410 fixed_p
= c
== NULL
;
2414 /* A horiz. combination is fixed-height if one of if its
2416 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2417 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2418 fixed_p
= c
!= NULL
;
2421 else if (!NILP (w
->vchild
))
2423 c
= XWINDOW (w
->vchild
);
2427 /* A vert. combination is fixed-width if one of if its
2429 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2430 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2431 fixed_p
= c
!= NULL
;
2435 /* A vert. combination is fixed-height if all of if its
2437 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2438 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2439 fixed_p
= c
== NULL
;
2442 else if (BUFFERP (w
->buffer
))
2444 struct buffer
*old
= current_buffer
;
2447 current_buffer
= XBUFFER (w
->buffer
);
2448 val
= find_symbol_value (Qwindow_size_fixed
);
2449 current_buffer
= old
;
2452 if (!EQ (val
, Qunbound
))
2454 fixed_p
= !NILP (val
);
2457 && ((EQ (val
, Qheight
) && width_p
)
2458 || (EQ (val
, Qwidth
) && !width_p
)))
2462 /* Can't tell if this one is resizable without looking at
2463 siblings. If all siblings are fixed-size this one is too. */
2464 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2468 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2469 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2473 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2474 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2488 /* Return the minimum size of window W, not taking fixed-width windows
2489 into account. WIDTH_P non-zero means return the minimum width,
2490 otherwise return the minimum height. If W is a combination window,
2491 compute the minimum size from the minimum sizes of W's children. */
2494 window_min_size_1 (w
, width_p
)
2501 if (!NILP (w
->hchild
))
2503 c
= XWINDOW (w
->hchild
);
2508 /* The min width of a horizontal combination is
2509 the sum of the min widths of its children. */
2512 size
+= window_min_size_1 (c
, width_p
);
2513 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2518 /* The min height a horizontal combination equals
2519 the maximum of all min height of its children. */
2522 int min_size
= window_min_size_1 (c
, width_p
);
2523 size
= max (min_size
, size
);
2524 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2528 else if (!NILP (w
->vchild
))
2530 c
= XWINDOW (w
->vchild
);
2535 /* The min width of a vertical combination is
2536 the maximum of the min widths of its children. */
2539 int min_size
= window_min_size_1 (c
, width_p
);
2540 size
= max (min_size
, size
);
2541 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2546 /* The min height of a vertical combination equals
2547 the sum of the min height of its children. */
2550 size
+= window_min_size_1 (c
, width_p
);
2551 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2558 size
= window_min_width
;
2561 if (MINI_WINDOW_P (w
)
2562 || (!WINDOW_WANTS_MODELINE_P (w
)
2563 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2566 size
= window_min_height
;
2574 /* Return the minimum size of window W, taking fixed-size windows into
2575 account. WIDTH_P non-zero means return the minimum width,
2576 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2577 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2578 unless FIXED is null. */
2581 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2583 int width_p
, ignore_fixed_p
, *fixed
;
2590 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2596 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2598 size
= window_min_size_1 (w
, width_p
);
2604 /* Adjust the margins of window W if text area is too small.
2605 Return 1 if window width is ok after adjustment; 0 if window
2606 is still too narrow. */
2609 adjust_window_margins (w
)
2612 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2613 - WINDOW_FRINGE_COLS (w
)
2614 - WINDOW_SCROLL_BAR_COLS (w
));
2615 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2616 + WINDOW_RIGHT_MARGIN_COLS (w
));
2618 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2621 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2624 /* Window's text area is too narrow, but reducing the window
2625 margins will fix that. */
2626 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2627 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2629 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2630 w
->left_margin_cols
= w
->right_margin_cols
2631 = make_number (margin_cols
/2);
2633 w
->right_margin_cols
= make_number (margin_cols
);
2636 w
->left_margin_cols
= make_number (margin_cols
);
2640 /* Calculate new sizes for windows in the list FORWARD when the window size
2641 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2642 The number of windows in FORWARD is NCHILDREN, and the number that
2643 can shrink is SHRINKABLE.
2644 The minimum size a window can have is MIN_SIZE.
2645 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2646 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2649 This function returns an allocated array of new sizes that the caller
2650 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2651 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2652 the second, and so on.
2654 This function tries to keep windows at least at the minimum size
2655 and resize other windows before it resizes any window to zero (i.e.
2656 delete that window).
2658 Windows are resized proportional to their size, so bigger windows
2659 shrink more than smaller windows. */
2661 shrink_windows (total
, size
, nchildren
, shrinkable
,
2662 min_size
, resize_fixed_p
, forward
, width_p
)
2663 int total
, size
, nchildren
, shrinkable
, min_size
;
2664 int resize_fixed_p
, width_p
;
2665 Lisp_Object forward
;
2667 int available_resize
= 0;
2671 int smallest
= total
;
2672 int total_removed
= 0;
2673 int total_shrink
= total
- size
;
2676 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2678 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2682 c
= XWINDOW (child
);
2683 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2685 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2689 new_sizes
[i
] = child_size
;
2690 if (child_size
> min_size
)
2691 available_resize
+= child_size
- min_size
;
2694 /* We might need to shrink some windows to zero. Find the smallest
2695 windows and set them to 0 until we can fulfil the new size. */
2697 while (shrinkable
> 1 && size
+ available_resize
< total
)
2699 for (i
= 0; i
< nchildren
; ++i
)
2700 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2701 smallest
= new_sizes
[i
];
2703 for (i
= 0; i
< nchildren
; ++i
)
2704 if (new_sizes
[i
] == smallest
)
2706 /* Resize this window down to zero. */
2708 if (smallest
> min_size
)
2709 available_resize
-= smallest
- min_size
;
2710 available_resize
+= smallest
;
2712 total_removed
+= smallest
;
2714 /* We don't know what the smallest is now. */
2717 /* Out of for, just remove one window at the time and
2718 check again if we have enough space. */
2723 /* Now, calculate the new sizes. Try to shrink each window
2724 proportional to its size. */
2725 for (i
= 0; i
< nchildren
; ++i
)
2727 if (new_sizes
[i
] > min_size
)
2729 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2730 if (new_sizes
[i
] - to_shrink
< min_size
)
2731 to_shrink
= new_sizes
[i
] - min_size
;
2732 new_sizes
[i
] -= to_shrink
;
2733 total_removed
+= to_shrink
;
2737 /* Any reminder due to rounding, we just subtract from windows
2738 that are left and still can be shrunk. */
2739 while (total_shrink
> total_removed
)
2741 int nonzero_sizes
= 0;
2742 int nonzero_idx
= -1;
2744 for (i
= 0; i
< nchildren
; ++i
)
2745 if (new_sizes
[i
] > 0)
2751 for (i
= 0; i
< nchildren
; ++i
)
2752 if (new_sizes
[i
] > min_size
)
2757 /* Out of for, just shrink one window at the time and
2758 check again if we have enough space. */
2763 /* Special case, only one window left. */
2764 if (nonzero_sizes
== 1)
2768 /* Any surplus due to rounding, we add to windows that are left. */
2769 while (total_shrink
< total_removed
)
2771 for (i
= 0; i
< nchildren
; ++i
)
2773 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2785 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2786 WINDOW's width. Resize WINDOW's children, if any, so that they
2787 keep their proportionate size relative to WINDOW. Propagate
2788 WINDOW's top or left edge position to children. Delete windows
2789 that become too small unless NODELETE_P is non-zero.
2791 If NODELETE_P is 2, that means we do delete windows that are
2792 too small, even if they were too small before! */
2795 size_window (window
, size
, width_p
, nodelete_p
)
2797 int size
, width_p
, nodelete_p
;
2799 struct window
*w
= XWINDOW (window
);
2801 Lisp_Object child
, *forward
, *sideward
;
2802 int old_size
, min_size
, safe_min_size
;
2804 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2805 seems like it's too soon to do this here. ++KFS. */
2806 if (nodelete_p
== 2)
2809 check_min_window_sizes ();
2810 size
= max (0, size
);
2812 /* If the window has been "too small" at one point,
2813 don't delete it for being "too small" in the future.
2814 Preserve it as long as that is at all possible. */
2817 old_size
= WINDOW_TOTAL_COLS (w
);
2818 min_size
= window_min_width
;
2819 /* Ensure that there is room for the scroll bar and fringes!
2820 We may reduce display margins though. */
2821 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2822 + WINDOW_FRINGE_COLS (w
)
2823 + WINDOW_SCROLL_BAR_COLS (w
));
2827 old_size
= XINT (w
->total_lines
);
2828 min_size
= window_min_height
;
2829 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2832 if (old_size
< min_size
&& nodelete_p
!= 2)
2833 w
->too_small_ok
= Qt
;
2835 /* Maybe delete WINDOW if it's too small. */
2836 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2838 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2839 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2840 if (min_size
< safe_min_size
)
2841 min_size
= safe_min_size
;
2842 if (size
< min_size
)
2844 delete_window (window
);
2849 /* Set redisplay hints. */
2850 w
->last_modified
= make_number (0);
2851 w
->last_overlay_modified
= make_number (0);
2852 windows_or_buffers_changed
++;
2853 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2857 sideward
= &w
->vchild
;
2858 forward
= &w
->hchild
;
2859 w
->total_cols
= make_number (size
);
2860 adjust_window_margins (w
);
2864 sideward
= &w
->hchild
;
2865 forward
= &w
->vchild
;
2866 w
->total_lines
= make_number (size
);
2867 w
->orig_total_lines
= Qnil
;
2870 if (!NILP (*sideward
))
2872 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2874 c
= XWINDOW (child
);
2876 c
->left_col
= w
->left_col
;
2878 c
->top_line
= w
->top_line
;
2879 size_window (child
, size
, width_p
, nodelete_p
);
2882 else if (!NILP (*forward
))
2884 int fixed_size
, each
, extra
, n
;
2885 int resize_fixed_p
, nfixed
;
2886 int last_pos
, first_pos
, nchildren
, total
;
2887 int *new_sizes
= NULL
;
2889 /* Determine the fixed-size portion of the this window, and the
2890 number of child windows. */
2891 fixed_size
= nchildren
= nfixed
= total
= 0;
2892 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2896 c
= XWINDOW (child
);
2897 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2898 total
+= child_size
;
2900 if (window_fixed_size_p (c
, width_p
, 0))
2902 fixed_size
+= child_size
;
2907 /* If the new size is smaller than fixed_size, or if there
2908 aren't any resizable windows, allow resizing fixed-size
2910 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2912 /* Compute how many lines/columns to add/remove to each child. The
2913 value of extra takes care of rounding errors. */
2914 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2915 if (size
< total
&& n
> 1)
2916 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2917 resize_fixed_p
, *forward
, width_p
);
2920 each
= (size
- total
) / n
;
2921 extra
= (size
- total
) - n
* each
;
2924 /* Compute new children heights and edge positions. */
2925 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2926 last_pos
= first_pos
;
2927 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2929 int new_size
, old_size
;
2931 c
= XWINDOW (child
);
2932 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2933 new_size
= old_size
;
2935 /* The top or left edge position of this child equals the
2936 bottom or right edge of its predecessor. */
2938 c
->left_col
= make_number (last_pos
);
2940 c
->top_line
= make_number (last_pos
);
2942 /* If this child can be resized, do it. */
2943 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2945 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2949 /* Set new height. Note that size_window also propagates
2950 edge positions to children, so it's not a no-op if we
2951 didn't change the child's size. */
2952 size_window (child
, new_size
, width_p
, 1);
2954 /* Remember the bottom/right edge position of this child; it
2955 will be used to set the top/left edge of the next child. */
2956 last_pos
+= new_size
;
2959 if (new_sizes
) xfree (new_sizes
);
2961 /* We should have covered the parent exactly with child windows. */
2962 xassert (size
== last_pos
- first_pos
);
2964 /* Now delete any children that became too small. */
2966 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2969 c
= XWINDOW (child
);
2970 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2971 size_window (child
, child_size
, width_p
, 2);
2976 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2977 WINDOW's children. NODELETE non-zero means don't delete windows
2978 that become too small in the process. (The caller should check
2979 later and do so if appropriate.) */
2982 set_window_height (window
, height
, nodelete
)
2987 size_window (window
, height
, 0, nodelete
);
2991 /* Set WINDOW's width to WIDTH, and recursively change the width of
2992 WINDOW's children. NODELETE non-zero means don't delete windows
2993 that become too small in the process. (The caller should check
2994 later and do so if appropriate.) */
2997 set_window_width (window
, width
, nodelete
)
3002 size_window (window
, width
, 1, nodelete
);
3005 /* Change window heights in windows rooted in WINDOW by N lines. */
3008 change_window_heights (window
, n
)
3012 struct window
*w
= XWINDOW (window
);
3014 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
3015 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
3017 if (INTEGERP (w
->orig_top_line
))
3018 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
3019 if (INTEGERP (w
->orig_total_lines
))
3020 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
3022 /* Handle just the top child in a vertical split. */
3023 if (!NILP (w
->vchild
))
3024 change_window_heights (w
->vchild
, n
);
3026 /* Adjust all children in a horizontal split. */
3027 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
3029 w
= XWINDOW (window
);
3030 change_window_heights (window
, n
);
3035 int window_select_count
;
3038 Fset_window_buffer_unwind (obuf
)
3045 EXFUN (Fset_window_fringes
, 4);
3046 EXFUN (Fset_window_scroll_bars
, 4);
3048 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3049 means it's allowed to run hooks. See make_frame for a case where
3050 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3051 margins, fringes, and scroll-bar settings of the window are not
3052 reset from the buffer's local settings. */
3055 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3056 Lisp_Object window
, buffer
;
3057 int run_hooks_p
, keep_margins_p
;
3059 struct window
*w
= XWINDOW (window
);
3060 struct buffer
*b
= XBUFFER (buffer
);
3061 int count
= SPECPDL_INDEX ();
3065 if (EQ (window
, selected_window
))
3066 b
->last_selected_window
= window
;
3068 /* Let redisplay errors through. */
3069 b
->display_error_modiff
= 0;
3071 /* Update time stamps of buffer display. */
3072 if (INTEGERP (b
->display_count
))
3073 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3074 b
->display_time
= Fcurrent_time ();
3076 XSETFASTINT (w
->window_end_pos
, 0);
3077 XSETFASTINT (w
->window_end_vpos
, 0);
3078 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3079 w
->window_end_valid
= Qnil
;
3080 w
->hscroll
= w
->min_hscroll
= make_number (0);
3082 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3083 set_marker_restricted (w
->start
,
3084 make_number (b
->last_window_start
),
3086 w
->start_at_line_beg
= Qnil
;
3087 w
->force_start
= Qnil
;
3088 XSETFASTINT (w
->last_modified
, 0);
3089 XSETFASTINT (w
->last_overlay_modified
, 0);
3090 windows_or_buffers_changed
++;
3092 /* We must select BUFFER for running the window-scroll-functions.
3093 If WINDOW is selected, switch permanently.
3094 Otherwise, switch but go back to the ambient buffer afterward. */
3095 if (EQ (window
, selected_window
))
3096 Fset_buffer (buffer
);
3097 /* We can't check ! NILP (Vwindow_scroll_functions) here
3098 because that might itself be a local variable. */
3099 else if (window_initialized
)
3101 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3102 Fset_buffer (buffer
);
3105 if (!keep_margins_p
)
3107 /* Set left and right marginal area width etc. from buffer. */
3109 /* This may call adjust_window_margins three times, so
3110 temporarily disable window margins. */
3111 Lisp_Object save_left
= w
->left_margin_cols
;
3112 Lisp_Object save_right
= w
->right_margin_cols
;
3114 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3116 Fset_window_fringes (window
,
3117 b
->left_fringe_width
, b
->right_fringe_width
,
3118 b
->fringes_outside_margins
);
3120 Fset_window_scroll_bars (window
,
3121 b
->scroll_bar_width
,
3122 b
->vertical_scroll_bar_type
, Qnil
);
3124 w
->left_margin_cols
= save_left
;
3125 w
->right_margin_cols
= save_right
;
3127 Fset_window_margins (window
,
3128 b
->left_margin_cols
, b
->right_margin_cols
);
3133 if (! NILP (Vwindow_scroll_functions
))
3134 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3135 Fmarker_position (w
->start
));
3137 if (! NILP (Vwindow_configuration_change_hook
)
3138 && ! NILP (Vrun_hooks
))
3139 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3142 unbind_to (count
, Qnil
);
3146 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3147 doc
: /* Make WINDOW display BUFFER as its contents.
3148 BUFFER can be a buffer or the name of an existing buffer.
3149 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3150 display margins, fringe widths, and scroll bar settings are maintained;
3151 the default is to reset these from BUFFER's local settings or the frame
3154 This function runs the hook `window-scroll-functions'. */)
3155 (window
, buffer
, keep_margins
)
3156 register Lisp_Object window
, buffer
, keep_margins
;
3158 register Lisp_Object tem
;
3159 register struct window
*w
= decode_window (window
);
3161 XSETWINDOW (window
, w
);
3162 buffer
= Fget_buffer (buffer
);
3163 CHECK_BUFFER (buffer
);
3165 if (NILP (XBUFFER (buffer
)->name
))
3166 error ("Attempt to display deleted buffer");
3170 error ("Window is deleted");
3171 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3172 is first being set up. */
3174 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3175 error ("Window is dedicated to `%s'",
3176 SDATA (XBUFFER (tem
)->name
));
3181 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3185 /* Note that selected_window can be nil
3186 when this is called from Fset_window_configuration. */
3188 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3189 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3190 If WINDOW is not already selected, make WINDOW's buffer current
3191 and make WINDOW the frame's selected window. Return WINDOW.
3192 Optional second arg NORECORD non-nil means
3193 do not put this buffer at the front of the list of recently selected ones.
3195 Note that the main editor command loop
3196 selects the buffer of the selected window before each command. */)
3198 register Lisp_Object window
, norecord
;
3200 register struct window
*w
;
3201 register struct window
*ow
;
3204 CHECK_LIVE_WINDOW (window
);
3206 w
= XWINDOW (window
);
3207 w
->frozen_window_start_p
= 0;
3209 ++window_select_count
;
3210 XSETFASTINT (w
->use_time
, window_select_count
);
3211 if (EQ (window
, selected_window
))
3214 /* Store the current buffer's actual point into the
3215 old selected window. It belongs to that window,
3216 and when the window is not selected, must be in the window. */
3217 if (!NILP (selected_window
))
3219 ow
= XWINDOW (selected_window
);
3220 if (! NILP (ow
->buffer
))
3221 set_marker_both (ow
->pointm
, ow
->buffer
,
3222 BUF_PT (XBUFFER (ow
->buffer
)),
3223 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3226 selected_window
= window
;
3227 sf
= SELECTED_FRAME ();
3228 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3230 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3231 /* Use this rather than Fhandle_switch_frame
3232 so that FRAME_FOCUS_FRAME is moved appropriately as we
3233 move around in the state where a minibuffer in a separate
3235 Fselect_frame (WINDOW_FRAME (w
));
3238 sf
->selected_window
= window
;
3240 if (NILP (norecord
))
3241 record_buffer (w
->buffer
);
3242 Fset_buffer (w
->buffer
);
3244 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3246 /* Go to the point recorded in the window.
3247 This is important when the buffer is in more
3248 than one window. It also matters when
3249 redisplay_window has altered point after scrolling,
3250 because it makes the change only in the window. */
3252 register int new_point
= marker_position (w
->pointm
);
3253 if (new_point
< BEGV
)
3255 else if (new_point
> ZV
)
3261 windows_or_buffers_changed
++;
3266 select_window_norecord (window
)
3269 return Fselect_window (window
, Qt
);
3272 /* Deiconify the frame containing the window WINDOW,
3273 unless it is the selected frame;
3276 The reason for the exception for the selected frame
3277 is that it seems better not to change the selected frames visibility
3278 merely because of displaying a different buffer in it.
3279 The deiconification is useful when a buffer gets shown in
3280 another frame that you were not using lately. */
3283 display_buffer_1 (window
)
3286 Lisp_Object frame
= XWINDOW (window
)->frame
;
3287 FRAME_PTR f
= XFRAME (frame
);
3289 FRAME_SAMPLE_VISIBILITY (f
);
3291 if (EQ (frame
, selected_frame
))
3292 ; /* Assume the selected frame is already visible enough. */
3293 else if (minibuf_level
> 0
3294 && MINI_WINDOW_P (XWINDOW (selected_window
))
3295 && WINDOW_LIVE_P (minibuf_selected_window
)
3296 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3297 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3300 if (FRAME_ICONIFIED_P (f
))
3301 Fmake_frame_visible (frame
);
3302 else if (FRAME_VISIBLE_P (f
))
3303 Fraise_frame (frame
);
3309 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3310 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3311 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3312 special frame for that buffer using the default frame parameters.
3314 If the value is a list, it is a list of frame parameters that would be used
3315 to make a frame for that buffer.
3316 The variables `special-display-buffer-names'
3317 and `special-display-regexps' control this. */)
3319 Lisp_Object buffer_name
;
3323 CHECK_STRING (buffer_name
);
3325 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3329 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3333 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3335 Lisp_Object car
= XCAR (tem
);
3337 && fast_string_match (car
, buffer_name
) >= 0)
3339 else if (CONSP (car
)
3340 && STRINGP (XCAR (car
))
3341 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3347 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3348 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3349 More precisely, if `display-buffer' or `pop-to-buffer' would display
3350 that buffer in the selected window rather than (as usual) in some other window.
3351 See `same-window-buffer-names' and `same-window-regexps'. */)
3353 Lisp_Object buffer_name
;
3357 CHECK_STRING (buffer_name
);
3359 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3363 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3367 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3369 Lisp_Object car
= XCAR (tem
);
3371 && fast_string_match (car
, buffer_name
) >= 0)
3373 else if (CONSP (car
)
3374 && STRINGP (XCAR (car
))
3375 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3381 /* Use B so the default is (other-buffer). */
3382 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3383 "BDisplay buffer: \nP",
3384 doc
: /* Make BUFFER appear in some window but don't select it.
3385 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3387 If BUFFER is shown already in some window, just use that one,
3388 unless the window is the selected window and the optional second
3389 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3390 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3391 Returns the window displaying BUFFER.
3392 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3393 displaying BUFFER, then simply raise that frame.
3395 The variables `special-display-buffer-names',
3396 `special-display-regexps', `same-window-buffer-names', and
3397 `same-window-regexps' customize how certain buffer names are handled.
3398 The latter two take effect only if NOT-THIS-WINDOW is t.
3400 If optional argument FRAME is `visible', search all visible frames.
3401 If FRAME is 0, search all visible and iconified frames.
3402 If FRAME is t, search all frames.
3403 If FRAME is a frame, search only that frame.
3404 If FRAME is nil, search only the selected frame
3405 (actually the last nonminibuffer frame),
3406 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3407 which means search visible and iconified frames.
3409 If a full-width window on a splittable frame is available to display
3410 the buffer, it may be split, subject to the value of the variable
3411 `split-height-threshold'.
3413 If `even-window-heights' is non-nil, window heights will be evened out
3414 if displaying the buffer causes two vertically adjacent windows to be
3416 (buffer
, not_this_window
, frame
)
3417 register Lisp_Object buffer
, not_this_window
, frame
;
3419 register Lisp_Object window
, tem
, swp
;
3423 buffer
= Fget_buffer (buffer
);
3424 CHECK_BUFFER (buffer
);
3426 if (!NILP (Vdisplay_buffer_function
))
3427 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3429 if (NILP (not_this_window
)
3430 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3431 return display_buffer_1 (selected_window
);
3433 /* See if the user has specified this buffer should appear
3434 in the selected window. */
3435 if (NILP (not_this_window
))
3437 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3438 if (!NILP (swp
) && !no_switch_window (selected_window
))
3440 Fswitch_to_buffer (buffer
, Qnil
);
3441 return display_buffer_1 (selected_window
);
3445 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3446 look for a window showing BUFFER on any visible or iconified frame.
3447 Otherwise search only the current frame. */
3450 else if (pop_up_frames
3451 || display_buffer_reuse_frames
3452 || last_nonminibuf_frame
== 0)
3453 XSETFASTINT (tem
, 0);
3455 XSETFRAME (tem
, last_nonminibuf_frame
);
3457 window
= Fget_buffer_window (buffer
, tem
);
3459 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3460 return display_buffer_1 (window
);
3462 /* Certain buffer names get special handling. */
3463 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3465 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3467 return call1 (Vspecial_display_function
, buffer
);
3469 return call2 (Vspecial_display_function
, buffer
, tem
);
3472 /* If there are no frames open that have more than a minibuffer,
3473 we need to create a new frame. */
3474 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3476 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3477 Fset_window_buffer (window
, buffer
, Qnil
);
3478 return display_buffer_1 (window
);
3481 f
= SELECTED_FRAME ();
3483 || FRAME_MINIBUF_ONLY_P (f
)
3484 /* If the current frame is a special display frame,
3485 don't try to reuse its windows. */
3486 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3491 if (FRAME_MINIBUF_ONLY_P (f
))
3492 XSETFRAME (frames
, last_nonminibuf_frame
);
3493 /* Don't try to create a window if we would get an error. */
3494 if (split_height_threshold
< window_min_height
<< 1)
3495 split_height_threshold
= window_min_height
<< 1;
3497 /* Note that both Fget_largest_window and Fget_lru_window
3498 ignore minibuffers and dedicated windows.
3499 This means they can return nil. */
3501 /* If the frame we would try to split cannot be split,
3502 try other frames. */
3503 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3505 /* Try visible frames first. */
3506 window
= Fget_largest_window (Qvisible
, Qt
);
3507 /* If that didn't work, try iconified frames. */
3509 window
= Fget_largest_window (make_number (0), Qt
);
3510 #if 0 /* Don't try windows on other displays. */
3512 window
= Fget_largest_window (Qt
, Qt
);
3516 window
= Fget_largest_window (frames
, Qt
);
3518 /* If we got a tall enough full-width window that can be split,
3521 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3522 && window_height (window
) >= split_height_threshold
3523 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3524 window
= Fsplit_window (window
, Qnil
, Qnil
);
3527 Lisp_Object upper
, lower
, other
;
3529 window
= Fget_lru_window (frames
, Qt
);
3530 /* If the LRU window is selected, and big enough,
3531 and can be split, split it. */
3533 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3534 && (EQ (window
, selected_window
)
3535 || EQ (XWINDOW (window
)->parent
, Qnil
))
3536 && window_height (window
) >= window_min_height
<< 1)
3537 window
= Fsplit_window (window
, Qnil
, Qnil
);
3539 window
= Fget_lru_window (frames
, Qnil
);
3540 /* If Fget_lru_window returned nil, try other approaches. */
3542 /* Try visible frames first. */
3544 window
= Fget_buffer_window (buffer
, Qvisible
);
3546 window
= Fget_largest_window (Qvisible
, Qnil
);
3547 /* If that didn't work, try iconified frames. */
3549 window
= Fget_buffer_window (buffer
, make_number (0));
3551 window
= Fget_largest_window (make_number (0), Qnil
);
3553 #if 0 /* Don't try frames on other displays. */
3555 window
= Fget_buffer_window (buffer
, Qt
);
3557 window
= Fget_largest_window (Qt
, Qnil
);
3559 /* As a last resort, make a new frame. */
3561 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3562 /* If window appears above or below another,
3563 even out their heights. */
3564 other
= upper
= lower
= Qnil
;
3565 if (!NILP (XWINDOW (window
)->prev
))
3566 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3567 if (!NILP (XWINDOW (window
)->next
))
3568 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3570 && !NILP (Veven_window_heights
)
3571 /* Check that OTHER and WINDOW are vertically arrayed. */
3572 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3573 && (XFASTINT (XWINDOW (other
)->total_lines
)
3574 > XFASTINT (XWINDOW (window
)->total_lines
)))
3576 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3577 + XFASTINT (XWINDOW (window
)->total_lines
));
3578 enlarge_window (upper
,
3579 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3585 window
= Fget_lru_window (Qnil
, Qnil
);
3587 Fset_window_buffer (window
, buffer
, Qnil
);
3588 return display_buffer_1 (window
);
3592 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3594 doc
: /* Force redisplay of all windows.
3595 If optional arg OBJECT is a window, force redisplay of that window only.
3596 If OBJECT is a buffer or buffer name, force redisplay of all windows
3597 displaying that buffer. */)
3603 windows_or_buffers_changed
++;
3604 update_mode_lines
++;
3608 if (WINDOWP (object
))
3610 struct window
*w
= XWINDOW (object
);
3611 mark_window_display_accurate (object
, 0);
3612 w
->update_mode_line
= Qt
;
3613 if (BUFFERP (w
->buffer
))
3614 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3615 ++update_mode_lines
;
3619 if (STRINGP (object
))
3620 object
= Fget_buffer (object
);
3621 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3623 /* Walk all windows looking for buffer, and force update
3624 of each of those windows. */
3626 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3627 return NILP (object
) ? Qnil
: Qt
;
3630 /* If nothing suitable was found, just return.
3631 We could signal an error, but this feature will typically be used
3632 asynchronously in timers or process sentinels, so we don't. */
3638 temp_output_buffer_show (buf
)
3639 register Lisp_Object buf
;
3641 register struct buffer
*old
= current_buffer
;
3642 register Lisp_Object window
;
3643 register struct window
*w
;
3645 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3648 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3652 #if 0 /* rms: there should be no reason for this. */
3653 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3655 set_buffer_internal (old
);
3657 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3658 call1 (Vtemp_buffer_show_function
, buf
);
3661 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3663 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3664 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3665 Vminibuf_scroll_window
= window
;
3666 w
= XWINDOW (window
);
3667 XSETFASTINT (w
->hscroll
, 0);
3668 XSETFASTINT (w
->min_hscroll
, 0);
3669 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3670 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3672 /* Run temp-buffer-show-hook, with the chosen window selected
3673 and its buffer current. */
3675 if (!NILP (Vrun_hooks
)
3676 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3677 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3679 int count
= SPECPDL_INDEX ();
3680 Lisp_Object prev_window
, prev_buffer
;
3681 prev_window
= selected_window
;
3682 XSETBUFFER (prev_buffer
, old
);
3684 /* Select the window that was chosen, for running the hook.
3685 Note: Both Fselect_window and select_window_norecord may
3686 set-buffer to the buffer displayed in the window,
3687 so we need to save the current buffer. --stef */
3688 record_unwind_protect (Fset_buffer
, prev_buffer
);
3689 record_unwind_protect (select_window_norecord
, prev_window
);
3690 Fselect_window (window
, Qt
);
3691 Fset_buffer (w
->buffer
);
3692 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3693 unbind_to (count
, Qnil
);
3699 make_dummy_parent (window
)
3703 register struct window
*o
, *p
;
3706 o
= XWINDOW (window
);
3707 p
= allocate_window ();
3708 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3709 ((struct Lisp_Vector
*) p
)->contents
[i
]
3710 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3711 XSETWINDOW (new, p
);
3714 XSETFASTINT (p
->sequence_number
, sequence_number
);
3716 /* Put new into window structure in place of window */
3717 replace_window (window
, new);
3730 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3731 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3732 WINDOW defaults to selected one and SIZE to half its size.
3733 If optional third arg HORFLAG is non-nil, split side by side
3734 and put SIZE columns in the first of the pair. In that case,
3735 SIZE includes that window's scroll bar, or the divider column to its right.
3736 Interactively, all arguments are nil.
3738 Returns the newly created window (which is the lower or rightmost one).
3739 The upper or leftmost window is the original one and remains selected.
3740 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3741 (window
, size
, horflag
)
3742 Lisp_Object window
, size
, horflag
;
3744 register Lisp_Object
new;
3745 register struct window
*o
, *p
;
3747 register int size_int
;
3750 window
= selected_window
;
3752 CHECK_LIVE_WINDOW (window
);
3754 o
= XWINDOW (window
);
3755 fo
= XFRAME (WINDOW_FRAME (o
));
3759 if (!NILP (horflag
))
3760 /* Calculate the size of the left-hand window, by dividing
3761 the usable space in columns by two.
3762 We round up, since the left-hand window may include
3763 a dividing line, while the right-hand may not. */
3764 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3766 size_int
= XFASTINT (o
->total_lines
) >> 1;
3770 CHECK_NUMBER (size
);
3771 size_int
= XINT (size
);
3774 if (MINI_WINDOW_P (o
))
3775 error ("Attempt to split minibuffer window");
3776 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3777 error ("Attempt to split fixed-size window");
3779 check_min_window_sizes ();
3783 if (size_int
< window_min_height
)
3784 error ("Window height %d too small (after splitting)", size_int
);
3785 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3786 error ("Window height %d too small (after splitting)",
3787 XFASTINT (o
->total_lines
) - size_int
);
3788 if (NILP (o
->parent
)
3789 || NILP (XWINDOW (o
->parent
)->vchild
))
3791 make_dummy_parent (window
);
3793 XWINDOW (new)->vchild
= window
;
3798 if (size_int
< window_min_width
)
3799 error ("Window width %d too small (after splitting)", size_int
);
3801 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3802 error ("Window width %d too small (after splitting)",
3803 XFASTINT (o
->total_cols
) - size_int
);
3804 if (NILP (o
->parent
)
3805 || NILP (XWINDOW (o
->parent
)->hchild
))
3807 make_dummy_parent (window
);
3809 XWINDOW (new)->hchild
= window
;
3813 /* Now we know that window's parent is a vertical combination
3814 if we are dividing vertically, or a horizontal combination
3815 if we are making side-by-side windows */
3817 windows_or_buffers_changed
++;
3818 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3819 new = make_window ();
3822 p
->frame
= o
->frame
;
3824 if (!NILP (p
->next
))
3825 XWINDOW (p
->next
)->prev
= new;
3828 p
->parent
= o
->parent
;
3830 p
->window_end_valid
= Qnil
;
3831 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3833 /* Duplicate special geometry settings. */
3835 p
->left_margin_cols
= o
->left_margin_cols
;
3836 p
->right_margin_cols
= o
->right_margin_cols
;
3837 p
->left_fringe_width
= o
->left_fringe_width
;
3838 p
->right_fringe_width
= o
->right_fringe_width
;
3839 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3840 p
->scroll_bar_width
= o
->scroll_bar_width
;
3841 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3843 /* Apportion the available frame space among the two new windows */
3845 if (!NILP (horflag
))
3847 p
->total_lines
= o
->total_lines
;
3848 p
->top_line
= o
->top_line
;
3849 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3850 XSETFASTINT (o
->total_cols
, size_int
);
3851 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3852 adjust_window_margins (p
);
3853 adjust_window_margins (o
);
3857 p
->left_col
= o
->left_col
;
3858 p
->total_cols
= o
->total_cols
;
3859 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3860 XSETFASTINT (o
->total_lines
, size_int
);
3861 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3864 /* Adjust glyph matrices. */
3867 Fset_window_buffer (new, o
->buffer
, Qt
);
3871 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 3, "p",
3872 doc
: /* Make current window ARG lines bigger.
3873 From program, optional second arg non-nil means grow sideways ARG columns.
3874 Interactively, if an argument is not given, make the window one line bigger.
3876 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3877 of the siblings above or to the left of the selected window. Only
3878 siblings to the right or below are changed. */)
3879 (arg
, side
, preserve_before
)
3880 register Lisp_Object arg
, side
, preserve_before
;
3883 enlarge_window (selected_window
, XINT (arg
), !NILP (side
),
3884 !NILP (preserve_before
));
3886 if (! NILP (Vwindow_configuration_change_hook
))
3887 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3892 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3893 doc
: /* Make current window ARG lines smaller.
3894 From program, optional second arg non-nil means shrink sideways arg columns.
3895 Interactively, if an argument is not given, make the window one line smaller.
3897 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3898 of the siblings above or to the left of the selected window. Only
3899 siblings to the right or below are changed. */)
3900 (arg
, side
, preserve_before
)
3901 register Lisp_Object arg
, side
, preserve_before
;
3904 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3905 !NILP (preserve_before
));
3907 if (! NILP (Vwindow_configuration_change_hook
))
3908 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3914 window_height (window
)
3917 register struct window
*p
= XWINDOW (window
);
3918 return WINDOW_TOTAL_LINES (p
);
3922 window_width (window
)
3925 register struct window
*p
= XWINDOW (window
);
3926 return WINDOW_TOTAL_COLS (p
);
3931 *(widthflag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3933 #define CURSIZE(w) \
3934 *(widthflag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3937 /* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
3938 increase its width. Siblings of the selected window are resized to
3939 fulfill the size request. If they become too small in the process,
3940 they will be deleted.
3942 If PRESERVE_BEFORE is nonzero, that means don't alter
3943 the siblings to the left or above WINDOW. */
3946 enlarge_window (window
, delta
, widthflag
, preserve_before
)
3948 int delta
, widthflag
, preserve_before
;
3950 Lisp_Object parent
, next
, prev
;
3954 int (*sizefun
) P_ ((Lisp_Object
))
3955 = widthflag
? window_width
: window_height
;
3956 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3957 = (widthflag
? set_window_width
: set_window_height
);
3959 /* Check values of window_min_width and window_min_height for
3961 check_min_window_sizes ();
3963 /* Give up if this window cannot be resized. */
3964 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3965 error ("Window is not resizable");
3967 /* Find the parent of the selected window. */
3970 p
= XWINDOW (window
);
3976 error ("No other window to side of this one");
3981 ? !NILP (XWINDOW (parent
)->hchild
)
3982 : !NILP (XWINDOW (parent
)->vchild
))
3988 sizep
= &CURSIZE (window
);
3991 register int maxdelta
;
3993 /* Compute the maximum size increment this window can have. */
3995 if (preserve_before
)
3999 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
4000 /* Subtract size of siblings before, since we can't take that. */
4001 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
4004 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4005 - window_min_size (XWINDOW (p
->next
),
4010 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
4011 /* This is a main window followed by a minibuffer. */
4012 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
4013 - window_min_size (XWINDOW (p
->next
),
4015 /* This is a minibuffer following a main window. */
4016 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
4017 - window_min_size (XWINDOW (p
->prev
),
4019 /* This is a frame with only one window, a minibuffer-only
4020 or a minibufferless frame. */
4023 if (delta
> maxdelta
)
4024 /* This case traps trying to make the minibuffer
4025 the full frame, or make the only window aside from the
4026 minibuffer the full frame. */
4030 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
4032 delete_window (window
);
4039 /* Find the total we can get from other siblings without deleting them. */
4041 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
4042 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
4044 if (! preserve_before
)
4045 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
4046 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
4049 /* If we can get it all from them without deleting them, do so. */
4050 if (delta
<= maximum
)
4052 Lisp_Object first_unaffected
;
4053 Lisp_Object first_affected
;
4058 first_affected
= window
;
4059 /* Look at one sibling at a time,
4060 moving away from this window in both directions alternately,
4061 and take as much as we can get without deleting that sibling. */
4063 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
4067 int this_one
= ((*sizefun
) (next
)
4068 - window_min_size (XWINDOW (next
),
4069 widthflag
, 0, &fixed_p
));
4072 if (this_one
> delta
)
4075 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4076 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4081 next
= XWINDOW (next
)->next
;
4087 if (!preserve_before
&& ! NILP (prev
))
4089 int this_one
= ((*sizefun
) (prev
)
4090 - window_min_size (XWINDOW (prev
),
4091 widthflag
, 0, &fixed_p
));
4094 if (this_one
> delta
)
4097 first_affected
= prev
;
4099 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4100 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4105 prev
= XWINDOW (prev
)->prev
;
4109 xassert (delta
== 0);
4111 /* Now recalculate the edge positions of all the windows affected,
4112 based on the new sizes. */
4113 first_unaffected
= next
;
4114 prev
= first_affected
;
4115 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4116 prev
= next
, next
= XWINDOW (next
)->next
)
4118 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4119 /* This does not change size of NEXT,
4120 but it propagates the new top edge to its children */
4121 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4126 register int delta1
;
4127 register int opht
= (*sizefun
) (parent
);
4129 if (opht
<= XINT (*sizep
) + delta
)
4131 /* If trying to grow this window to or beyond size of the parent,
4132 just delete all the sibling windows. */
4133 Lisp_Object start
, tem
, next
;
4135 start
= XWINDOW (parent
)->vchild
;
4137 start
= XWINDOW (parent
)->hchild
;
4139 /* Delete any siblings that come after WINDOW. */
4140 tem
= XWINDOW (window
)->next
;
4141 while (! NILP (tem
))
4143 next
= XWINDOW (tem
)->next
;
4144 delete_window (tem
);
4148 /* Delete any siblings that come after WINDOW.
4149 Note that if START is not WINDOW, then WINDOW still
4150 Fhas siblings, so WINDOW has not yet replaced its parent. */
4152 while (! EQ (tem
, window
))
4154 next
= XWINDOW (tem
)->next
;
4155 delete_window (tem
);
4161 /* Otherwise, make delta1 just right so that if we add
4162 delta1 lines to this window and to the parent, and then
4163 shrink the parent back to its original size, the new
4164 proportional size of this window will increase by delta.
4166 The function size_window will compute the new height h'
4167 of the window from delta1 as:
4170 x = delta1 - delta1/n * n for the 1st resizable child
4173 where n is the number of children that can be resized.
4174 We can ignore x by choosing a delta1 that is a multiple of
4175 n. We want the height of this window to come out as
4185 The number of children n equals the number of resizable
4186 children of this window + 1 because we know window itself
4187 is resizable (otherwise we would have signalled an error). */
4189 struct window
*w
= XWINDOW (window
);
4193 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4194 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4196 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4197 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4202 /* Add delta1 lines or columns to this window, and to the parent,
4203 keeping things consistent while not affecting siblings. */
4204 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4205 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4207 /* Squeeze out delta1 lines or columns from our parent,
4208 shriking this window and siblings proportionately.
4209 This brings parent back to correct size.
4210 Delta1 was calculated so this makes this window the desired size,
4211 taking it all out of the siblings. */
4212 (*setsizefun
) (parent
, opht
, 0);
4217 XSETFASTINT (p
->last_modified
, 0);
4218 XSETFASTINT (p
->last_overlay_modified
, 0);
4220 /* Adjust glyph matrices. */
4221 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4229 /***********************************************************************
4230 Resizing Mini-Windows
4231 ***********************************************************************/
4233 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4235 enum save_restore_action
4242 static int save_restore_orig_size
P_ ((struct window
*,
4243 enum save_restore_action
));
4245 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4246 from lowest windows first. */
4249 shrink_window_lowest_first (w
, height
)
4257 xassert (!MINI_WINDOW_P (w
));
4259 /* Set redisplay hints. */
4260 XSETFASTINT (w
->last_modified
, 0);
4261 XSETFASTINT (w
->last_overlay_modified
, 0);
4262 windows_or_buffers_changed
++;
4263 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4265 old_height
= XFASTINT (w
->total_lines
);
4266 XSETFASTINT (w
->total_lines
, height
);
4268 if (!NILP (w
->hchild
))
4270 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4272 c
= XWINDOW (child
);
4273 c
->top_line
= w
->top_line
;
4274 shrink_window_lowest_first (c
, height
);
4277 else if (!NILP (w
->vchild
))
4279 Lisp_Object last_child
;
4280 int delta
= old_height
- height
;
4285 /* Find the last child. We are taking space from lowest windows
4286 first, so we iterate over children from the last child
4288 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4291 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4292 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4296 c
= XWINDOW (child
);
4297 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4299 if (this_one
> delta
)
4302 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4306 /* Compute new positions. */
4307 last_top
= XINT (w
->top_line
);
4308 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4310 c
= XWINDOW (child
);
4311 c
->top_line
= make_number (last_top
);
4312 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4313 last_top
+= XFASTINT (c
->total_lines
);
4319 /* Save, restore, or check positions and sizes in the window tree
4320 rooted at W. ACTION says what to do.
4322 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4323 orig_total_lines members are valid for all windows in the window
4324 tree. Value is non-zero if they are valid.
4326 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4327 orig_top_line and orig_total_lines for all windows in the tree.
4329 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4330 stored in orig_top_line and orig_total_lines for all windows. */
4333 save_restore_orig_size (w
, action
)
4335 enum save_restore_action action
;
4341 if (!NILP (w
->hchild
))
4343 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4346 else if (!NILP (w
->vchild
))
4348 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4354 case CHECK_ORIG_SIZES
:
4355 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4359 case SAVE_ORIG_SIZES
:
4360 w
->orig_top_line
= w
->top_line
;
4361 w
->orig_total_lines
= w
->total_lines
;
4362 XSETFASTINT (w
->last_modified
, 0);
4363 XSETFASTINT (w
->last_overlay_modified
, 0);
4366 case RESTORE_ORIG_SIZES
:
4367 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4368 w
->top_line
= w
->orig_top_line
;
4369 w
->total_lines
= w
->orig_total_lines
;
4370 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4371 XSETFASTINT (w
->last_modified
, 0);
4372 XSETFASTINT (w
->last_overlay_modified
, 0);
4379 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4386 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4387 without deleting other windows. */
4390 grow_mini_window (w
, delta
)
4394 struct frame
*f
= XFRAME (w
->frame
);
4395 struct window
*root
;
4397 xassert (MINI_WINDOW_P (w
));
4398 xassert (delta
>= 0);
4400 /* Check values of window_min_width and window_min_height for
4402 check_min_window_sizes ();
4404 /* Compute how much we can enlarge the mini-window without deleting
4406 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4409 int min_height
= window_min_size (root
, 0, 0, 0);
4410 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4411 /* Note that the root window may already be smaller than
4413 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4418 /* Save original window sizes and positions, if not already done. */
4419 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4420 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4422 /* Shrink other windows. */
4423 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4425 /* Grow the mini-window. */
4426 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4427 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4428 XSETFASTINT (w
->last_modified
, 0);
4429 XSETFASTINT (w
->last_overlay_modified
, 0);
4436 /* Shrink mini-window W. If there is recorded info about window sizes
4437 before a call to grow_mini_window, restore recorded window sizes.
4438 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4442 shrink_mini_window (w
)
4445 struct frame
*f
= XFRAME (w
->frame
);
4446 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4448 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4450 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4452 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4453 windows_or_buffers_changed
= 1;
4455 else if (XFASTINT (w
->total_lines
) > 1)
4457 /* Distribute the additional lines of the mini-window
4458 among the other windows. */
4460 XSETWINDOW (window
, w
);
4461 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0, 0);
4467 /* Mark window cursors off for all windows in the window tree rooted
4468 at W by setting their phys_cursor_on_p flag to zero. Called from
4469 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4470 the frame are cleared. */
4473 mark_window_cursors_off (w
)
4478 if (!NILP (w
->hchild
))
4479 mark_window_cursors_off (XWINDOW (w
->hchild
));
4480 else if (!NILP (w
->vchild
))
4481 mark_window_cursors_off (XWINDOW (w
->vchild
));
4483 w
->phys_cursor_on_p
= 0;
4485 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4490 /* Return number of lines of text (not counting mode lines) in W. */
4493 window_internal_height (w
)
4496 int ht
= XFASTINT (w
->total_lines
);
4498 if (!MINI_WINDOW_P (w
))
4500 if (!NILP (w
->parent
)
4501 || !NILP (w
->vchild
)
4502 || !NILP (w
->hchild
)
4505 || WINDOW_WANTS_MODELINE_P (w
))
4508 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4516 /* Return the number of columns in W.
4517 Don't count columns occupied by scroll bars or the vertical bar
4518 separating W from the sibling to its right. */
4521 window_box_text_cols (w
)
4524 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4525 int width
= XINT (w
->total_cols
);
4527 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4528 /* Scroll bars occupy a few columns. */
4529 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4530 else if (!FRAME_WINDOW_P (f
)
4531 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4532 /* The column of `|' characters separating side-by-side windows
4533 occupies one column only. */
4536 if (FRAME_WINDOW_P (f
))
4537 /* On window-systems, fringes and display margins cannot be
4538 used for normal text. */
4539 width
-= (WINDOW_FRINGE_COLS (w
)
4540 + WINDOW_LEFT_MARGIN_COLS (w
)
4541 + WINDOW_RIGHT_MARGIN_COLS (w
));
4547 /************************************************************************
4549 ***********************************************************************/
4551 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4552 N screen-fulls, which is defined as the height of the window minus
4553 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4554 instead. Negative values of N mean scroll down. NOERROR non-zero
4555 means don't signal an error if we try to move over BEGV or ZV,
4559 window_scroll (window
, n
, whole
, noerror
)
4567 /* If we must, use the pixel-based version which is much slower than
4568 the line-based one but can handle varying line heights. */
4569 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4570 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4572 window_scroll_line_based (window
, n
, whole
, noerror
);
4578 /* Implementation of window_scroll that works based on pixel line
4579 heights. See the comment of window_scroll for parameter
4583 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4590 struct window
*w
= XWINDOW (window
);
4591 struct text_pos start
;
4593 int this_scroll_margin
;
4595 /* True if we fiddled the window vscroll field without really scrolling. */
4598 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4600 /* If PT is not visible in WINDOW, move back one half of
4601 the screen. Allow PT to be partially visible, otherwise
4602 something like (scroll-down 1) with PT in the line before
4603 the partially visible one would recenter. */
4604 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4607 /* Move backward half the height of the window. Performance note:
4608 vmotion used here is about 10% faster, but would give wrong
4609 results for variable height lines. */
4610 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4611 it
.current_y
= it
.last_visible_y
;
4612 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4614 /* The function move_iterator_vertically may move over more than
4615 the specified y-distance. If it->w is small, e.g. a
4616 mini-buffer window, we may end up in front of the window's
4617 display area. This is the case when Start displaying at the
4618 start of the line containing PT in this case. */
4619 if (it
.current_y
<= 0)
4621 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4622 move_it_vertically_backward (&it
, 0);
4626 start
= it
.current
.pos
;
4628 else if (auto_window_vscroll_p
)
4630 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4633 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4635 dy
= max ((window_box_height (w
)
4636 - next_screen_context_lines
* dy
),
4640 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4642 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4643 Fset_window_vscroll (window
, make_number (px
), Qt
);
4646 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4648 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4649 Fset_window_vscroll (window
, make_number (px
), Qt
);
4653 Fset_window_vscroll (window
, make_number (0), Qt
);
4656 /* If scroll_preserve_screen_position is non-nil, we try to set
4657 point in the same window line as it is now, so get that line. */
4658 if (!NILP (Vscroll_preserve_screen_position
))
4660 start_display (&it
, w
, start
);
4661 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4662 preserve_y
= it
.current_y
;
4667 /* Move iterator it from start the specified distance forward or
4668 backward. The result is the new window start. */
4669 start_display (&it
, w
, start
);
4672 int start_pos
= IT_CHARPOS (it
);
4673 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4674 dy
= max ((window_box_height (w
)
4675 - next_screen_context_lines
* dy
),
4678 /* Note that move_it_vertically always moves the iterator to the
4679 start of a line. So, if the last line doesn't have a newline,
4680 we would end up at the start of the line ending at ZV. */
4683 move_it_vertically_backward (&it
, -dy
);
4684 /* Ensure we actually does move, e.g. in case we are currently
4685 looking at an image that is taller that the window height. */
4686 while (start_pos
== IT_CHARPOS (it
)
4687 && start_pos
> BEGV
)
4688 move_it_by_lines (&it
, -1, 1);
4692 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4693 MOVE_TO_POS
| MOVE_TO_Y
);
4694 /* Ensure we actually does move, e.g. in case we are currently
4695 looking at an image that is taller that the window height. */
4696 while (start_pos
== IT_CHARPOS (it
)
4698 move_it_by_lines (&it
, 1, 1);
4702 move_it_by_lines (&it
, n
, 1);
4704 /* We failed if we find ZV is already on the screen (scrolling up,
4705 means there's nothing past the end), or if we can't start any
4706 earlier (scrolling down, means there's nothing past the top). */
4707 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4708 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4710 if (IT_CHARPOS (it
) == ZV
)
4712 if (it
.current_y
< it
.last_visible_y
4713 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4714 >= it
.last_visible_y
))
4716 /* The last line was only partially visible, make it fully
4718 w
->vscroll
= (it
.last_visible_y
4719 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4720 adjust_glyphs (it
.f
);
4725 Fsignal (Qend_of_buffer
, Qnil
);
4729 if (w
->vscroll
!= 0)
4730 /* The first line was only partially visible, make it fully
4736 Fsignal (Qbeginning_of_buffer
, Qnil
);
4739 /* If control gets here, then we vscrolled. */
4741 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4743 /* Don't try to change the window start below. */
4749 int pos
= IT_CHARPOS (it
);
4752 /* If in the middle of a multi-glyph character move forward to
4753 the next character. */
4754 if (in_display_vector_p (&it
))
4757 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4760 /* Set the window start, and set up the window for redisplay. */
4761 set_marker_restricted (w
->start
, make_number (pos
),
4763 bytepos
= XMARKER (w
->start
)->bytepos
;
4764 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4766 w
->update_mode_line
= Qt
;
4767 XSETFASTINT (w
->last_modified
, 0);
4768 XSETFASTINT (w
->last_overlay_modified
, 0);
4769 /* Set force_start so that redisplay_window will run the
4770 window-scroll-functions. */
4771 w
->force_start
= Qt
;
4774 /* The rest of this function uses current_y in a nonstandard way,
4775 not including the height of the header line if any. */
4776 it
.current_y
= it
.vpos
= 0;
4778 /* Move PT out of scroll margins.
4779 This code wants current_y to be zero at the window start position
4780 even if there is a header line. */
4781 this_scroll_margin
= max (0, scroll_margin
);
4782 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4783 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4787 /* We moved the window start towards ZV, so PT may be now
4788 in the scroll margin at the top. */
4789 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4790 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
4791 && (NILP (Vscroll_preserve_screen_position
)
4792 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4793 /* We found PT at a legitimate height. Leave it alone. */
4795 else if (preserve_y
>= 0)
4797 /* If we have a header line, take account of it.
4798 This is necessary because we set it.current_y to 0, above. */
4799 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4800 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4802 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4803 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4807 while (it
.current_y
< this_scroll_margin
)
4809 int prev
= it
.current_y
;
4810 move_it_by_lines (&it
, 1, 1);
4811 if (prev
== it
.current_y
)
4814 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4819 int charpos
, bytepos
;
4822 /* Save our position, for the preserve_y case. */
4823 charpos
= IT_CHARPOS (it
);
4824 bytepos
= IT_BYTEPOS (it
);
4826 /* We moved the window start towards BEGV, so PT may be now
4827 in the scroll margin at the bottom. */
4828 move_it_to (&it
, PT
, -1,
4829 (it
.last_visible_y
- CURRENT_HEADER_LINE_HEIGHT (w
)
4830 - this_scroll_margin
- 1),
4832 MOVE_TO_POS
| MOVE_TO_Y
);
4834 /* Save our position, in case it's correct. */
4835 charpos
= IT_CHARPOS (it
);
4836 bytepos
= IT_BYTEPOS (it
);
4838 /* See if point is on a partially visible line at the end. */
4839 if (it
.what
== IT_EOB
)
4840 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4843 move_it_by_lines (&it
, 1, 1);
4844 partial_p
= it
.current_y
> it
.last_visible_y
;
4847 if (charpos
== PT
&& !partial_p
4848 && (NILP (Vscroll_preserve_screen_position
)
4849 || EQ (Vscroll_preserve_screen_position
, Qt
)))
4850 /* We found PT before we found the display margin, so PT is ok. */
4852 else if (preserve_y
>= 0)
4854 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4855 start_display (&it
, w
, start
);
4856 #if 0 /* It's wrong to subtract this here
4857 because we called start_display again
4858 and did not alter it.current_y this time. */
4860 /* If we have a header line, take account of it. */
4861 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4862 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4865 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4866 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4871 /* The last line was only partially visible, so back up two
4872 lines to make sure we're on a fully visible line. */
4874 move_it_by_lines (&it
, -2, 0);
4875 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4878 /* No, the position we saved is OK, so use it. */
4879 SET_PT_BOTH (charpos
, bytepos
);
4885 /* Implementation of window_scroll that works based on screen lines.
4886 See the comment of window_scroll for parameter descriptions. */
4889 window_scroll_line_based (window
, n
, whole
, noerror
)
4895 register struct window
*w
= XWINDOW (window
);
4896 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4897 register int pos
, pos_byte
;
4898 register int ht
= window_internal_height (w
);
4899 register Lisp_Object tem
;
4903 struct position posit
;
4906 /* If scrolling screen-fulls, compute the number of lines to
4907 scroll from the window's height. */
4909 n
*= max (1, ht
- next_screen_context_lines
);
4911 startpos
= marker_position (w
->start
);
4913 posit
= *compute_motion (startpos
, 0, 0, 0,
4915 -1, XINT (w
->hscroll
),
4917 original_vpos
= posit
.vpos
;
4919 XSETFASTINT (tem
, PT
);
4920 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4924 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4929 lose
= n
< 0 && PT
== BEGV
;
4930 Fvertical_motion (make_number (n
), window
);
4934 SET_PT_BOTH (opoint
, opoint_byte
);
4941 Fsignal (Qbeginning_of_buffer
, Qnil
);
4946 int this_scroll_margin
= scroll_margin
;
4948 /* Don't use a scroll margin that is negative or too large. */
4949 if (this_scroll_margin
< 0)
4950 this_scroll_margin
= 0;
4952 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
4953 this_scroll_margin
= XINT (w
->total_lines
) / 4;
4955 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4956 w
->start_at_line_beg
= bolp
;
4957 w
->update_mode_line
= Qt
;
4958 XSETFASTINT (w
->last_modified
, 0);
4959 XSETFASTINT (w
->last_overlay_modified
, 0);
4960 /* Set force_start so that redisplay_window will run
4961 the window-scroll-functions. */
4962 w
->force_start
= Qt
;
4964 if (!NILP (Vscroll_preserve_screen_position
)
4965 && (whole
|| !EQ (Vscroll_preserve_screen_position
, Qt
)))
4967 SET_PT_BOTH (pos
, pos_byte
);
4968 Fvertical_motion (make_number (original_vpos
), window
);
4970 /* If we scrolled forward, put point enough lines down
4971 that it is outside the scroll margin. */
4976 if (this_scroll_margin
> 0)
4978 SET_PT_BOTH (pos
, pos_byte
);
4979 Fvertical_motion (make_number (this_scroll_margin
), window
);
4985 if (top_margin
<= opoint
)
4986 SET_PT_BOTH (opoint
, opoint_byte
);
4987 else if (!NILP (Vscroll_preserve_screen_position
))
4989 SET_PT_BOTH (pos
, pos_byte
);
4990 Fvertical_motion (make_number (original_vpos
), window
);
4993 SET_PT (top_margin
);
4999 /* If we scrolled backward, put point near the end of the window
5000 but not within the scroll margin. */
5001 SET_PT_BOTH (pos
, pos_byte
);
5002 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
5003 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
5006 bottom_margin
= PT
+ 1;
5008 if (bottom_margin
> opoint
)
5009 SET_PT_BOTH (opoint
, opoint_byte
);
5012 if (!NILP (Vscroll_preserve_screen_position
))
5014 SET_PT_BOTH (pos
, pos_byte
);
5015 Fvertical_motion (make_number (original_vpos
), window
);
5018 Fvertical_motion (make_number (-1), window
);
5027 Fsignal (Qend_of_buffer
, Qnil
);
5032 /* Scroll selected_window up or down. If N is nil, scroll a
5033 screen-full which is defined as the height of the window minus
5034 next_screen_context_lines. If N is the symbol `-', scroll.
5035 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
5036 up. This is the guts of Fscroll_up and Fscroll_down. */
5039 scroll_command (n
, direction
)
5043 int count
= SPECPDL_INDEX ();
5045 xassert (abs (direction
) == 1);
5047 /* If selected window's buffer isn't current, make it current for
5048 the moment. But don't screw up if window_scroll gets an error. */
5049 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
5051 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5052 Fset_buffer (XWINDOW (selected_window
)->buffer
);
5054 /* Make redisplay consider other windows than just selected_window. */
5055 ++windows_or_buffers_changed
;
5059 window_scroll (selected_window
, direction
, 1, 0);
5060 else if (EQ (n
, Qminus
))
5061 window_scroll (selected_window
, -direction
, 1, 0);
5064 n
= Fprefix_numeric_value (n
);
5065 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5068 unbind_to (count
, Qnil
);
5071 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5072 doc
: /* Scroll text of current window upward ARG lines.
5073 If ARG is omitted or nil, scroll upward by a near full screen.
5074 A near full screen is `next-screen-context-lines' less than a full screen.
5075 Negative ARG means scroll downward.
5076 If ARG is the atom `-', scroll downward by nearly full screen.
5077 When calling from a program, supply as argument a number, nil, or `-'. */)
5081 scroll_command (arg
, 1);
5085 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5086 doc
: /* Scroll text of current window down ARG lines.
5087 If ARG is omitted or nil, scroll down by a near full screen.
5088 A near full screen is `next-screen-context-lines' less than a full screen.
5089 Negative ARG means scroll upward.
5090 If ARG is the atom `-', scroll upward by nearly full screen.
5091 When calling from a program, supply as argument a number, nil, or `-'. */)
5095 scroll_command (arg
, -1);
5099 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5100 doc
: /* Return the other window for \"other window scroll\" commands.
5101 If `other-window-scroll-buffer' is non-nil, a window
5102 showing that buffer is used.
5103 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5104 specifies the window. This takes precedence over
5105 `other-window-scroll-buffer'. */)
5110 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5111 && !NILP (Vminibuf_scroll_window
))
5112 window
= Vminibuf_scroll_window
;
5113 /* If buffer is specified, scroll that buffer. */
5114 else if (!NILP (Vother_window_scroll_buffer
))
5116 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5118 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5122 /* Nothing specified; look for a neighboring window on the same
5124 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5126 if (EQ (window
, selected_window
))
5127 /* That didn't get us anywhere; look for a window on another
5130 window
= Fnext_window (window
, Qnil
, Qt
);
5131 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5132 && ! EQ (window
, selected_window
));
5135 CHECK_LIVE_WINDOW (window
);
5137 if (EQ (window
, selected_window
))
5138 error ("There is no other window");
5143 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5144 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5145 A near full screen is `next-screen-context-lines' less than a full screen.
5146 The next window is the one below the current one; or the one at the top
5147 if the current one is at the bottom. Negative ARG means scroll downward.
5148 If ARG is the atom `-', scroll downward by nearly full screen.
5149 When calling from a program, supply as argument a number, nil, or `-'.
5151 If `other-window-scroll-buffer' is non-nil, scroll the window
5152 showing that buffer, popping the buffer up if necessary.
5153 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5154 specifies the window to scroll. This takes precedence over
5155 `other-window-scroll-buffer'. */)
5161 int count
= SPECPDL_INDEX ();
5163 window
= Fother_window_for_scrolling ();
5164 w
= XWINDOW (window
);
5166 /* Don't screw up if window_scroll gets an error. */
5167 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5168 ++windows_or_buffers_changed
;
5170 Fset_buffer (w
->buffer
);
5171 SET_PT (marker_position (w
->pointm
));
5174 window_scroll (window
, 1, 1, 1);
5175 else if (EQ (arg
, Qminus
))
5176 window_scroll (window
, -1, 1, 1);
5182 window_scroll (window
, XINT (arg
), 0, 1);
5185 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5186 unbind_to (count
, Qnil
);
5191 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5192 doc
: /* Scroll selected window display ARG columns left.
5193 Default for ARG is window width minus 2.
5194 Value is the total amount of leftward horizontal scrolling in
5195 effect after the change.
5196 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5197 lower bound for automatic scrolling, i.e. automatic scrolling
5198 will not scroll a window to a column less than the value returned
5199 by this function. This happens in an interactive call. */)
5201 register Lisp_Object arg
, set_minimum
;
5205 struct window
*w
= XWINDOW (selected_window
);
5208 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5210 arg
= Fprefix_numeric_value (arg
);
5212 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5213 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5215 if (!NILP (set_minimum
))
5216 w
->min_hscroll
= w
->hscroll
;
5221 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5222 doc
: /* Scroll selected window display ARG columns right.
5223 Default for ARG is window width minus 2.
5224 Value is the total amount of leftward horizontal scrolling in
5225 effect after the change.
5226 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5227 lower bound for automatic scrolling, i.e. automatic scrolling
5228 will not scroll a window to a column less than the value returned
5229 by this function. This happens in an interactive call. */)
5231 register Lisp_Object arg
, set_minimum
;
5235 struct window
*w
= XWINDOW (selected_window
);
5238 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5240 arg
= Fprefix_numeric_value (arg
);
5242 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5243 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5245 if (!NILP (set_minimum
))
5246 w
->min_hscroll
= w
->hscroll
;
5251 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5252 doc
: /* Return the window which was selected when entering the minibuffer.
5253 Returns nil, if current window is not a minibuffer window. */)
5256 if (minibuf_level
> 0
5257 && MINI_WINDOW_P (XWINDOW (selected_window
))
5258 && WINDOW_LIVE_P (minibuf_selected_window
))
5259 return minibuf_selected_window
;
5264 /* Value is the number of lines actually displayed in window W,
5265 as opposed to its height. */
5268 displayed_window_lines (w
)
5272 struct text_pos start
;
5273 int height
= window_box_height (w
);
5274 struct buffer
*old_buffer
;
5277 if (XBUFFER (w
->buffer
) != current_buffer
)
5279 old_buffer
= current_buffer
;
5280 set_buffer_internal (XBUFFER (w
->buffer
));
5285 /* In case W->start is out of the accessible range, do something
5286 reasonable. This happens in Info mode when Info-scroll-down
5287 calls (recenter -1) while W->start is 1. */
5288 if (XMARKER (w
->start
)->charpos
< BEGV
)
5289 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5290 else if (XMARKER (w
->start
)->charpos
> ZV
)
5291 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5293 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5295 start_display (&it
, w
, start
);
5296 move_it_vertically (&it
, height
);
5297 bottom_y
= line_bottom_y (&it
);
5299 /* rms: On a non-window display,
5300 the value of it.vpos at the bottom of the screen
5301 seems to be 1 larger than window_box_height (w).
5302 This kludge fixes a bug whereby (move-to-window-line -1)
5303 when ZV is on the last screen line
5304 moves to the previous screen line instead of the last one. */
5305 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5308 /* Add in empty lines at the bottom of the window. */
5309 if (bottom_y
< height
)
5311 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5312 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5316 set_buffer_internal (old_buffer
);
5322 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5323 doc
: /* Center point in window and redisplay frame.
5324 With prefix argument ARG, recenter putting point on screen line ARG
5325 relative to the current window. If ARG is negative, it counts up from the
5326 bottom of the window. (ARG should be less than the height of the window.)
5328 If ARG is omitted or nil, erase the entire frame and then
5329 redraw with point in the center of the current window.
5330 Just C-u as prefix means put point in the center of the window
5331 and redisplay normally--don't erase and redraw the frame. */)
5333 register Lisp_Object arg
;
5335 struct window
*w
= XWINDOW (selected_window
);
5336 struct buffer
*buf
= XBUFFER (w
->buffer
);
5337 struct buffer
*obuf
= current_buffer
;
5339 int charpos
, bytepos
;
5341 int this_scroll_margin
;
5343 /* If redisplay is suppressed due to an error, try again. */
5344 obuf
->display_error_modiff
= 0;
5350 /* Invalidate pixel data calculated for all compositions. */
5351 for (i
= 0; i
< n_compositions
; i
++)
5352 composition_table
[i
]->font
= NULL
;
5354 Fredraw_frame (w
->frame
);
5355 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5358 else if (CONSP (arg
)) /* Just C-u. */
5362 arg
= Fprefix_numeric_value (arg
);
5367 set_buffer_internal (buf
);
5369 /* Do this after making BUF current
5370 in case scroll_margin is buffer-local. */
5371 this_scroll_margin
= max (0, scroll_margin
);
5372 this_scroll_margin
= min (this_scroll_margin
,
5373 XFASTINT (w
->total_lines
) / 4);
5375 /* Handle centering on a graphical frame specially. Such frames can
5376 have variable-height lines and centering point on the basis of
5377 line counts would lead to strange effects. */
5378 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5385 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5386 start_display (&it
, w
, pt
);
5387 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5388 charpos
= IT_CHARPOS (it
);
5389 bytepos
= IT_BYTEPOS (it
);
5396 int extra_line_spacing
;
5397 int h
= window_box_height (w
);
5399 iarg
= - max (-iarg
, this_scroll_margin
);
5401 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5402 start_display (&it
, w
, pt
);
5404 /* Be sure we have the exact height of the full line containing PT. */
5405 move_it_by_lines (&it
, 0, 1);
5407 /* The amount of pixels we have to move back is the window
5408 height minus what's displayed in the line containing PT,
5409 and the lines below. */
5412 move_it_by_lines (&it
, nlines
, 1);
5414 if (it
.vpos
== nlines
)
5418 /* Last line has no newline */
5419 h
-= line_bottom_y (&it
);
5423 /* Don't reserve space for extra line spacing of last line. */
5424 extra_line_spacing
= it
.max_extra_line_spacing
;
5426 /* If we can't move down NLINES lines because we hit
5427 the end of the buffer, count in some empty lines. */
5428 if (it
.vpos
< nlines
)
5431 extra_line_spacing
= it
.extra_line_spacing
;
5432 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5437 /* Now find the new top line (starting position) of the window. */
5438 start_display (&it
, w
, pt
);
5440 move_it_vertically_backward (&it
, h
);
5442 /* If extra line spacing is present, we may move too far
5443 back. This causes the last line to be only partially
5444 visible (which triggers redisplay to recenter that line
5445 in the middle), so move forward.
5446 But ignore extra line spacing on last line, as it is not
5447 considered to be part of the visible height of the line.
5449 h
+= extra_line_spacing
;
5450 while (-it
.current_y
> h
)
5451 move_it_by_lines (&it
, 1, 1);
5453 charpos
= IT_CHARPOS (it
);
5454 bytepos
= IT_BYTEPOS (it
);
5458 struct position pos
;
5460 iarg
= max (iarg
, this_scroll_margin
);
5462 pos
= *vmotion (PT
, -iarg
, w
);
5463 charpos
= pos
.bufpos
;
5464 bytepos
= pos
.bytepos
;
5469 struct position pos
;
5470 int ht
= window_internal_height (w
);
5477 /* Don't let it get into the margin at either top or bottom. */
5478 iarg
= max (iarg
, this_scroll_margin
);
5479 iarg
= min (iarg
, ht
- this_scroll_margin
- 1);
5481 pos
= *vmotion (PT
, - iarg
, w
);
5482 charpos
= pos
.bufpos
;
5483 bytepos
= pos
.bytepos
;
5486 /* Set the new window start. */
5487 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5488 w
->window_end_valid
= Qnil
;
5490 w
->optional_new_start
= Qt
;
5492 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5493 w
->start_at_line_beg
= Qt
;
5495 w
->start_at_line_beg
= Qnil
;
5497 set_buffer_internal (obuf
);
5502 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5504 doc
: /* Return the height in lines of the text display area of WINDOW.
5505 This doesn't include the mode-line (or header-line if any) or any
5506 partial-height lines in the text display area. */)
5510 struct window
*w
= decode_window (window
);
5511 int pixel_height
= window_box_height (w
);
5512 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5513 return make_number (line_height
);
5518 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5520 doc
: /* Position point relative to window.
5521 With no argument, position point at center of window.
5522 An argument specifies vertical position within the window;
5523 zero means top of window, negative means relative to bottom of window. */)
5527 struct window
*w
= XWINDOW (selected_window
);
5531 int this_scroll_margin
;
5534 window
= selected_window
;
5535 start
= marker_position (w
->start
);
5536 if (start
< BEGV
|| start
> ZV
)
5538 int height
= window_internal_height (w
);
5539 Fvertical_motion (make_number (- (height
/ 2)), window
);
5540 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5541 w
->start_at_line_beg
= Fbolp ();
5542 w
->force_start
= Qt
;
5545 Fgoto_char (w
->start
);
5547 lines
= displayed_window_lines (w
);
5550 this_scroll_margin
= max (0, scroll_margin
);
5551 this_scroll_margin
= min (this_scroll_margin
, lines
/ 4);
5555 XSETFASTINT (arg
, lines
/ 2);
5558 int iarg
= XINT (Fprefix_numeric_value (arg
));
5561 iarg
= iarg
+ lines
;
5563 #if 0 /* This code would prevent move-to-window-line from moving point
5564 to a place inside the scroll margins (which would cause the
5565 next redisplay to scroll). I wrote this code, but then concluded
5566 it is probably better not to install it. However, it is here
5567 inside #if 0 so as not to lose it. -- rms. */
5569 /* Don't let it get into the margin at either top or bottom. */
5570 iarg
= max (iarg
, this_scroll_margin
);
5571 iarg
= min (iarg
, lines
- this_scroll_margin
- 1);
5574 arg
= make_number (iarg
);
5577 /* Skip past a partially visible first line. */
5579 XSETINT (arg
, XINT (arg
) + 1);
5581 return Fvertical_motion (arg
, window
);
5586 /***********************************************************************
5587 Window Configuration
5588 ***********************************************************************/
5590 struct save_window_data
5592 EMACS_INT size_from_Lisp_Vector_struct
;
5593 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5594 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5595 Lisp_Object frame_tool_bar_lines
;
5596 Lisp_Object selected_frame
;
5597 Lisp_Object current_window
;
5598 Lisp_Object current_buffer
;
5599 Lisp_Object minibuf_scroll_window
;
5600 Lisp_Object minibuf_selected_window
;
5601 Lisp_Object root_window
;
5602 Lisp_Object focus_frame
;
5603 /* Record the values of window-min-width and window-min-height
5604 so that window sizes remain consistent with them. */
5605 Lisp_Object min_width
, min_height
;
5606 /* A vector, each of whose elements is a struct saved_window
5608 Lisp_Object saved_windows
;
5611 /* This is saved as a Lisp_Vector */
5614 /* these first two must agree with struct Lisp_Vector in lisp.h */
5615 EMACS_INT size_from_Lisp_Vector_struct
;
5616 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5619 Lisp_Object buffer
, start
, pointm
, mark
;
5620 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5621 Lisp_Object hscroll
, min_hscroll
;
5622 Lisp_Object parent
, prev
;
5623 Lisp_Object start_at_line_beg
;
5624 Lisp_Object display_table
;
5625 Lisp_Object orig_top_line
, orig_total_lines
;
5626 Lisp_Object left_margin_cols
, right_margin_cols
;
5627 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5628 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5631 #define SAVED_WINDOW_N(swv,n) \
5632 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5634 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5635 doc
: /* Return t if OBJECT is a window-configuration object. */)
5639 if (WINDOW_CONFIGURATIONP (object
))
5644 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5645 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5649 register struct save_window_data
*data
;
5650 struct Lisp_Vector
*saved_windows
;
5652 if (! WINDOW_CONFIGURATIONP (config
))
5653 wrong_type_argument (Qwindow_configuration_p
, config
);
5655 data
= (struct save_window_data
*) XVECTOR (config
);
5656 saved_windows
= XVECTOR (data
->saved_windows
);
5657 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5660 DEFUN ("set-window-configuration", Fset_window_configuration
,
5661 Sset_window_configuration
, 1, 1, 0,
5662 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5663 CONFIGURATION must be a value previously returned
5664 by `current-window-configuration' (which see).
5665 If CONFIGURATION was made from a frame that is now deleted,
5666 only frame-independent values can be restored. In this case,
5667 the return value is nil. Otherwise the value is t. */)
5669 Lisp_Object configuration
;
5671 register struct save_window_data
*data
;
5672 struct Lisp_Vector
*saved_windows
;
5673 Lisp_Object new_current_buffer
;
5678 while (!WINDOW_CONFIGURATIONP (configuration
))
5679 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5681 data
= (struct save_window_data
*) XVECTOR (configuration
);
5682 saved_windows
= XVECTOR (data
->saved_windows
);
5684 new_current_buffer
= data
->current_buffer
;
5685 if (NILP (XBUFFER (new_current_buffer
)->name
))
5686 new_current_buffer
= Qnil
;
5689 if (XBUFFER (new_current_buffer
) == current_buffer
)
5692 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5693 point in new_current_buffer as of the last time this buffer was
5694 used. This can be non-deterministic since it can be changed by
5695 things like jit-lock by mere temporary selection of some random
5696 window that happens to show this buffer.
5697 So if possible we want this arbitrary choice of "which point" to
5698 be the one from the to-be-selected-window so as to prevent this
5699 window's cursor from being copied from another window. */
5700 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5701 /* If current_window = selected_window, its point is in BUF_PT. */
5702 && !EQ (selected_window
, data
->current_window
))
5703 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5705 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5708 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5711 /* If f is a dead frame, don't bother rebuilding its window tree.
5712 However, there is other stuff we should still try to do below. */
5713 if (FRAME_LIVE_P (f
))
5715 register struct window
*w
;
5716 register struct saved_window
*p
;
5717 struct window
*root_window
;
5718 struct window
**leaf_windows
;
5722 /* If the frame has been resized since this window configuration was
5723 made, we change the frame to the size specified in the
5724 configuration, restore the configuration, and then resize it
5725 back. We keep track of the prevailing height in these variables. */
5726 int previous_frame_lines
= FRAME_LINES (f
);
5727 int previous_frame_cols
= FRAME_COLS (f
);
5728 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5729 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5731 /* The mouse highlighting code could get screwed up
5732 if it runs during this. */
5735 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5736 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5737 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5738 XFASTINT (data
->frame_cols
), 0, 0, 0);
5739 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5740 if (XFASTINT (data
->frame_menu_bar_lines
)
5741 != previous_frame_menu_bar_lines
)
5742 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5743 #ifdef HAVE_WINDOW_SYSTEM
5744 if (XFASTINT (data
->frame_tool_bar_lines
)
5745 != previous_frame_tool_bar_lines
)
5746 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5750 /* "Swap out" point from the selected window's buffer
5751 into the window itself. (Normally the pointm of the selected
5752 window holds garbage.) We do this now, before
5753 restoring the window contents, and prevent it from
5754 being done later on when we select a new window. */
5755 if (! NILP (XWINDOW (selected_window
)->buffer
))
5757 w
= XWINDOW (selected_window
);
5758 set_marker_both (w
->pointm
,
5760 BUF_PT (XBUFFER (w
->buffer
)),
5761 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5764 windows_or_buffers_changed
++;
5765 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5767 /* Problem: Freeing all matrices and later allocating them again
5768 is a serious redisplay flickering problem. What we would
5769 really like to do is to free only those matrices not reused
5771 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5773 = (struct window
**) alloca (count_windows (root_window
)
5774 * sizeof (struct window
*));
5775 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5777 /* Temporarily avoid any problems with windows that are smaller
5778 than they are supposed to be. */
5779 window_min_height
= 1;
5780 window_min_width
= 1;
5783 Mark all windows now on frame as "deleted".
5784 Restoring the new configuration "undeletes" any that are in it.
5786 Save their current buffers in their height fields, since we may
5787 need it later, if a buffer saved in the configuration is now
5789 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5791 for (k
= 0; k
< saved_windows
->size
; k
++)
5793 p
= SAVED_WINDOW_N (saved_windows
, k
);
5794 w
= XWINDOW (p
->window
);
5797 if (!NILP (p
->parent
))
5798 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5799 XFASTINT (p
->parent
))->window
;
5803 if (!NILP (p
->prev
))
5805 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5806 XFASTINT (p
->prev
))->window
;
5807 XWINDOW (w
->prev
)->next
= p
->window
;
5812 if (!NILP (w
->parent
))
5814 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5816 XWINDOW (w
->parent
)->vchild
= p
->window
;
5817 XWINDOW (w
->parent
)->hchild
= Qnil
;
5821 XWINDOW (w
->parent
)->hchild
= p
->window
;
5822 XWINDOW (w
->parent
)->vchild
= Qnil
;
5827 /* If we squirreled away the buffer in the window's height,
5829 if (BUFFERP (w
->total_lines
))
5830 w
->buffer
= w
->total_lines
;
5831 w
->left_col
= p
->left_col
;
5832 w
->top_line
= p
->top_line
;
5833 w
->total_cols
= p
->total_cols
;
5834 w
->total_lines
= p
->total_lines
;
5835 w
->hscroll
= p
->hscroll
;
5836 w
->min_hscroll
= p
->min_hscroll
;
5837 w
->display_table
= p
->display_table
;
5838 w
->orig_top_line
= p
->orig_top_line
;
5839 w
->orig_total_lines
= p
->orig_total_lines
;
5840 w
->left_margin_cols
= p
->left_margin_cols
;
5841 w
->right_margin_cols
= p
->right_margin_cols
;
5842 w
->left_fringe_width
= p
->left_fringe_width
;
5843 w
->right_fringe_width
= p
->right_fringe_width
;
5844 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5845 w
->scroll_bar_width
= p
->scroll_bar_width
;
5846 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5847 XSETFASTINT (w
->last_modified
, 0);
5848 XSETFASTINT (w
->last_overlay_modified
, 0);
5850 /* Reinstall the saved buffer and pointers into it. */
5851 if (NILP (p
->buffer
))
5852 w
->buffer
= p
->buffer
;
5855 if (!NILP (XBUFFER (p
->buffer
)->name
))
5856 /* If saved buffer is alive, install it. */
5858 w
->buffer
= p
->buffer
;
5859 w
->start_at_line_beg
= p
->start_at_line_beg
;
5860 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5861 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5862 Fset_marker (XBUFFER (w
->buffer
)->mark
,
5863 p
->mark
, w
->buffer
);
5865 /* As documented in Fcurrent_window_configuration, don't
5866 restore the location of point in the buffer which was
5867 current when the window configuration was recorded. */
5868 if (!EQ (p
->buffer
, new_current_buffer
)
5869 && XBUFFER (p
->buffer
) == current_buffer
)
5870 Fgoto_char (w
->pointm
);
5872 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
5873 /* Else unless window has a live buffer, get one. */
5875 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5876 /* This will set the markers to beginning of visible
5878 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5879 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5880 w
->start_at_line_beg
= Qt
;
5883 /* Keeping window's old buffer; make sure the markers
5886 /* Set window markers at start of visible range. */
5887 if (XMARKER (w
->start
)->buffer
== 0)
5888 set_marker_restricted (w
->start
, make_number (0),
5890 if (XMARKER (w
->pointm
)->buffer
== 0)
5891 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5892 BUF_PT (XBUFFER (w
->buffer
)),
5893 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5894 w
->start_at_line_beg
= Qt
;
5899 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5900 /* Prevent "swapping out point" in the old selected window
5901 using the buffer that has been restored into it.
5902 We already swapped out point that from that window's old buffer. */
5903 selected_window
= Qnil
;
5905 /* Arrange *not* to restore point in the buffer that was
5906 current when the window configuration was saved. */
5907 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5908 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5909 make_number (old_point
),
5910 XWINDOW (data
->current_window
)->buffer
);
5912 Fselect_window (data
->current_window
, Qnil
);
5913 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
5916 if (NILP (data
->focus_frame
)
5917 || (FRAMEP (data
->focus_frame
)
5918 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5919 Fredirect_frame_focus (frame
, data
->focus_frame
);
5921 #if 0 /* I don't understand why this is needed, and it causes problems
5922 when the frame's old selected window has been deleted. */
5923 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
5924 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5928 /* Set the screen height to the value it had before this function. */
5929 if (previous_frame_lines
!= FRAME_LINES (f
)
5930 || previous_frame_cols
!= FRAME_COLS (f
))
5931 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5933 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5934 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5935 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5937 #ifdef HAVE_WINDOW_SYSTEM
5938 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5939 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5944 /* Now, free glyph matrices in windows that were not reused. */
5945 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5947 if (NILP (leaf_windows
[i
]->buffer
))
5949 /* Assert it's not reused as a combination. */
5950 xassert (NILP (leaf_windows
[i
]->hchild
)
5951 && NILP (leaf_windows
[i
]->vchild
));
5952 free_window_matrices (leaf_windows
[i
]);
5954 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5962 /* Fselect_window will have made f the selected frame, so we
5963 reselect the proper frame here. Fhandle_switch_frame will change the
5964 selected window too, but that doesn't make the call to
5965 Fselect_window above totally superfluous; it still sets f's
5967 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5968 do_switch_frame (data
->selected_frame
, 0, 0);
5970 if (! NILP (Vwindow_configuration_change_hook
)
5971 && ! NILP (Vrun_hooks
))
5972 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5975 if (!NILP (new_current_buffer
))
5976 Fset_buffer (new_current_buffer
);
5978 /* Restore the minimum heights recorded in the configuration. */
5979 window_min_height
= XINT (data
->min_height
);
5980 window_min_width
= XINT (data
->min_width
);
5982 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5983 minibuf_selected_window
= data
->minibuf_selected_window
;
5985 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5988 /* Mark all windows now on frame as deleted
5989 by setting their buffers to nil. */
5992 delete_all_subwindows (w
)
5993 register struct window
*w
;
5995 if (!NILP (w
->next
))
5996 delete_all_subwindows (XWINDOW (w
->next
));
5997 if (!NILP (w
->vchild
))
5998 delete_all_subwindows (XWINDOW (w
->vchild
));
5999 if (!NILP (w
->hchild
))
6000 delete_all_subwindows (XWINDOW (w
->hchild
));
6002 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
6004 if (!NILP (w
->buffer
))
6007 /* We set all three of these fields to nil, to make sure that we can
6008 distinguish this dead window from any live window. Live leaf
6009 windows will have buffer set, and combination windows will have
6010 vchild or hchild set. */
6015 Vwindow_list
= Qnil
;
6019 count_windows (window
)
6020 register struct window
*window
;
6022 register int count
= 1;
6023 if (!NILP (window
->next
))
6024 count
+= count_windows (XWINDOW (window
->next
));
6025 if (!NILP (window
->vchild
))
6026 count
+= count_windows (XWINDOW (window
->vchild
));
6027 if (!NILP (window
->hchild
))
6028 count
+= count_windows (XWINDOW (window
->hchild
));
6033 /* Fill vector FLAT with leaf windows under W, starting at index I.
6034 Value is last index + 1. */
6037 get_leaf_windows (w
, flat
, i
)
6039 struct window
**flat
;
6044 if (!NILP (w
->hchild
))
6045 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
6046 else if (!NILP (w
->vchild
))
6047 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
6051 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6058 /* Return a pointer to the glyph W's physical cursor is on. Value is
6059 null if W's current matrix is invalid, so that no meaningfull glyph
6063 get_phys_cursor_glyph (w
)
6066 struct glyph_row
*row
;
6067 struct glyph
*glyph
;
6069 if (w
->phys_cursor
.vpos
>= 0
6070 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
6071 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
6073 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
6074 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
6083 save_window_save (window
, vector
, i
)
6085 struct Lisp_Vector
*vector
;
6088 register struct saved_window
*p
;
6089 register struct window
*w
;
6090 register Lisp_Object tem
;
6092 for (;!NILP (window
); window
= w
->next
)
6094 p
= SAVED_WINDOW_N (vector
, i
);
6095 w
= XWINDOW (window
);
6097 XSETFASTINT (w
->temslot
, i
); i
++;
6099 p
->buffer
= w
->buffer
;
6100 p
->left_col
= w
->left_col
;
6101 p
->top_line
= w
->top_line
;
6102 p
->total_cols
= w
->total_cols
;
6103 p
->total_lines
= w
->total_lines
;
6104 p
->hscroll
= w
->hscroll
;
6105 p
->min_hscroll
= w
->min_hscroll
;
6106 p
->display_table
= w
->display_table
;
6107 p
->orig_top_line
= w
->orig_top_line
;
6108 p
->orig_total_lines
= w
->orig_total_lines
;
6109 p
->left_margin_cols
= w
->left_margin_cols
;
6110 p
->right_margin_cols
= w
->right_margin_cols
;
6111 p
->left_fringe_width
= w
->left_fringe_width
;
6112 p
->right_fringe_width
= w
->right_fringe_width
;
6113 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6114 p
->scroll_bar_width
= w
->scroll_bar_width
;
6115 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6116 if (!NILP (w
->buffer
))
6118 /* Save w's value of point in the window configuration.
6119 If w is the selected window, then get the value of point
6120 from the buffer; pointm is garbage in the selected window. */
6121 if (EQ (window
, selected_window
))
6123 p
->pointm
= Fmake_marker ();
6124 set_marker_both (p
->pointm
, w
->buffer
,
6125 BUF_PT (XBUFFER (w
->buffer
)),
6126 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6129 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6131 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6132 p
->start_at_line_beg
= w
->start_at_line_beg
;
6134 tem
= XBUFFER (w
->buffer
)->mark
;
6135 p
->mark
= Fcopy_marker (tem
, Qnil
);
6142 p
->start_at_line_beg
= Qnil
;
6145 if (NILP (w
->parent
))
6148 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6153 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6155 if (!NILP (w
->vchild
))
6156 i
= save_window_save (w
->vchild
, vector
, i
);
6157 if (!NILP (w
->hchild
))
6158 i
= save_window_save (w
->hchild
, vector
, i
);
6164 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6165 Scurrent_window_configuration
, 0, 1, 0,
6166 doc
: /* Return an object representing the current window configuration of FRAME.
6167 If FRAME is nil or omitted, use the selected frame.
6168 This describes the number of windows, their sizes and current buffers,
6169 and for each displayed buffer, where display starts, and the positions of
6170 point and mark. An exception is made for point in the current buffer:
6171 its value is -not- saved.
6172 This also records the currently selected frame, and FRAME's focus
6173 redirection (see `redirect-frame-focus'). */)
6177 register Lisp_Object tem
;
6178 register int n_windows
;
6179 register struct save_window_data
*data
;
6180 register struct Lisp_Vector
*vec
;
6185 frame
= selected_frame
;
6186 CHECK_LIVE_FRAME (frame
);
6189 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6190 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6191 data
= (struct save_window_data
*)vec
;
6193 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6194 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6195 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6196 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6197 data
->selected_frame
= selected_frame
;
6198 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6199 XSETBUFFER (data
->current_buffer
, current_buffer
);
6200 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6201 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6202 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6203 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6204 XSETINT (data
->min_height
, window_min_height
);
6205 XSETINT (data
->min_width
, window_min_width
);
6206 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6207 data
->saved_windows
= tem
;
6208 for (i
= 0; i
< n_windows
; i
++)
6209 XVECTOR (tem
)->contents
[i
]
6210 = Fmake_vector (make_number (VECSIZE (struct saved_window
)), Qnil
);
6211 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6212 XSETWINDOW_CONFIGURATION (tem
, data
);
6216 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6218 doc
: /* Execute BODY, preserving window sizes and contents.
6219 Return the value of the last form in BODY.
6220 Restore which buffer appears in which window, where display starts,
6221 and the value of point and mark for each window.
6222 Also restore the choice of selected window.
6223 Also restore which buffer is current.
6224 Does not restore the value of point in current buffer.
6225 usage: (save-window-excursion BODY ...) */)
6229 register Lisp_Object val
;
6230 register int count
= SPECPDL_INDEX ();
6232 record_unwind_protect (Fset_window_configuration
,
6233 Fcurrent_window_configuration (Qnil
));
6234 val
= Fprogn (args
);
6235 return unbind_to (count
, val
);
6240 /***********************************************************************
6242 ***********************************************************************/
6248 Lisp_Object tail
= Qnil
;
6249 Lisp_Object result
= Qnil
;
6256 if (!NILP (w
->hchild
))
6257 wn
= Fcons (Qnil
, Fcons (Fwindow_edges (wn
),
6258 window_tree (XWINDOW (w
->hchild
))));
6259 else if (!NILP (w
->vchild
))
6260 wn
= Fcons (Qt
, Fcons (Fwindow_edges (wn
),
6261 window_tree (XWINDOW (w
->vchild
))));
6265 result
= tail
= Fcons (wn
, Qnil
);
6269 XSETCDR (tail
, Fcons (wn
, Qnil
));
6273 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6281 DEFUN ("window-tree", Fwindow_tree
, Swindow_tree
,
6283 doc
: /* Return the window tree for frame FRAME.
6285 The return value is a list of the form (ROOT MINI), where ROOT
6286 represents the window tree of the frame's root window, and MINI
6287 is the frame's minibuffer window.
6289 If the root window is not split, ROOT is the root window itself.
6290 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil for a
6291 horizontal split, and t for a vertical split, EDGES gives the combined
6292 size and position of the subwindows in the split, and the rest of the
6293 elements are the subwindows in the split. Each of the subwindows may
6294 again be a window or a list representing a window split, and so on.
6295 EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
6297 If FRAME is nil or omitted, return information on the currently
6305 frame
= selected_frame
;
6307 CHECK_FRAME (frame
);
6310 if (!FRAME_LIVE_P (f
))
6313 return window_tree (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6317 /***********************************************************************
6319 ***********************************************************************/
6321 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6323 doc
: /* Set width of marginal areas of window WINDOW.
6324 If WINDOW is nil, set margins of the currently selected window.
6325 Second arg LEFT-WIDTH specifies the number of character cells to
6326 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6327 does the same for the right marginal area. A nil width parameter
6328 means no margin. */)
6329 (window
, left_width
, right_width
)
6330 Lisp_Object window
, left_width
, right_width
;
6332 struct window
*w
= decode_window (window
);
6334 /* Translate negative or zero widths to nil.
6335 Margins that are too wide have to be checked elsewhere. */
6337 if (!NILP (left_width
))
6339 CHECK_NUMBER (left_width
);
6340 if (XINT (left_width
) <= 0)
6344 if (!NILP (right_width
))
6346 CHECK_NUMBER (right_width
);
6347 if (XINT (right_width
) <= 0)
6351 if (!EQ (w
->left_margin_cols
, left_width
)
6352 || !EQ (w
->right_margin_cols
, right_width
))
6354 w
->left_margin_cols
= left_width
;
6355 w
->right_margin_cols
= right_width
;
6357 adjust_window_margins (w
);
6359 ++windows_or_buffers_changed
;
6360 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6367 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6369 doc
: /* Get width of marginal areas of window WINDOW.
6370 If WINDOW is omitted or nil, use the currently selected window.
6371 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6372 If a marginal area does not exist, its width will be returned
6377 struct window
*w
= decode_window (window
);
6378 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6383 /***********************************************************************
6385 ***********************************************************************/
6387 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6389 doc
: /* Set the fringe widths of window WINDOW.
6390 If WINDOW is nil, set the fringe widths of the currently selected
6392 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6393 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6394 fringe width. If a fringe width arg is nil, that means to use the
6395 frame's default fringe width. Default fringe widths can be set with
6396 the command `set-fringe-style'.
6397 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6398 outside of the display margins. By default, fringes are drawn between
6399 display marginal areas and the text area. */)
6400 (window
, left_width
, right_width
, outside_margins
)
6401 Lisp_Object window
, left_width
, right_width
, outside_margins
;
6403 struct window
*w
= decode_window (window
);
6405 if (!NILP (left_width
))
6406 CHECK_NATNUM (left_width
);
6407 if (!NILP (right_width
))
6408 CHECK_NATNUM (right_width
);
6410 if (!EQ (w
->left_fringe_width
, left_width
)
6411 || !EQ (w
->right_fringe_width
, right_width
)
6412 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6414 w
->left_fringe_width
= left_width
;
6415 w
->right_fringe_width
= right_width
;
6416 w
->fringes_outside_margins
= outside_margins
;
6418 adjust_window_margins (w
);
6420 clear_glyph_matrix (w
->current_matrix
);
6421 w
->window_end_valid
= Qnil
;
6423 ++windows_or_buffers_changed
;
6424 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6431 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6433 doc
: /* Get width of fringes of window WINDOW.
6434 If WINDOW is omitted or nil, use the currently selected window.
6435 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6439 struct window
*w
= decode_window (window
);
6440 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6441 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6442 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6443 Qt
: Qnil
), Qnil
)));
6448 /***********************************************************************
6450 ***********************************************************************/
6452 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6454 doc
: /* Set width and type of scroll bars of window WINDOW.
6455 If window is nil, set scroll bars of the currently selected window.
6456 Second parameter WIDTH specifies the pixel width for the scroll bar;
6457 this is automatically adjusted to a multiple of the frame column width.
6458 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6459 bar: left, right, or nil.
6460 If WIDTH is nil, use the frame's scroll-bar width.
6461 If TYPE is t, use the frame's scroll-bar type. */)
6462 (window
, width
, vertical_type
, horizontal_type
)
6463 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6465 struct window
*w
= decode_window (window
);
6469 CHECK_NATNUM (width
);
6471 if (XINT (width
) == 0)
6472 vertical_type
= Qnil
;
6475 if (!(EQ (vertical_type
, Qnil
)
6476 || EQ (vertical_type
, Qleft
)
6477 || EQ (vertical_type
, Qright
)
6478 || EQ (vertical_type
, Qt
)))
6479 error ("Invalid type of vertical scroll bar");
6481 if (!EQ (w
->scroll_bar_width
, width
)
6482 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6484 w
->scroll_bar_width
= width
;
6485 w
->vertical_scroll_bar_type
= vertical_type
;
6487 adjust_window_margins (w
);
6489 clear_glyph_matrix (w
->current_matrix
);
6490 w
->window_end_valid
= Qnil
;
6492 ++windows_or_buffers_changed
;
6493 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6500 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6502 doc
: /* Get width and type of scroll bars of window WINDOW.
6503 If WINDOW is omitted or nil, use the currently selected window.
6504 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6505 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6510 struct window
*w
= decode_window (window
);
6511 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6512 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6513 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6514 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6515 Fcons (w
->vertical_scroll_bar_type
,
6516 Fcons (Qnil
, Qnil
))));
6521 /***********************************************************************
6523 ***********************************************************************/
6525 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6526 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6527 Use the selected window if WINDOW is nil or omitted.
6528 Normally, value is a multiple of the canonical character height of WINDOW;
6529 optional second arg PIXELS_P means value is measured in pixels. */)
6531 Lisp_Object window
, pixels_p
;
6538 window
= selected_window
;
6540 CHECK_WINDOW (window
);
6541 w
= XWINDOW (window
);
6542 f
= XFRAME (w
->frame
);
6544 if (FRAME_WINDOW_P (f
))
6545 result
= (NILP (pixels_p
)
6546 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6547 : make_number (-w
->vscroll
));
6549 result
= make_number (0);
6554 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6556 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6557 WINDOW nil means use the selected window. Normally, VSCROLL is a
6558 non-negative multiple of the canonical character height of WINDOW;
6559 optional third arg PIXELS_P non-nil means that VSCROLL is in pixels.
6560 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6561 corresponds to an integral number of pixels. The return value is the
6562 result of this rounding.
6563 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6564 (window
, vscroll
, pixels_p
)
6565 Lisp_Object window
, vscroll
, pixels_p
;
6571 window
= selected_window
;
6573 CHECK_WINDOW (window
);
6574 CHECK_NUMBER_OR_FLOAT (vscroll
);
6576 w
= XWINDOW (window
);
6577 f
= XFRAME (w
->frame
);
6579 if (FRAME_WINDOW_P (f
))
6581 int old_dy
= w
->vscroll
;
6583 w
->vscroll
= - (NILP (pixels_p
)
6584 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6585 : XFLOATINT (vscroll
));
6586 w
->vscroll
= min (w
->vscroll
, 0);
6588 if (w
->vscroll
!= old_dy
)
6590 /* Adjust glyph matrix of the frame if the virtual display
6591 area becomes larger than before. */
6592 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6595 /* Prevent redisplay shortcuts. */
6596 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6600 return Fwindow_vscroll (window
, pixels_p
);
6604 /* Call FN for all leaf windows on frame F. FN is called with the
6605 first argument being a pointer to the leaf window, and with
6606 additional argument USER_DATA. Stops when FN returns 0. */
6609 foreach_window (f
, fn
, user_data
)
6611 int (* fn
) P_ ((struct window
*, void *));
6614 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6618 /* Helper function for foreach_window. Call FN for all leaf windows
6619 reachable from W. FN is called with the first argument being a
6620 pointer to the leaf window, and with additional argument USER_DATA.
6621 Stop when FN returns 0. Value is 0 if stopped by FN. */
6624 foreach_window_1 (w
, fn
, user_data
)
6626 int (* fn
) P_ ((struct window
*, void *));
6631 for (cont
= 1; w
&& cont
;)
6633 if (!NILP (w
->hchild
))
6634 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6635 else if (!NILP (w
->vchild
))
6636 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6638 cont
= fn (w
, user_data
);
6640 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6647 /* Freeze or unfreeze the window start of W unless it is a
6648 mini-window or the selected window. FREEZE_P non-null means freeze
6649 the window start. */
6652 freeze_window_start (w
, freeze_p
)
6656 if (w
== XWINDOW (selected_window
)
6657 || MINI_WINDOW_P (w
)
6658 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6659 && ! NILP (Vminibuf_scroll_window
)
6660 && w
== XWINDOW (Vminibuf_scroll_window
)))
6663 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6668 /* Freeze or unfreeze the window starts of all leaf windows on frame
6669 F, except the selected window and a mini-window. FREEZE_P non-zero
6670 means freeze the window start. */
6673 freeze_window_starts (f
, freeze_p
)
6677 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6681 /***********************************************************************
6683 ***********************************************************************/
6685 /* Return 1 if window configurations C1 and C2
6686 describe the same state of affairs. This is used by Fequal. */
6689 compare_window_configurations (c1
, c2
, ignore_positions
)
6691 int ignore_positions
;
6693 register struct save_window_data
*d1
, *d2
;
6694 struct Lisp_Vector
*sw1
, *sw2
;
6697 if (!WINDOW_CONFIGURATIONP (c1
))
6698 wrong_type_argument (Qwindow_configuration_p
, c1
);
6699 if (!WINDOW_CONFIGURATIONP (c2
))
6700 wrong_type_argument (Qwindow_configuration_p
, c2
);
6702 d1
= (struct save_window_data
*) XVECTOR (c1
);
6703 d2
= (struct save_window_data
*) XVECTOR (c2
);
6704 sw1
= XVECTOR (d1
->saved_windows
);
6705 sw2
= XVECTOR (d2
->saved_windows
);
6707 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6709 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6711 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6713 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6715 /* Don't compare the current_window field directly.
6716 Instead see w1_is_current and w2_is_current, below. */
6717 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6719 if (! ignore_positions
)
6721 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6723 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6726 /* Don't compare the root_window field.
6727 We don't require the two configurations
6728 to use the same window object,
6729 and the two root windows must be equivalent
6730 if everything else compares equal. */
6731 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6733 if (! EQ (d1
->min_width
, d2
->min_width
))
6735 if (! EQ (d1
->min_height
, d2
->min_height
))
6738 /* Verify that the two confis have the same number of windows. */
6739 if (sw1
->size
!= sw2
->size
)
6742 for (i
= 0; i
< sw1
->size
; i
++)
6744 struct saved_window
*p1
, *p2
;
6745 int w1_is_current
, w2_is_current
;
6747 p1
= SAVED_WINDOW_N (sw1
, i
);
6748 p2
= SAVED_WINDOW_N (sw2
, i
);
6750 /* Verify that the current windows in the two
6751 configurations correspond to each other. */
6752 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6753 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6755 if (w1_is_current
!= w2_is_current
)
6758 /* Verify that the corresponding windows do match. */
6759 if (! EQ (p1
->buffer
, p2
->buffer
))
6761 if (! EQ (p1
->left_col
, p2
->left_col
))
6763 if (! EQ (p1
->top_line
, p2
->top_line
))
6765 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6767 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6769 if (! EQ (p1
->display_table
, p2
->display_table
))
6771 if (! EQ (p1
->parent
, p2
->parent
))
6773 if (! EQ (p1
->prev
, p2
->prev
))
6775 if (! ignore_positions
)
6777 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6779 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6781 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6783 if (NILP (Fequal (p1
->start
, p2
->start
)))
6785 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6787 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6790 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6792 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6794 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6796 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6798 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6800 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6802 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6809 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6810 Scompare_window_configurations
, 2, 2, 0,
6811 doc
: /* Compare two window configurations as regards the structure of windows.
6812 This function ignores details such as the values of point and mark
6813 and scrolling positions. */)
6817 if (compare_window_configurations (x
, y
, 1))
6825 struct frame
*f
= make_terminal_frame ();
6826 XSETFRAME (selected_frame
, f
);
6827 Vterminal_frame
= selected_frame
;
6828 minibuf_window
= f
->minibuffer_window
;
6829 selected_window
= f
->selected_window
;
6830 last_nonminibuf_frame
= f
;
6832 window_initialized
= 1;
6838 Vwindow_list
= Qnil
;
6844 Qwindow_size_fixed
= intern ("window-size-fixed");
6845 staticpro (&Qwindow_size_fixed
);
6846 Fset (Qwindow_size_fixed
, Qnil
);
6848 staticpro (&Qwindow_configuration_change_hook
);
6849 Qwindow_configuration_change_hook
6850 = intern ("window-configuration-change-hook");
6852 Qwindowp
= intern ("windowp");
6853 staticpro (&Qwindowp
);
6855 Qwindow_configuration_p
= intern ("window-configuration-p");
6856 staticpro (&Qwindow_configuration_p
);
6858 Qwindow_live_p
= intern ("window-live-p");
6859 staticpro (&Qwindow_live_p
);
6861 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
6862 staticpro (&Qtemp_buffer_show_hook
);
6864 staticpro (&Vwindow_list
);
6866 minibuf_selected_window
= Qnil
;
6867 staticpro (&minibuf_selected_window
);
6869 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
6870 doc
: /* Non-nil means call as function to display a help buffer.
6871 The function is called with one argument, the buffer to be displayed.
6872 Used by `with-output-to-temp-buffer'.
6873 If this function is used, then it must do the entire job of showing
6874 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6875 Vtemp_buffer_show_function
= Qnil
;
6877 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
6878 doc
: /* If non-nil, function to call to handle `display-buffer'.
6879 It will receive two args, the buffer and a flag which if non-nil means
6880 that the currently selected window is not acceptable.
6881 It should choose or create a window, display the specified buffer in it,
6882 and return the window.
6883 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
6884 work using this function. */);
6885 Vdisplay_buffer_function
= Qnil
;
6887 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
6888 doc
: /* *If non-nil, `display-buffer' should even the window heights.
6889 If nil, `display-buffer' will leave the window configuration alone. */);
6890 Veven_window_heights
= Qt
;
6892 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
6893 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6894 Vminibuf_scroll_window
= Qnil
;
6896 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
6897 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6898 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6899 is displayed in the `mode-line' face. */);
6900 mode_line_in_non_selected_windows
= 1;
6902 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
6903 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6904 Vother_window_scroll_buffer
= Qnil
;
6906 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
6907 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
6910 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
6911 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6912 auto_window_vscroll_p
= 1;
6914 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
6915 doc
: /* *Non-nil means `display-buffer' should reuse frames.
6916 If the buffer in question is already displayed in a frame, raise that frame. */);
6917 display_buffer_reuse_frames
= 0;
6919 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
6920 doc
: /* Function to call to handle automatic new frame creation.
6921 It is called with no arguments and should return a newly created frame.
6923 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
6924 where `pop-up-frame-alist' would hold the default frame parameters. */);
6925 Vpop_up_frame_function
= Qnil
;
6927 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
6928 doc
: /* *List of buffer names that should have their own special frames.
6929 Displaying a buffer with `display-buffer' or `pop-to-buffer',
6930 if its name is in this list, makes a special frame for it
6931 using `special-display-function'. See also `special-display-regexps'.
6933 An element of the list can be a list instead of just a string.
6934 There are two ways to use a list as an element:
6935 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
6936 In the first case, the FRAME-PARAMETERS are pairs of the form
6937 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6938 In the second case, FUNCTION is called with BUFFER as the first argument,
6939 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
6940 All this is done by the function found in `special-display-function'.
6942 If the specified frame parameters include (same-buffer . t), the
6943 buffer is displayed in the currently selected window. Otherwise, if
6944 they include (same-frame . t), the buffer is displayed in a new window
6945 in the currently selected frame.
6947 If this variable appears \"not to work\", because you add a name to it
6948 but that buffer still appears in the selected window, look at the
6949 values of `same-window-buffer-names' and `same-window-regexps'.
6950 Those variables take precedence over this one. */);
6951 Vspecial_display_buffer_names
= Qnil
;
6953 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
6954 doc
: /* *List of regexps saying which buffers should have their own special frames.
6955 When displaying a buffer with `display-buffer' or `pop-to-buffer',
6956 if any regexp in this list matches the buffer name, it makes a
6957 special frame for the buffer by calling `special-display-function'.
6959 An element of the list can be a list instead of just a string.
6960 There are two ways to use a list as an element:
6961 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
6962 In the first case, the FRAME-PARAMETERS are pairs of the form
6963 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6964 In the second case, FUNCTION is called with BUFFER as the first argument,
6965 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
6966 All this is done by the function found in `special-display-function'.
6968 If the specified frame parameters include (same-buffer . t), the
6969 buffer is displayed in the currently selected window. Otherwise, if
6970 they include (same-frame . t), the buffer is displayed in a new window
6971 in the currently selected frame.
6973 If this variable appears \"not to work\", because you add a regexp to it
6974 but the matching buffers still appear in the selected window, look at the
6975 values of `same-window-buffer-names' and `same-window-regexps'.
6976 Those variables take precedence over this one. */);
6977 Vspecial_display_regexps
= Qnil
;
6979 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
6980 doc
: /* Function to call to make a new frame for a special buffer.
6981 It is called with two arguments, the buffer and optional buffer specific
6982 data, and should return a window displaying that buffer.
6983 The default value normally makes a separate frame for the buffer,
6984 using `special-display-frame-alist' to specify the frame parameters.
6985 But if the buffer specific data includes (same-buffer . t) then the
6986 buffer is displayed in the current selected window.
6987 Otherwise if it includes (same-frame . t) then the buffer is displayed in
6988 a new window in the currently selected frame.
6990 A buffer is special if it is listed in `special-display-buffer-names'
6991 or matches a regexp in `special-display-regexps'. */);
6992 Vspecial_display_function
= Qnil
;
6994 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
6995 doc
: /* *List of buffer names that should appear in the selected window.
6996 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
6997 switches to it in the selected window, rather than making it appear
6998 in some other window.
7000 An element of the list can be a cons cell instead of just a string.
7001 Then the car must be a string, which specifies the buffer name.
7002 This is for compatibility with `special-display-buffer-names';
7003 the cdr of the cons cell is ignored.
7005 See also `same-window-regexps'. */);
7006 Vsame_window_buffer_names
= Qnil
;
7008 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
7009 doc
: /* *List of regexps saying which buffers should appear in the selected window.
7010 If a buffer name matches one of these regexps, then displaying it
7011 using `display-buffer' or `pop-to-buffer' switches to it
7012 in the selected window, rather than making it appear in some other window.
7014 An element of the list can be a cons cell instead of just a string.
7015 Then the car must be a string, which specifies the buffer name.
7016 This is for compatibility with `special-display-buffer-names';
7017 the cdr of the cons cell is ignored.
7019 See also `same-window-buffer-names'. */);
7020 Vsame_window_regexps
= Qnil
;
7022 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
7023 doc
: /* *Non-nil means display-buffer should make new windows. */);
7026 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
7027 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
7028 next_screen_context_lines
= 2;
7030 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
7031 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
7032 If there is only one window, it is split regardless of this value. */);
7033 split_height_threshold
= 500;
7035 DEFVAR_INT ("window-min-height", &window_min_height
,
7036 doc
: /* *Delete any window less than this tall (including its mode line). */);
7037 window_min_height
= 4;
7039 DEFVAR_INT ("window-min-width", &window_min_width
,
7040 doc
: /* *Delete any window less than this wide. */);
7041 window_min_width
= 10;
7043 DEFVAR_LISP ("scroll-preserve-screen-position",
7044 &Vscroll_preserve_screen_position
,
7045 doc
: /* *Controls if scroll commands move point to keep its screen line unchanged.
7046 A value of nil means point does not keep its screen position except
7047 at the scroll margin or window boundary respectively.
7048 A value of t means point keeps its screen position if the scroll
7049 command moved it vertically out of the window, e.g. when scrolling
7051 Any other value means point always keeps its screen position. */);
7052 Vscroll_preserve_screen_position
= Qnil
;
7054 DEFVAR_LISP ("window-configuration-change-hook",
7055 &Vwindow_configuration_change_hook
,
7056 doc
: /* Functions to call when window configuration changes.
7057 The selected frame is the one whose configuration has changed. */);
7058 Vwindow_configuration_change_hook
= Qnil
;
7060 defsubr (&Sselected_window
);
7061 defsubr (&Sminibuffer_window
);
7062 defsubr (&Swindow_minibuffer_p
);
7063 defsubr (&Swindowp
);
7064 defsubr (&Swindow_live_p
);
7065 defsubr (&Spos_visible_in_window_p
);
7066 defsubr (&Swindow_buffer
);
7067 defsubr (&Swindow_height
);
7068 defsubr (&Swindow_width
);
7069 defsubr (&Swindow_hscroll
);
7070 defsubr (&Sset_window_hscroll
);
7071 defsubr (&Swindow_redisplay_end_trigger
);
7072 defsubr (&Sset_window_redisplay_end_trigger
);
7073 defsubr (&Swindow_edges
);
7074 defsubr (&Swindow_pixel_edges
);
7075 defsubr (&Swindow_inside_edges
);
7076 defsubr (&Swindow_inside_pixel_edges
);
7077 defsubr (&Scoordinates_in_window_p
);
7078 defsubr (&Swindow_at
);
7079 defsubr (&Swindow_point
);
7080 defsubr (&Swindow_start
);
7081 defsubr (&Swindow_end
);
7082 defsubr (&Sset_window_point
);
7083 defsubr (&Sset_window_start
);
7084 defsubr (&Swindow_dedicated_p
);
7085 defsubr (&Sset_window_dedicated_p
);
7086 defsubr (&Swindow_display_table
);
7087 defsubr (&Sset_window_display_table
);
7088 defsubr (&Snext_window
);
7089 defsubr (&Sprevious_window
);
7090 defsubr (&Sother_window
);
7091 defsubr (&Sget_lru_window
);
7092 defsubr (&Sget_largest_window
);
7093 defsubr (&Sget_buffer_window
);
7094 defsubr (&Sdelete_other_windows
);
7095 defsubr (&Sdelete_windows_on
);
7096 defsubr (&Sreplace_buffer_in_windows
);
7097 defsubr (&Sdelete_window
);
7098 defsubr (&Sset_window_buffer
);
7099 defsubr (&Sselect_window
);
7100 defsubr (&Sspecial_display_p
);
7101 defsubr (&Ssame_window_p
);
7102 defsubr (&Sdisplay_buffer
);
7103 defsubr (&Sforce_window_update
);
7104 defsubr (&Ssplit_window
);
7105 defsubr (&Senlarge_window
);
7106 defsubr (&Sshrink_window
);
7107 defsubr (&Sscroll_up
);
7108 defsubr (&Sscroll_down
);
7109 defsubr (&Sscroll_left
);
7110 defsubr (&Sscroll_right
);
7111 defsubr (&Sother_window_for_scrolling
);
7112 defsubr (&Sscroll_other_window
);
7113 defsubr (&Sminibuffer_selected_window
);
7114 defsubr (&Srecenter
);
7115 defsubr (&Swindow_text_height
);
7116 defsubr (&Smove_to_window_line
);
7117 defsubr (&Swindow_configuration_p
);
7118 defsubr (&Swindow_configuration_frame
);
7119 defsubr (&Sset_window_configuration
);
7120 defsubr (&Scurrent_window_configuration
);
7121 defsubr (&Ssave_window_excursion
);
7122 defsubr (&Swindow_tree
);
7123 defsubr (&Sset_window_margins
);
7124 defsubr (&Swindow_margins
);
7125 defsubr (&Sset_window_fringes
);
7126 defsubr (&Swindow_fringes
);
7127 defsubr (&Sset_window_scroll_bars
);
7128 defsubr (&Swindow_scroll_bars
);
7129 defsubr (&Swindow_vscroll
);
7130 defsubr (&Sset_window_vscroll
);
7131 defsubr (&Scompare_window_configurations
);
7132 defsubr (&Swindow_list
);
7138 initial_define_key (control_x_map
, '1', "delete-other-windows");
7139 initial_define_key (control_x_map
, '2', "split-window");
7140 initial_define_key (control_x_map
, '0', "delete-window");
7141 initial_define_key (control_x_map
, 'o', "other-window");
7142 initial_define_key (control_x_map
, '^', "enlarge-window");
7143 initial_define_key (control_x_map
, '<', "scroll-left");
7144 initial_define_key (control_x_map
, '>', "scroll-right");
7146 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
7147 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
7148 initial_define_key (meta_map
, 'v', "scroll-down");
7150 initial_define_key (global_map
, Ctl('L'), "recenter");
7151 initial_define_key (meta_map
, 'r', "move-to-window-line");
7154 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
7155 (do not change this comment) */