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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
52 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
53 Lisp_Object Qwindow_size_fixed
;
54 extern Lisp_Object Qleft_margin
, Qright_margin
;
56 static int displayed_window_lines
P_ ((struct window
*));
57 static struct window
*decode_window
P_ ((Lisp_Object
));
58 static int count_windows
P_ ((struct window
*));
59 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
60 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
61 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
62 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
63 static int window_min_size_1
P_ ((struct window
*, int));
64 static int window_min_size
P_ ((struct window
*, int, int, int *));
65 static void size_window
P_ ((Lisp_Object
, int, int, int));
66 static int freeze_window_start
P_ ((struct window
*, void *));
67 static int window_fixed_size_p
P_ ((struct window
*, int, int));
68 static void enlarge_window
P_ ((Lisp_Object
, int, int, int));
69 static Lisp_Object window_list
P_ ((void));
70 static int add_window_to_list
P_ ((struct window
*, void *));
71 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
73 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
75 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
77 static int foreach_window_1
P_ ((struct window
*,
78 int (* fn
) (struct window
*, void *),
80 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
82 /* 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
->height_fixed_p
= 0;
277 p
->last_cursor_off_p
= p
->cursor_off_p
= 0;
278 p
->left_margin_cols
= Qnil
;
279 p
->right_margin_cols
= Qnil
;
280 p
->left_fringe_width
= Qnil
;
281 p
->right_fringe_width
= Qnil
;
282 p
->fringes_outside_margins
= Qnil
;
283 p
->scroll_bar_width
= Qnil
;
284 p
->vertical_scroll_bar_type
= Qt
;
290 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
291 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
294 return selected_window
;
297 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
298 doc
: /* Return the window used now for minibuffers.
299 If the optional argument FRAME is specified, return the minibuffer window
300 used by that frame. */)
305 frame
= selected_frame
;
306 CHECK_LIVE_FRAME (frame
);
307 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
310 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
311 doc
: /* Returns non-nil if WINDOW is a minibuffer window.
312 WINDOW defaults to the selected window. */)
316 struct window
*w
= decode_window (window
);
317 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
321 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
322 Spos_visible_in_window_p
, 0, 3, 0,
323 doc
: /* Return non-nil if position POS is currently on the frame in WINDOW.
324 Return nil if that position is scrolled vertically out of view.
325 If a character is only partially visible, nil is returned, unless the
326 optional argument PARTIALLY is non-nil.
327 If POS is only out of view because of horizontal scrolling, return non-nil.
328 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
330 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
331 return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
332 relative to the top left corner of the window. PARTIAL is nil if the character
333 after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
334 and RBOT are the number of pixels invisible at the top and bottom of the row. */)
335 (pos
, window
, partially
)
336 Lisp_Object pos
, window
, partially
;
338 register struct window
*w
;
340 register struct buffer
*buf
;
342 Lisp_Object in_window
= Qnil
;
343 int rtop
, rbot
, fully_p
= 1;
346 w
= decode_window (window
);
347 buf
= XBUFFER (w
->buffer
);
348 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
352 CHECK_NUMBER_COERCE_MARKER (pos
);
355 else if (w
== XWINDOW (selected_window
))
358 posint
= XMARKER (w
->pointm
)->charpos
;
360 /* If position is above window start or outside buffer boundaries,
361 or if window start is out of range, position is not visible. */
362 if (posint
>= CHARPOS (top
)
363 && posint
<= BUF_ZV (buf
)
364 && CHARPOS (top
) >= BUF_BEGV (buf
)
365 && CHARPOS (top
) <= BUF_ZV (buf
)
366 && pos_visible_p (w
, posint
, &x
, &y
, &rtop
, &rbot
, NILP (partially
))
367 && (fully_p
= !rtop
&& !rbot
, (!NILP (partially
) || fully_p
)))
370 if (!NILP (in_window
) && !NILP (partially
))
371 in_window
= Fcons (make_number (x
),
372 Fcons (make_number (y
),
373 Fcons ((fully_p
? Qnil
374 : Fcons (make_number (rtop
),
375 make_number (rbot
))),
381 static struct window
*
382 decode_window (window
)
383 register Lisp_Object window
;
386 return XWINDOW (selected_window
);
388 CHECK_LIVE_WINDOW (window
);
389 return XWINDOW (window
);
392 static struct window
*
393 decode_any_window (window
)
394 register Lisp_Object window
;
397 return XWINDOW (selected_window
);
399 CHECK_WINDOW (window
);
400 return XWINDOW (window
);
403 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
404 doc
: /* Return the buffer that WINDOW is displaying.
405 WINDOW defaults to the selected window. */)
409 return decode_window (window
)->buffer
;
412 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
413 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
417 return decode_any_window (window
)->total_lines
;
420 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
421 doc
: /* Return the number of display columns in WINDOW.
422 This is the width that is usable columns available for text in WINDOW.
423 If you want to find out how many columns WINDOW takes up,
424 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
428 return make_number (window_box_text_cols (decode_any_window (window
)));
431 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
432 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
436 return decode_window (window
)->hscroll
;
439 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
440 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
441 Return NCOL. NCOL should be zero or positive.
443 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
444 window so that the location of point becomes invisible. */)
446 Lisp_Object window
, ncol
;
448 struct window
*w
= decode_window (window
);
452 hscroll
= max (0, XINT (ncol
));
454 /* Prevent redisplay shortcuts when changing the hscroll. */
455 if (XINT (w
->hscroll
) != hscroll
)
456 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
458 w
->hscroll
= make_number (hscroll
);
462 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
463 Swindow_redisplay_end_trigger
, 0, 1, 0,
464 doc
: /* Return WINDOW's redisplay end trigger value.
465 See `set-window-redisplay-end-trigger' for more information. */)
469 return decode_window (window
)->redisplay_end_trigger
;
472 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
473 Sset_window_redisplay_end_trigger
, 2, 2, 0,
474 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
475 VALUE should be a buffer position (typically a marker) or nil.
476 If it is a buffer position, then if redisplay in WINDOW reaches a position
477 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
478 with two arguments: WINDOW, and the end trigger value.
479 Afterwards the end-trigger value is reset to nil. */)
481 register Lisp_Object window
, value
;
483 register struct window
*w
;
485 w
= decode_window (window
);
486 w
->redisplay_end_trigger
= value
;
490 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
491 doc
: /* Return a list of the edge coordinates of WINDOW.
492 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
493 RIGHT is one more than the rightmost column occupied by WINDOW,
494 and BOTTOM is one more than the bottommost row occupied by WINDOW.
495 The edges include the space used by the window's scroll bar,
496 display margins, fringes, header line, and mode line, if it has them.
497 To get the edges of the actual text area, use `window-inside-edges'. */)
501 register struct window
*w
= decode_any_window (window
);
503 return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w
)),
504 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w
)),
505 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w
)),
506 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w
)),
510 DEFUN ("window-pixel-edges", Fwindow_pixel_edges
, Swindow_pixel_edges
, 0, 1, 0,
511 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
512 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
513 RIGHT is one more than the rightmost x position occupied by WINDOW,
514 and BOTTOM is one more than the bottommost y position occupied by WINDOW.
515 The pixel edges include the space used by the window's scroll bar,
516 display margins, fringes, header line, and mode line, if it has them.
517 To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
521 register struct window
*w
= decode_any_window (window
);
523 return Fcons (make_number (WINDOW_LEFT_EDGE_X (w
)),
524 Fcons (make_number (WINDOW_TOP_EDGE_Y (w
)),
525 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w
)),
526 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w
)),
530 DEFUN ("window-inside-edges", Fwindow_inside_edges
, Swindow_inside_edges
, 0, 1, 0,
531 doc
: /* Return a list of the edge coordinates of WINDOW.
532 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
533 RIGHT is one more than the rightmost column used by text in WINDOW,
534 and BOTTOM is one more than the bottommost row used by text in WINDOW.
535 The inside edges do not include the space used by the window's scroll bar,
536 display margins, fringes, header line, and/or mode line. */)
540 register struct window
*w
= decode_any_window (window
);
542 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w
)
543 + WINDOW_LEFT_MARGIN_COLS (w
)
544 + WINDOW_LEFT_FRINGE_COLS (w
)),
545 make_number (WINDOW_TOP_EDGE_LINE (w
)
546 + WINDOW_HEADER_LINE_LINES (w
)),
547 make_number (WINDOW_BOX_RIGHT_EDGE_COL (w
)
548 - WINDOW_RIGHT_MARGIN_COLS (w
)
549 - WINDOW_RIGHT_FRINGE_COLS (w
)),
550 make_number (WINDOW_BOTTOM_EDGE_LINE (w
)
551 - WINDOW_MODE_LINE_LINES (w
)));
554 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges
, Swindow_inside_pixel_edges
, 0, 1, 0,
555 doc
: /* Return a list of the edge pixel coordinates of WINDOW.
556 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
557 RIGHT is one more than the rightmost x position used by text in WINDOW,
558 and BOTTOM is one more than the bottommost y position used by text in WINDOW.
559 The inside edges do not include the space used by the window's scroll bar,
560 display margins, fringes, header line, and/or mode line. */)
564 register struct window
*w
= decode_any_window (window
);
566 return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w
)
567 + WINDOW_LEFT_MARGIN_WIDTH (w
)
568 + WINDOW_LEFT_FRINGE_WIDTH (w
)),
569 make_number (WINDOW_TOP_EDGE_Y (w
)
570 + WINDOW_HEADER_LINE_HEIGHT (w
)),
571 make_number (WINDOW_BOX_RIGHT_EDGE_X (w
)
572 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
573 - WINDOW_RIGHT_FRINGE_WIDTH (w
)),
574 make_number (WINDOW_BOTTOM_EDGE_Y (w
)
575 - WINDOW_MODE_LINE_HEIGHT (w
)));
578 /* Test if the character at column *X, row *Y is within window W.
579 If it is not, return ON_NOTHING;
580 if it is in the window's text area,
581 set *x and *y to its location relative to the upper left corner
584 if it is on the window's modeline, return ON_MODE_LINE;
585 if it is on the border between the window and its right sibling,
586 return ON_VERTICAL_BORDER.
587 if it is on a scroll bar,
588 return ON_SCROLL_BAR.
589 if it is on the window's top line, return ON_HEADER_LINE;
590 if it is in left or right fringe of the window,
591 return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
592 to window-relative coordinates;
593 if it is in the marginal area to the left/right of the window,
594 return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
595 to window-relative coordinates.
597 X and Y are frame relative pixel coordinates. */
599 static enum window_part
600 coordinates_in_window (w
, x
, y
)
601 register struct window
*w
;
604 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
605 int left_x
, right_x
, top_y
, bottom_y
;
606 enum window_part part
;
607 int ux
= FRAME_COLUMN_WIDTH (f
);
608 int x0
= WINDOW_LEFT_EDGE_X (w
);
609 int x1
= WINDOW_RIGHT_EDGE_X (w
);
610 /* The width of the area where the vertical line can be dragged.
611 (Between mode lines for instance. */
612 int grabbable_width
= ux
;
613 int lmargin_width
, rmargin_width
, text_left
, text_right
;
615 /* In what's below, we subtract 1 when computing right_x because we
616 want the rightmost pixel, which is given by left_pixel+width-1. */
617 if (w
->pseudo_window_p
)
620 right_x
= WINDOW_TOTAL_WIDTH (w
) - 1;
621 top_y
= WINDOW_TOP_EDGE_Y (w
);
622 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
626 left_x
= WINDOW_BOX_LEFT_EDGE_X (w
);
627 right_x
= WINDOW_BOX_RIGHT_EDGE_X (w
) - 1;
628 top_y
= WINDOW_TOP_EDGE_Y (w
);
629 bottom_y
= WINDOW_BOTTOM_EDGE_Y (w
);
632 /* Outside any interesting row? */
633 if (*y
< top_y
|| *y
>= bottom_y
)
636 /* On the mode line or header line? If it's near the start of
637 the mode or header line of window that's has a horizontal
638 sibling, say it's on the vertical line. That's to be able
639 to resize windows horizontally in case we're using toolkit
642 if (WINDOW_WANTS_MODELINE_P (w
)
643 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
))
647 header_vertical_border_check
:
648 /* We're somewhere on the mode line. We consider the place
649 between mode lines of horizontally adjacent mode lines
650 as the vertical border. If scroll bars on the left,
651 return the right window. */
652 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
653 || WINDOW_RIGHTMOST_P (w
))
655 if (!WINDOW_LEFTMOST_P (w
) && abs (*x
- x0
) < grabbable_width
)
656 return ON_VERTICAL_BORDER
;
660 if (abs (*x
- x1
) < grabbable_width
)
661 return ON_VERTICAL_BORDER
;
664 if (*x
< x0
|| *x
>= x1
)
667 /* Convert X and Y to window relative coordinates.
668 Mode line starts at left edge of window. */
674 if (WINDOW_WANTS_HEADER_LINE_P (w
)
675 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
))
677 part
= ON_HEADER_LINE
;
678 goto header_vertical_border_check
;
681 if (*x
< x0
|| *x
>= x1
)
684 /* Outside any interesting column? */
685 if (*x
< left_x
|| *x
> right_x
)
686 return ON_SCROLL_BAR
;
688 lmargin_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
689 rmargin_width
= window_box_width (w
, RIGHT_MARGIN_AREA
);
691 text_left
= window_box_left (w
, TEXT_AREA
);
692 text_right
= text_left
+ window_box_width (w
, TEXT_AREA
);
694 if (FRAME_WINDOW_P (f
))
696 if (!w
->pseudo_window_p
697 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
698 && !WINDOW_RIGHTMOST_P (w
)
699 && (abs (*x
- right_x
) < grabbable_width
))
700 return ON_VERTICAL_BORDER
;
704 /* Need to say "*x > right_x" rather than >=, since on character
705 terminals, the vertical line's x coordinate is right_x. */
706 if (!w
->pseudo_window_p
707 && !WINDOW_RIGHTMOST_P (w
)
708 && *x
> right_x
- ux
)
710 /* On the border on the right side of the window? Assume that
711 this area begins at RIGHT_X minus a canonical char width. */
712 return ON_VERTICAL_BORDER
;
718 if (lmargin_width
> 0
719 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
720 ? (*x
>= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
))
721 : (*x
< left_x
+ lmargin_width
)))
724 if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
725 *x
-= WINDOW_LEFT_FRINGE_WIDTH (w
);
727 return ON_LEFT_MARGIN
;
730 /* Convert X and Y to window-relative pixel coordinates. */
733 return ON_LEFT_FRINGE
;
736 if (*x
>= text_right
)
738 if (rmargin_width
> 0
739 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
740 ? (*x
< right_x
- WINDOW_RIGHT_FRINGE_WIDTH (w
))
741 : (*x
>= right_x
- rmargin_width
)))
744 if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
745 *x
-= WINDOW_RIGHT_FRINGE_WIDTH (w
);
747 return ON_RIGHT_MARGIN
;
750 /* Convert X and Y to window-relative pixel coordinates. */
751 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
753 return ON_RIGHT_FRINGE
;
756 /* Everything special ruled out - must be on text area */
757 *x
-= left_x
+ WINDOW_LEFT_FRINGE_WIDTH (w
);
763 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
764 Scoordinates_in_window_p
, 2, 2, 0,
765 doc
: /* Return non-nil if COORDINATES are in WINDOW.
766 COORDINATES is a cons of the form (X . Y), X and Y being distances
767 measured in characters from the upper-left corner of the frame.
768 \(0 . 0) denotes the character in the upper left corner of the
770 If COORDINATES are in the text portion of WINDOW,
771 the coordinates relative to the window are returned.
772 If they are in the mode line of WINDOW, `mode-line' is returned.
773 If they are in the top mode line of WINDOW, `header-line' is returned.
774 If they are in the left fringe of WINDOW, `left-fringe' is returned.
775 If they are in the right fringe of WINDOW, `right-fringe' is returned.
776 If they are on the border between WINDOW and its right sibling,
777 `vertical-line' is returned.
778 If they are in the windows's left or right marginal areas, `left-margin'\n\
779 or `right-margin' is returned. */)
780 (coordinates
, window
)
781 register Lisp_Object coordinates
, window
;
788 CHECK_WINDOW (window
);
789 w
= XWINDOW (window
);
790 f
= XFRAME (w
->frame
);
791 CHECK_CONS (coordinates
);
792 lx
= Fcar (coordinates
);
793 ly
= Fcdr (coordinates
);
794 CHECK_NUMBER_OR_FLOAT (lx
);
795 CHECK_NUMBER_OR_FLOAT (ly
);
796 x
= FRAME_PIXEL_X_FROM_CANON_X (f
, lx
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
797 y
= FRAME_PIXEL_Y_FROM_CANON_Y (f
, ly
) + FRAME_INTERNAL_BORDER_WIDTH (f
);
799 switch (coordinates_in_window (w
, &x
, &y
))
805 /* X and Y are now window relative pixel coordinates. Convert
806 them to canonical char units before returning them. */
807 return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f
, x
),
808 FRAME_CANON_Y_FROM_PIXEL_Y (f
, y
));
813 case ON_VERTICAL_BORDER
:
814 return Qvertical_line
;
822 case ON_RIGHT_FRINGE
:
823 return Qright_fringe
;
828 case ON_RIGHT_MARGIN
:
829 return Qright_margin
;
832 /* Historically we are supposed to return nil in this case. */
841 /* Callback for foreach_window, used in window_from_coordinates.
842 Check if window W contains coordinates specified by USER_DATA which
843 is actually a pointer to a struct check_window_data CW.
845 Check if window W contains coordinates *CW->x and *CW->y. If it
846 does, return W in *CW->window, as Lisp_Object, and return in
847 *CW->part the part of the window under coordinates *X,*Y. Return
848 zero from this function to stop iterating over windows. */
850 struct check_window_data
854 enum window_part
*part
;
858 check_window_containing (w
, user_data
)
862 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
863 enum window_part found
;
866 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
867 if (found
!= ON_NOTHING
)
870 XSETWINDOW (*cw
->window
, w
);
878 /* Find the window containing frame-relative pixel position X/Y and
879 return it as a Lisp_Object.
881 If X, Y is on one of the window's special `window_part' elements,
882 set *PART to the id of that element, and return X and Y converted
883 to window relative coordinates in WX and WY.
885 If there is no window under X, Y return nil and leave *PART
886 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
888 This function was previously implemented with a loop cycling over
889 windows with Fnext_window, and starting with the frame's selected
890 window. It turned out that this doesn't work with an
891 implementation of next_window using Vwindow_list, because
892 FRAME_SELECTED_WINDOW (F) is not always contained in the window
893 tree of F when this function is called asynchronously from
894 note_mouse_highlight. The original loop didn't terminate in this
898 window_from_coordinates (f
, x
, y
, part
, wx
, wy
, tool_bar_p
)
901 enum window_part
*part
;
906 struct check_window_data cw
;
907 enum window_part dummy
;
913 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
914 foreach_window (f
, check_window_containing
, &cw
);
916 /* If not found above, see if it's in the tool bar window, if a tool
920 && WINDOWP (f
->tool_bar_window
)
921 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0
922 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
926 window
= f
->tool_bar_window
;
935 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
936 doc
: /* Return window containing coordinates X and Y on FRAME.
937 If omitted, FRAME defaults to the currently selected frame.
938 The top left corner of the frame is considered to be row 0,
941 Lisp_Object x
, y
, frame
;
946 frame
= selected_frame
;
947 CHECK_LIVE_FRAME (frame
);
950 /* Check that arguments are integers or floats. */
951 CHECK_NUMBER_OR_FLOAT (x
);
952 CHECK_NUMBER_OR_FLOAT (y
);
954 return window_from_coordinates (f
,
955 (FRAME_PIXEL_X_FROM_CANON_X (f
, x
)
956 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
957 (FRAME_PIXEL_Y_FROM_CANON_Y (f
, y
)
958 + FRAME_INTERNAL_BORDER_WIDTH (f
)),
962 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
963 doc
: /* Return current value of point in WINDOW.
964 For a nonselected window, this is the value point would have
965 if that window were selected.
967 Note that, when WINDOW is the selected window and its buffer
968 is also currently selected, the value returned is the same as (point).
969 It would be more strictly correct to return the `top-level' value
970 of point, outside of any save-excursion forms.
971 But that is hard to define. */)
975 register struct window
*w
= decode_window (window
);
977 if (w
== XWINDOW (selected_window
)
978 && current_buffer
== XBUFFER (w
->buffer
))
980 return Fmarker_position (w
->pointm
);
983 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
984 doc
: /* Return position at which display currently starts in WINDOW.
985 This is updated by redisplay or by calling `set-window-start'. */)
989 return Fmarker_position (decode_window (window
)->start
);
992 /* This is text temporarily removed from the doc string below.
994 This function returns nil if the position is not currently known.
995 That happens when redisplay is preempted and doesn't finish.
996 If in that case you want to compute where the end of the window would
997 have been if redisplay had finished, do this:
999 (goto-char (window-start window))
1000 (vertical-motion (1- (window-height window)) window)
1003 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
1004 doc
: /* Return position at which display currently ends in WINDOW.
1005 This is updated by redisplay, when it runs to completion.
1006 Simply changing the buffer text or setting `window-start'
1007 does not update this value.
1008 Return nil if there is no recorded value. \(This can happen if the
1009 last redisplay of WINDOW was preempted, and did not finish.)
1010 If UPDATE is non-nil, compute the up-to-date position
1011 if it isn't already recorded. */)
1013 Lisp_Object window
, update
;
1016 struct window
*w
= decode_window (window
);
1022 #if 0 /* This change broke some things. We should make it later. */
1023 /* If we don't know the end position, return nil.
1024 The user can compute it with vertical-motion if he wants to.
1025 It would be nicer to do it automatically,
1026 but that's so slow that it would probably bother people. */
1027 if (NILP (w
->window_end_valid
))
1032 && ! (! NILP (w
->window_end_valid
)
1033 && XFASTINT (w
->last_modified
) >= MODIFF
))
1035 struct text_pos startp
;
1037 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
1039 /* In case W->start is out of the range, use something
1040 reasonable. This situation occurred when loading a file with
1041 `-l' containing a call to `rmail' with subsequent other
1042 commands. At the end, W->start happened to be BEG, while
1043 rmail had already narrowed the buffer. */
1044 if (XMARKER (w
->start
)->charpos
< BEGV
)
1045 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
1046 else if (XMARKER (w
->start
)->charpos
> ZV
)
1047 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
1049 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
1051 /* Cannot use Fvertical_motion because that function doesn't
1052 cope with variable-height lines. */
1053 if (b
!= current_buffer
)
1055 old_buffer
= current_buffer
;
1056 set_buffer_internal (b
);
1059 start_display (&it
, w
, startp
);
1060 move_it_vertically (&it
, window_box_height (w
));
1061 if (it
.current_y
< it
.last_visible_y
)
1062 move_it_past_eol (&it
);
1063 value
= make_number (IT_CHARPOS (it
));
1066 set_buffer_internal (old_buffer
);
1069 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
1074 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
1075 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
1078 Lisp_Object window
, pos
;
1080 register struct window
*w
= decode_window (window
);
1082 CHECK_NUMBER_COERCE_MARKER (pos
);
1083 if (w
== XWINDOW (selected_window
)
1084 && XBUFFER (w
->buffer
) == current_buffer
)
1087 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
1089 /* We have to make sure that redisplay updates the window to show
1090 the new value of point. */
1091 if (!EQ (window
, selected_window
))
1092 ++windows_or_buffers_changed
;
1097 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
1098 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
1100 Optional third arg NOFORCE non-nil inhibits next redisplay
1101 from overriding motion of point in order to display at this exact start. */)
1102 (window
, pos
, noforce
)
1103 Lisp_Object window
, pos
, noforce
;
1105 register struct window
*w
= decode_window (window
);
1107 CHECK_NUMBER_COERCE_MARKER (pos
);
1108 set_marker_restricted (w
->start
, pos
, w
->buffer
);
1109 /* this is not right, but much easier than doing what is right. */
1110 w
->start_at_line_beg
= Qnil
;
1112 w
->force_start
= Qt
;
1113 w
->update_mode_line
= Qt
;
1114 XSETFASTINT (w
->last_modified
, 0);
1115 XSETFASTINT (w
->last_overlay_modified
, 0);
1116 if (!EQ (window
, selected_window
))
1117 windows_or_buffers_changed
++;
1122 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
1124 doc
: /* Return WINDOW's dedicated object, usually t or nil.
1125 See also `set-window-dedicated-p'. */)
1129 return decode_window (window
)->dedicated
;
1132 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1133 Sset_window_dedicated_p
, 2, 2, 0,
1134 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1135 If it is dedicated, Emacs will not automatically change
1136 which buffer appears in it.
1137 The second argument is the new value for the dedication flag;
1138 non-nil means yes. */)
1140 Lisp_Object window
, arg
;
1142 register struct window
*w
= decode_window (window
);
1146 return w
->dedicated
;
1149 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1151 doc
: /* Return the display-table that WINDOW is using. */)
1155 return decode_window (window
)->display_table
;
1158 /* Get the display table for use on window W. This is either W's
1159 display table or W's buffer's display table. Ignore the specified
1160 tables if they are not valid; if no valid table is specified,
1163 struct Lisp_Char_Table
*
1164 window_display_table (w
)
1167 struct Lisp_Char_Table
*dp
= NULL
;
1169 if (DISP_TABLE_P (w
->display_table
))
1170 dp
= XCHAR_TABLE (w
->display_table
);
1171 else if (BUFFERP (w
->buffer
))
1173 struct buffer
*b
= XBUFFER (w
->buffer
);
1175 if (DISP_TABLE_P (b
->display_table
))
1176 dp
= XCHAR_TABLE (b
->display_table
);
1177 else if (DISP_TABLE_P (Vstandard_display_table
))
1178 dp
= XCHAR_TABLE (Vstandard_display_table
);
1184 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1185 doc
: /* Set WINDOW's display-table to TABLE. */)
1187 register Lisp_Object window
, table
;
1189 register struct window
*w
;
1191 w
= decode_window (window
);
1192 w
->display_table
= table
;
1196 /* Record info on buffer window w is displaying
1197 when it is about to cease to display that buffer. */
1200 register struct window
*w
;
1207 if (b
!= XMARKER (w
->pointm
)->buffer
)
1211 if (w
== XWINDOW (selected_window
)
1212 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1213 /* Do this except when the selected window's buffer
1214 is being removed from some other window. */
1216 /* last_window_start records the start position that this buffer
1217 had in the last window to be disconnected from it.
1218 Now that this statement is unconditional,
1219 it is possible for the buffer to be displayed in the
1220 selected window, while last_window_start reflects another
1221 window which was recently showing the same buffer.
1222 Some people might say that might be a good thing. Let's see. */
1223 b
->last_window_start
= marker_position (w
->start
);
1225 /* Point in the selected window's buffer
1226 is actually stored in that buffer, and the window's pointm isn't used.
1227 So don't clobber point in that buffer. */
1228 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1229 /* This line helps to fix Horsley's testbug.el bug. */
1230 && !(WINDOWP (b
->last_selected_window
)
1231 && w
!= XWINDOW (b
->last_selected_window
)
1232 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1233 temp_set_point_both (b
,
1234 clip_to_bounds (BUF_BEGV (b
),
1235 XMARKER (w
->pointm
)->charpos
,
1237 clip_to_bounds (BUF_BEGV_BYTE (b
),
1238 marker_byte_position (w
->pointm
),
1241 if (WINDOWP (b
->last_selected_window
)
1242 && w
== XWINDOW (b
->last_selected_window
))
1243 b
->last_selected_window
= Qnil
;
1246 /* Put replacement into the window structure in place of old. */
1248 replace_window (old
, replacement
)
1249 Lisp_Object old
, replacement
;
1251 register Lisp_Object tem
;
1252 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1254 /* If OLD is its frame's root_window, then replacement is the new
1255 root_window for that frame. */
1257 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1258 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1260 p
->left_col
= o
->left_col
;
1261 p
->top_line
= o
->top_line
;
1262 p
->total_cols
= o
->total_cols
;
1263 p
->total_lines
= o
->total_lines
;
1264 p
->desired_matrix
= p
->current_matrix
= 0;
1266 bzero (&p
->cursor
, sizeof (p
->cursor
));
1267 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1268 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1269 p
->phys_cursor_type
= -1;
1270 p
->phys_cursor_width
= -1;
1271 p
->must_be_updated_p
= 0;
1272 p
->pseudo_window_p
= 0;
1273 XSETFASTINT (p
->window_end_vpos
, 0);
1274 XSETFASTINT (p
->window_end_pos
, 0);
1275 p
->window_end_valid
= Qnil
;
1276 p
->frozen_window_start_p
= 0;
1277 p
->orig_top_line
= p
->orig_total_lines
= Qnil
;
1279 p
->next
= tem
= o
->next
;
1281 XWINDOW (tem
)->prev
= replacement
;
1283 p
->prev
= tem
= o
->prev
;
1285 XWINDOW (tem
)->next
= replacement
;
1287 p
->parent
= tem
= o
->parent
;
1290 if (EQ (XWINDOW (tem
)->vchild
, old
))
1291 XWINDOW (tem
)->vchild
= replacement
;
1292 if (EQ (XWINDOW (tem
)->hchild
, old
))
1293 XWINDOW (tem
)->hchild
= replacement
;
1296 /*** Here, if replacement is a vertical combination
1297 and so is its new parent, we should make replacement's
1298 children be children of that parent instead. ***/
1301 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1302 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1304 register Lisp_Object window
;
1306 delete_window (window
);
1308 if (! NILP (Vwindow_configuration_change_hook
)
1309 && ! NILP (Vrun_hooks
))
1310 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1316 delete_window (window
)
1317 register Lisp_Object window
;
1319 register Lisp_Object tem
, parent
, sib
;
1320 register struct window
*p
;
1321 register struct window
*par
;
1324 /* Because this function is called by other C code on non-leaf
1325 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1326 so we can't decode_window here. */
1328 window
= selected_window
;
1330 CHECK_WINDOW (window
);
1331 p
= XWINDOW (window
);
1333 /* It's okay to delete an already-deleted window. */
1334 if (NILP (p
->buffer
)
1336 && NILP (p
->vchild
))
1341 error ("Attempt to delete minibuffer or sole ordinary window");
1342 par
= XWINDOW (parent
);
1344 windows_or_buffers_changed
++;
1345 Vwindow_list
= Qnil
;
1346 f
= XFRAME (WINDOW_FRAME (p
));
1347 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1349 /* Are we trying to delete any frame's selected window? */
1351 Lisp_Object swindow
, pwindow
;
1353 /* See if the frame's selected window is either WINDOW
1354 or any subwindow of it, by finding all that window's parents
1355 and comparing each one with WINDOW. */
1356 swindow
= FRAME_SELECTED_WINDOW (f
);
1361 while (!NILP (pwindow
))
1363 if (EQ (window
, pwindow
))
1365 pwindow
= XWINDOW (pwindow
)->parent
;
1368 /* If the window being deleted is not a parent of SWINDOW,
1369 then SWINDOW is ok as the new selected window. */
1370 if (!EQ (window
, pwindow
))
1372 /* Otherwise, try another window for SWINDOW. */
1373 swindow
= Fnext_window (swindow
, Qlambda
, Qnil
);;
1375 /* If we get back to the frame's selected window,
1376 it means there was no acceptable alternative,
1377 so we cannot delete. */
1378 if (EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1379 error ("Cannot delete window");
1382 /* If we need to change SWINDOW, do it. */
1383 if (! EQ (swindow
, FRAME_SELECTED_WINDOW (f
)))
1385 /* If we're about to delete the selected window on the
1386 selected frame, then we should use Fselect_window to select
1387 the new window. On the other hand, if we're about to
1388 delete the selected window on any other frame, we shouldn't do
1389 anything but set the frame's selected_window slot. */
1390 if (EQ (FRAME_SELECTED_WINDOW (f
), selected_window
))
1391 Fselect_window (swindow
, Qnil
);
1393 FRAME_SELECTED_WINDOW (f
) = swindow
;
1398 /* tem is null for dummy parent windows
1399 (which have inferiors but not any contents themselves) */
1403 unchain_marker (XMARKER (p
->pointm
));
1404 unchain_marker (XMARKER (p
->start
));
1407 /* Free window glyph matrices. It is sure that they are allocated
1408 again when ADJUST_GLYPHS is called. Block input so that expose
1409 events and other events that access glyph matrices are not
1410 processed while we are changing them. */
1412 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1416 XWINDOW (tem
)->prev
= p
->prev
;
1420 XWINDOW (tem
)->next
= p
->next
;
1422 if (EQ (window
, par
->hchild
))
1423 par
->hchild
= p
->next
;
1424 if (EQ (window
, par
->vchild
))
1425 par
->vchild
= p
->next
;
1427 /* Find one of our siblings to give our space to. */
1431 /* If p gives its space to its next sibling, that sibling needs
1432 to have its top/left side pulled back to where p's is.
1433 set_window_{height,width} will re-position the sibling's
1436 XWINDOW (sib
)->top_line
= p
->top_line
;
1437 XWINDOW (sib
)->left_col
= p
->left_col
;
1440 /* Stretch that sibling. */
1441 if (!NILP (par
->vchild
))
1442 set_window_height (sib
,
1443 XFASTINT (XWINDOW (sib
)->total_lines
) + XFASTINT (p
->total_lines
),
1445 if (!NILP (par
->hchild
))
1446 set_window_width (sib
,
1447 XFASTINT (XWINDOW (sib
)->total_cols
) + XFASTINT (p
->total_cols
),
1450 /* If parent now has only one child,
1451 put the child into the parent's place. */
1455 if (NILP (XWINDOW (tem
)->next
))
1456 replace_window (parent
, tem
);
1458 /* Since we may be deleting combination windows, we must make sure that
1459 not only p but all its children have been marked as deleted. */
1460 if (! NILP (p
->hchild
))
1461 delete_all_subwindows (XWINDOW (p
->hchild
));
1462 else if (! NILP (p
->vchild
))
1463 delete_all_subwindows (XWINDOW (p
->vchild
));
1465 /* Mark this window as deleted. */
1466 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1468 /* Adjust glyph matrices. */
1475 /***********************************************************************
1477 ***********************************************************************/
1479 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1480 pointer. This is a callback function for foreach_window, used in
1481 function window_list. */
1484 add_window_to_list (w
, user_data
)
1488 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1490 XSETWINDOW (window
, w
);
1491 *list
= Fcons (window
, *list
);
1496 /* Return a list of all windows, for use by next_window. If
1497 Vwindow_list is a list, return that list. Otherwise, build a new
1498 list, cache it in Vwindow_list, and return that. */
1503 if (!CONSP (Vwindow_list
))
1507 Vwindow_list
= Qnil
;
1508 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1510 Lisp_Object args
[2];
1512 /* We are visiting windows in canonical order, and add
1513 new windows at the front of args[1], which means we
1514 have to reverse this list at the end. */
1516 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1517 args
[0] = Vwindow_list
;
1518 args
[1] = Fnreverse (args
[1]);
1519 Vwindow_list
= Fnconc (2, args
);
1523 return Vwindow_list
;
1527 /* Value is non-zero if WINDOW satisfies the constraints given by
1528 OWINDOW, MINIBUF and ALL_FRAMES.
1530 MINIBUF t means WINDOW may be minibuffer windows.
1531 `lambda' means WINDOW may not be a minibuffer window.
1532 a window means a specific minibuffer window
1534 ALL_FRAMES t means search all frames,
1535 nil means search just current frame,
1536 `visible' means search just visible frames,
1537 0 means search visible and iconified frames,
1538 a window means search the frame that window belongs to,
1539 a frame means consider windows on that frame, only. */
1542 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1543 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1545 struct window
*w
= XWINDOW (window
);
1546 struct frame
*f
= XFRAME (w
->frame
);
1547 int candidate_p
= 1;
1549 if (!BUFFERP (w
->buffer
))
1551 else if (MINI_WINDOW_P (w
)
1552 && (EQ (minibuf
, Qlambda
)
1553 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1555 /* If MINIBUF is `lambda' don't consider any mini-windows.
1556 If it is a window, consider only that one. */
1559 else if (EQ (all_frames
, Qt
))
1561 else if (NILP (all_frames
))
1563 xassert (WINDOWP (owindow
));
1564 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1566 else if (EQ (all_frames
, Qvisible
))
1568 FRAME_SAMPLE_VISIBILITY (f
);
1569 candidate_p
= FRAME_VISIBLE_P (f
);
1571 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1573 FRAME_SAMPLE_VISIBILITY (f
);
1574 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1576 else if (WINDOWP (all_frames
))
1577 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1578 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1579 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1580 else if (FRAMEP (all_frames
))
1581 candidate_p
= EQ (all_frames
, w
->frame
);
1587 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1588 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1592 decode_next_window_args (window
, minibuf
, all_frames
)
1593 Lisp_Object
*window
, *minibuf
, *all_frames
;
1596 *window
= selected_window
;
1598 CHECK_LIVE_WINDOW (*window
);
1600 /* MINIBUF nil may or may not include minibuffers. Decide if it
1602 if (NILP (*minibuf
))
1603 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1604 else if (!EQ (*minibuf
, Qt
))
1607 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1608 => count none of them, or a specific minibuffer window (the
1609 active one) to count. */
1611 /* ALL_FRAMES nil doesn't specify which frames to include. */
1612 if (NILP (*all_frames
))
1613 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1614 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1616 else if (EQ (*all_frames
, Qvisible
))
1618 else if (EQ (*all_frames
, make_number (0)))
1620 else if (FRAMEP (*all_frames
))
1622 else if (!EQ (*all_frames
, Qt
))
1625 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1626 search just current frame, `visible' meaning search just visible
1627 frames, 0 meaning search visible and iconified frames, or a
1628 window, meaning search the frame that window belongs to, or a
1629 frame, meaning consider windows on that frame, only. */
1633 /* Return the next or previous window of WINDOW in canonical ordering
1634 of windows. NEXT_P non-zero means return the next window. See the
1635 documentation string of next-window for the meaning of MINIBUF and
1639 next_window (window
, minibuf
, all_frames
, next_p
)
1640 Lisp_Object window
, minibuf
, all_frames
;
1643 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1645 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1646 return the first window on the frame. */
1647 if (FRAMEP (all_frames
)
1648 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1649 return Fframe_first_window (all_frames
);
1655 /* Find WINDOW in the list of all windows. */
1656 list
= Fmemq (window
, window_list ());
1658 /* Scan forward from WINDOW to the end of the window list. */
1660 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1661 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1664 /* Scan from the start of the window list up to WINDOW. */
1666 for (list
= Vwindow_list
;
1667 CONSP (list
) && !EQ (XCAR (list
), window
);
1669 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1673 window
= XCAR (list
);
1677 Lisp_Object candidate
, list
;
1679 /* Scan through the list of windows for candidates. If there are
1680 candidate windows in front of WINDOW, the last one of these
1681 is the one we want. If there are candidates following WINDOW
1682 in the list, again the last one of these is the one we want. */
1684 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1686 if (EQ (XCAR (list
), window
))
1688 if (WINDOWP (candidate
))
1691 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1693 candidate
= XCAR (list
);
1696 if (WINDOWP (candidate
))
1704 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1705 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1706 If omitted, WINDOW defaults to the selected window.
1708 Optional second arg MINIBUF t means count the minibuffer window even
1709 if not active. MINIBUF nil or omitted means count the minibuffer iff
1710 it is active. MINIBUF neither t nor nil means not to count the
1711 minibuffer even if it is active.
1713 Several frames may share a single minibuffer; if the minibuffer
1714 counts, all windows on all frames that share that minibuffer count
1715 too. Therefore, `next-window' can be used to iterate through the
1716 set of windows even when the minibuffer is on another frame. If the
1717 minibuffer does not count, only windows from WINDOW's frame count.
1719 Optional third arg ALL-FRAMES t means include windows on all frames.
1720 ALL-FRAMES nil or omitted means cycle within the frames as specified
1721 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1722 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1723 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1724 Anything else means restrict to WINDOW's frame.
1726 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1727 `next-window' to iterate through the entire cycle of acceptable
1728 windows, eventually ending up back at the window you started with.
1729 `previous-window' traverses the same cycle, in the reverse order. */)
1730 (window
, minibuf
, all_frames
)
1731 Lisp_Object window
, minibuf
, all_frames
;
1733 return next_window (window
, minibuf
, all_frames
, 1);
1737 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1738 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1739 If omitted, WINDOW defaults to the selected window.
1741 Optional second arg MINIBUF t means count the minibuffer window even
1742 if not active. MINIBUF nil or omitted means count the minibuffer iff
1743 it is active. MINIBUF neither t nor nil means not to count the
1744 minibuffer even if it is active.
1746 Several frames may share a single minibuffer; if the minibuffer
1747 counts, all windows on all frames that share that minibuffer count
1748 too. Therefore, `previous-window' can be used to iterate through
1749 the set of windows even when the minibuffer is on another frame. If
1750 the minibuffer does not count, only windows from WINDOW's frame count
1752 Optional third arg ALL-FRAMES t means include windows on all frames.
1753 ALL-FRAMES nil or omitted means cycle within the frames as specified
1754 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1755 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1756 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1757 Anything else means restrict to WINDOW's frame.
1759 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1760 `previous-window' to iterate through the entire cycle of acceptable
1761 windows, eventually ending up back at the window you started with.
1762 `next-window' traverses the same cycle, in the reverse order. */)
1763 (window
, minibuf
, all_frames
)
1764 Lisp_Object window
, minibuf
, all_frames
;
1766 return next_window (window
, minibuf
, all_frames
, 0);
1770 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1771 doc
: /* Select the ARG'th different window on this frame.
1772 All windows on current frame are arranged in a cyclic order.
1773 This command selects the window ARG steps away in that order.
1774 A negative ARG moves in the opposite order. The optional second
1775 argument ALL_FRAMES has the same meaning as in `next-window', which see. */)
1777 Lisp_Object arg
, all_frames
;
1783 window
= selected_window
;
1785 for (i
= XINT (arg
); i
> 0; --i
)
1786 window
= Fnext_window (window
, Qnil
, all_frames
);
1788 window
= Fprevious_window (window
, Qnil
, all_frames
);
1790 Fselect_window (window
, Qnil
);
1795 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1796 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1797 FRAME nil or omitted means use the selected frame.
1798 WINDOW nil or omitted means use the selected window.
1799 MINIBUF t means include the minibuffer window, even if it isn't active.
1800 MINIBUF nil or omitted means include the minibuffer window only
1802 MINIBUF neither nil nor t means never include the minibuffer window. */)
1803 (frame
, minibuf
, window
)
1804 Lisp_Object frame
, minibuf
, window
;
1807 window
= selected_window
;
1809 frame
= selected_frame
;
1811 if (!EQ (frame
, XWINDOW (window
)->frame
))
1812 error ("Window is on a different frame");
1814 return window_list_1 (window
, minibuf
, frame
);
1818 /* Return a list of windows in canonical ordering. Arguments are like
1819 for `next-window'. */
1822 window_list_1 (window
, minibuf
, all_frames
)
1823 Lisp_Object window
, minibuf
, all_frames
;
1825 Lisp_Object tail
, list
, rest
;
1827 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1830 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1831 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1832 list
= Fcons (XCAR (tail
), list
);
1834 /* Rotate the list to start with WINDOW. */
1835 list
= Fnreverse (list
);
1836 rest
= Fmemq (window
, list
);
1837 if (!NILP (rest
) && !EQ (rest
, list
))
1839 for (tail
= list
; !EQ (XCDR (tail
), rest
); tail
= XCDR (tail
))
1841 XSETCDR (tail
, Qnil
);
1842 list
= nconc2 (rest
, list
);
1849 /* Look at all windows, performing an operation specified by TYPE
1851 If FRAMES is Qt, look at all frames;
1852 Qnil, look at just the selected frame;
1853 Qvisible, look at visible frames;
1854 a frame, just look at windows on that frame.
1855 If MINI is non-zero, perform the operation on minibuffer windows too. */
1860 GET_BUFFER_WINDOW
, /* Arg is buffer */
1861 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1862 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1863 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1865 UNSHOW_BUFFER
, /* Arg is buffer */
1866 REDISPLAY_BUFFER_WINDOWS
, /* Arg is buffer */
1871 window_loop (type
, obj
, mini
, frames
)
1872 enum window_loop type
;
1873 Lisp_Object obj
, frames
;
1876 Lisp_Object window
, windows
, best_window
, frame_arg
;
1878 struct gcpro gcpro1
;
1880 /* If we're only looping through windows on a particular frame,
1881 frame points to that frame. If we're looping through windows
1882 on all frames, frame is 0. */
1883 if (FRAMEP (frames
))
1884 f
= XFRAME (frames
);
1885 else if (NILP (frames
))
1886 f
= SELECTED_FRAME ();
1891 frame_arg
= Qlambda
;
1892 else if (EQ (frames
, make_number (0)))
1894 else if (EQ (frames
, Qvisible
))
1899 /* frame_arg is Qlambda to stick to one frame,
1900 Qvisible to consider all visible frames,
1903 /* Pick a window to start with. */
1907 window
= FRAME_SELECTED_WINDOW (f
);
1909 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1911 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1915 for (; CONSP (windows
); windows
= CDR (windows
))
1919 window
= XCAR (windows
);
1920 w
= XWINDOW (window
);
1922 /* Note that we do not pay attention here to whether the frame
1923 is visible, since Fwindow_list skips non-visible frames if
1924 that is desired, under the control of frame_arg. */
1925 if (!MINI_WINDOW_P (w
)
1926 /* For UNSHOW_BUFFER, we must always consider all windows. */
1927 || type
== UNSHOW_BUFFER
1928 || (mini
&& minibuf_level
> 0))
1931 case GET_BUFFER_WINDOW
:
1932 if (EQ (w
->buffer
, obj
)
1933 /* Don't find any minibuffer window
1934 except the one that is currently in use. */
1935 && (MINI_WINDOW_P (w
)
1936 ? EQ (window
, minibuf_window
)
1939 if (NILP (best_window
))
1940 best_window
= window
;
1941 else if (EQ (window
, selected_window
))
1942 /* For compatibility with 20.x, prefer to return
1944 best_window
= window
;
1948 case GET_LRU_WINDOW
:
1949 /* t as arg means consider only full-width windows */
1950 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1952 /* Ignore dedicated windows and minibuffers. */
1953 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
1955 if (NILP (best_window
)
1956 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1957 > XFASTINT (w
->use_time
)))
1958 best_window
= window
;
1961 case DELETE_OTHER_WINDOWS
:
1962 if (!EQ (window
, obj
))
1963 Fdelete_window (window
);
1966 case DELETE_BUFFER_WINDOWS
:
1967 if (EQ (w
->buffer
, obj
))
1969 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1971 /* If this window is dedicated, and in a frame of its own,
1973 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1974 && !NILP (w
->dedicated
)
1975 && other_visible_frames (f
))
1977 /* Skip the other windows on this frame.
1978 There might be one, the minibuffer! */
1979 while (CONSP (XCDR (windows
))
1980 && EQ (XWINDOW (XCAR (windows
))->frame
,
1981 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1982 windows
= XCDR (windows
);
1984 /* Now we can safely delete the frame. */
1985 Fdelete_frame (w
->frame
, Qnil
);
1987 else if (NILP (w
->parent
))
1989 /* If we're deleting the buffer displayed in the
1990 only window on the frame, find a new buffer to
1993 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1994 Fset_window_buffer (window
, buffer
, Qnil
);
1995 if (EQ (window
, selected_window
))
1996 Fset_buffer (w
->buffer
);
1999 Fdelete_window (window
);
2003 case GET_LARGEST_WINDOW
:
2005 /* Ignore dedicated windows and minibuffers. */
2006 if (MINI_WINDOW_P (w
) || EQ (w
->dedicated
, Qt
))
2009 if (NILP (best_window
))
2010 best_window
= window
;
2013 struct window
*b
= XWINDOW (best_window
);
2014 if (XFASTINT (w
->total_lines
) * XFASTINT (w
->total_cols
)
2015 > XFASTINT (b
->total_lines
) * XFASTINT (b
->total_cols
))
2016 best_window
= window
;
2022 if (EQ (w
->buffer
, obj
))
2025 struct frame
*f
= XFRAME (w
->frame
);
2027 /* Find another buffer to show in this window. */
2028 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
2030 /* If this window is dedicated, and in a frame of its own,
2032 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
2033 && !NILP (w
->dedicated
)
2034 && other_visible_frames (f
))
2036 /* Skip the other windows on this frame.
2037 There might be one, the minibuffer! */
2038 while (CONSP (XCDR (windows
))
2039 && EQ (XWINDOW (XCAR (windows
))->frame
,
2040 XWINDOW (XCAR (XCDR (windows
)))->frame
))
2041 windows
= XCDR (windows
);
2043 /* Now we can safely delete the frame. */
2044 Fdelete_frame (w
->frame
, Qnil
);
2046 else if (!NILP (w
->dedicated
) && !NILP (w
->parent
))
2049 XSETWINDOW (window
, w
);
2050 /* If this window is dedicated and not the only window
2051 in its frame, then kill it. */
2052 Fdelete_window (window
);
2056 /* Otherwise show a different buffer in the window. */
2057 w
->dedicated
= Qnil
;
2058 Fset_window_buffer (window
, buffer
, Qnil
);
2059 if (EQ (window
, selected_window
))
2060 Fset_buffer (w
->buffer
);
2065 case REDISPLAY_BUFFER_WINDOWS
:
2066 if (EQ (w
->buffer
, obj
))
2068 mark_window_display_accurate (window
, 0);
2069 w
->update_mode_line
= Qt
;
2070 XBUFFER (obj
)->prevent_redisplay_optimizations_p
= 1;
2071 ++update_mode_lines
;
2072 best_window
= window
;
2076 /* Check for a window that has a killed buffer. */
2077 case CHECK_ALL_WINDOWS
:
2078 if (! NILP (w
->buffer
)
2079 && NILP (XBUFFER (w
->buffer
)->name
))
2083 case WINDOW_LOOP_UNUSED
:
2092 /* Used for debugging. Abort if any window has a dead buffer. */
2095 check_all_windows ()
2097 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
2100 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
2101 doc
: /* Return the window least recently selected or used for display.
2102 Return a full-width window if possible.
2103 A minibuffer window is never a candidate.
2104 A dedicated window is never a candidate, so if all windows are dedicated,
2106 If optional argument FRAME is `visible', search all visible frames.
2107 If FRAME is 0, search all visible and iconified frames.
2108 If FRAME is t, search all frames.
2109 If FRAME is nil, search only the selected frame.
2110 If FRAME is a frame, search only that frame. */)
2114 register Lisp_Object w
;
2115 /* First try for a window that is full-width */
2116 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
2117 if (!NILP (w
) && !EQ (w
, selected_window
))
2119 /* If none of them, try the rest */
2120 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
2123 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
2124 doc
: /* Return the largest window in area.
2125 A minibuffer window is never a candidate.
2126 A dedicated window is never a candidate, so if all windows are dedicated,
2128 If optional argument FRAME is `visible', search all visible frames.
2129 If FRAME is 0, search all visible and iconified frames.
2130 If FRAME is t, search all frames.
2131 If FRAME is nil, search only the selected frame.
2132 If FRAME is a frame, search only that frame. */)
2136 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
2140 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
2141 doc
: /* Return a window currently displaying BUFFER, or nil if none.
2142 BUFFER can be a buffer or a buffer name.
2143 If optional argument FRAME is `visible', search all visible frames.
2144 If optional argument FRAME is 0, search all visible and iconified frames.
2145 If FRAME is t, search all frames.
2146 If FRAME is nil, search only the selected frame.
2147 If FRAME is a frame, search only that frame. */)
2149 Lisp_Object buffer
, frame
;
2151 buffer
= Fget_buffer (buffer
);
2152 if (BUFFERP (buffer
))
2153 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
2158 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
2160 doc
: /* Make WINDOW (or the selected window) fill its frame.
2161 Only the frame WINDOW is on is affected.
2162 This function tries to reduce display jumps
2163 by keeping the text previously visible in WINDOW
2164 in the same place on the frame. Doing this depends on
2165 the value of (window-start WINDOW), so if calling this function
2166 in a program gives strange scrolling, make sure the window-start
2167 value is reasonable when this function is called. */)
2176 window
= selected_window
;
2178 CHECK_LIVE_WINDOW (window
);
2179 w
= XWINDOW (window
);
2181 startpos
= marker_position (w
->start
);
2182 top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2184 if (MINI_WINDOW_P (w
) && top
> 0)
2185 error ("Can't expand minibuffer to full frame");
2187 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2189 /* Try to minimize scrolling, by setting the window start to the point
2190 will cause the text at the old window start to be at the same place
2191 on the frame. But don't try to do this if the window start is
2192 outside the visible portion (as might happen when the display is
2193 not current, due to typeahead). */
2194 new_top
= WINDOW_TOP_EDGE_LINE (w
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2196 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2197 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2199 struct position pos
;
2200 struct buffer
*obuf
= current_buffer
;
2202 Fset_buffer (w
->buffer
);
2203 /* This computation used to temporarily move point, but that can
2204 have unwanted side effects due to text properties. */
2205 pos
= *vmotion (startpos
, -top
, w
);
2207 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2208 w
->window_end_valid
= Qnil
;
2209 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2210 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2212 /* We need to do this, so that the window-scroll-functions
2214 w
->optional_new_start
= Qt
;
2216 set_buffer_internal (obuf
);
2222 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2223 1, 2, "bDelete windows on (buffer): ",
2224 doc
: /* Delete all windows showing BUFFER.
2225 BUFFER must be a buffer or the name of an existing buffer.
2226 Optional second argument FRAME controls which frames are affected.
2227 If optional argument FRAME is `visible', search all visible frames.
2228 If FRAME is 0, search all visible and iconified frames.
2229 If FRAME is nil, search all frames.
2230 If FRAME is t, search only the selected frame.
2231 If FRAME is a frame, search only that frame. */)
2233 Lisp_Object buffer
, frame
;
2235 /* FRAME uses t and nil to mean the opposite of what window_loop
2239 else if (EQ (frame
, Qt
))
2244 buffer
= Fget_buffer (buffer
);
2245 CHECK_BUFFER (buffer
);
2246 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2252 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2253 Sreplace_buffer_in_windows
,
2254 1, 1, "bReplace buffer in windows: ",
2255 doc
: /* Replace BUFFER with some other buffer in all windows showing it.
2256 BUFFER may be a buffer or the name of an existing buffer. */)
2262 buffer
= Fget_buffer (buffer
);
2263 CHECK_BUFFER (buffer
);
2264 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2269 /* Replace BUFFER with some other buffer in all windows
2270 of all frames, even those on other keyboards. */
2273 replace_buffer_in_all_windows (buffer
)
2277 Lisp_Object tail
, frame
;
2279 /* A single call to window_loop won't do the job
2280 because it only considers frames on the current keyboard.
2281 So loop manually over frames, and handle each one. */
2282 FOR_EACH_FRAME (tail
, frame
)
2283 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2285 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2289 /* Set the height of WINDOW and all its inferiors. */
2291 /* The smallest acceptable dimensions for a window. Anything smaller
2292 might crash Emacs. */
2294 #define MIN_SAFE_WINDOW_WIDTH (2)
2295 #define MIN_SAFE_WINDOW_HEIGHT (1)
2297 /* Make sure that window_min_height and window_min_width are
2298 not too small; if they are, set them to safe minima. */
2301 check_min_window_sizes ()
2303 /* Smaller values might permit a crash. */
2304 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2305 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2306 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2307 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2310 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2311 minimum allowable size. */
2314 check_frame_size (frame
, rows
, cols
)
2318 /* For height, we have to see:
2319 how many windows the frame has at minimum (one or two),
2320 and whether it has a menu bar or other special stuff at the top. */
2322 = ((FRAME_MINIBUF_ONLY_P (frame
) || ! FRAME_HAS_MINIBUF_P (frame
))
2323 ? MIN_SAFE_WINDOW_HEIGHT
2324 : 2 * MIN_SAFE_WINDOW_HEIGHT
);
2326 if (FRAME_TOP_MARGIN (frame
) > 0)
2327 min_height
+= FRAME_TOP_MARGIN (frame
);
2329 if (*rows
< min_height
)
2331 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2332 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2336 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2337 check if W's width can be changed, otherwise check W's height.
2338 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2339 siblings, too. If none of the siblings is resizable, WINDOW isn't
2343 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2345 int width_p
, check_siblings_p
;
2350 if (!NILP (w
->hchild
))
2352 c
= XWINDOW (w
->hchild
);
2356 /* A horiz. combination is fixed-width if all of if its
2358 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2359 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2360 fixed_p
= c
== NULL
;
2364 /* A horiz. combination is fixed-height if one of if its
2366 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2367 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2368 fixed_p
= c
!= NULL
;
2371 else if (!NILP (w
->vchild
))
2373 c
= XWINDOW (w
->vchild
);
2377 /* A vert. combination is fixed-width if one of if its
2379 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2380 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2381 fixed_p
= c
!= NULL
;
2385 /* A vert. combination is fixed-height if all of if its
2387 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2388 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2389 fixed_p
= c
== NULL
;
2392 else if (BUFFERP (w
->buffer
))
2394 if (w
->height_fixed_p
&& !width_p
)
2398 struct buffer
*old
= current_buffer
;
2401 current_buffer
= XBUFFER (w
->buffer
);
2402 val
= find_symbol_value (Qwindow_size_fixed
);
2403 current_buffer
= old
;
2406 if (!EQ (val
, Qunbound
))
2408 fixed_p
= !NILP (val
);
2411 && ((EQ (val
, Qheight
) && width_p
)
2412 || (EQ (val
, Qwidth
) && !width_p
)))
2417 /* Can't tell if this one is resizable without looking at
2418 siblings. If all siblings are fixed-size this one is too. */
2419 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2423 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2424 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2428 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2429 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2443 /* Return the minimum size of window W, not taking fixed-width windows
2444 into account. WIDTH_P non-zero means return the minimum width,
2445 otherwise return the minimum height. If W is a combination window,
2446 compute the minimum size from the minimum sizes of W's children. */
2449 window_min_size_1 (w
, width_p
)
2456 if (!NILP (w
->hchild
))
2458 c
= XWINDOW (w
->hchild
);
2463 /* The min width of a horizontal combination is
2464 the sum of the min widths of its children. */
2467 size
+= window_min_size_1 (c
, width_p
);
2468 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2473 /* The min height a horizontal combination equals
2474 the maximum of all min height of its children. */
2477 int min_size
= window_min_size_1 (c
, width_p
);
2478 size
= max (min_size
, size
);
2479 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2483 else if (!NILP (w
->vchild
))
2485 c
= XWINDOW (w
->vchild
);
2490 /* The min width of a vertical combination is
2491 the maximum of the min widths of its children. */
2494 int min_size
= window_min_size_1 (c
, width_p
);
2495 size
= max (min_size
, size
);
2496 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2501 /* The min height of a vertical combination equals
2502 the sum of the min height of its children. */
2505 size
+= window_min_size_1 (c
, width_p
);
2506 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2513 size
= window_min_width
;
2516 if (MINI_WINDOW_P (w
)
2517 || (!WINDOW_WANTS_MODELINE_P (w
)
2518 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2521 size
= window_min_height
;
2529 /* Return the minimum size of window W, taking fixed-size windows into
2530 account. WIDTH_P non-zero means return the minimum width,
2531 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2532 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2533 unless FIXED is null. */
2536 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2538 int width_p
, ignore_fixed_p
, *fixed
;
2545 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2551 size
= width_p
? XFASTINT (w
->total_cols
) : XFASTINT (w
->total_lines
);
2553 size
= window_min_size_1 (w
, width_p
);
2559 /* Adjust the margins of window W if text area is too small.
2560 Return 1 if window width is ok after adjustment; 0 if window
2561 is still too narrow. */
2564 adjust_window_margins (w
)
2567 int box_cols
= (WINDOW_TOTAL_COLS (w
)
2568 - WINDOW_FRINGE_COLS (w
)
2569 - WINDOW_SCROLL_BAR_COLS (w
));
2570 int margin_cols
= (WINDOW_LEFT_MARGIN_COLS (w
)
2571 + WINDOW_RIGHT_MARGIN_COLS (w
));
2573 if (box_cols
- margin_cols
>= MIN_SAFE_WINDOW_WIDTH
)
2576 if (margin_cols
< 0 || box_cols
< MIN_SAFE_WINDOW_WIDTH
)
2579 /* Window's text area is too narrow, but reducing the window
2580 margins will fix that. */
2581 margin_cols
= box_cols
- MIN_SAFE_WINDOW_WIDTH
;
2582 if (WINDOW_RIGHT_MARGIN_COLS (w
) > 0)
2584 if (WINDOW_LEFT_MARGIN_COLS (w
) > 0)
2585 w
->left_margin_cols
= w
->right_margin_cols
2586 = make_number (margin_cols
/2);
2588 w
->right_margin_cols
= make_number (margin_cols
);
2591 w
->left_margin_cols
= make_number (margin_cols
);
2595 /* Calculate new sizes for windows in the list FORWARD when the window size
2596 goes from TOTAL to SIZE. TOTAL must be greater than SIZE.
2597 The number of windows in FORWARD is NCHILDREN, and the number that
2598 can shrink is SHRINKABLE.
2599 The minimum size a window can have is MIN_SIZE.
2600 If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
2601 If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
2604 This function returns an allocated array of new sizes that the caller
2605 must free. The size -1 means the window is fixed and RESIZE_FIXED_P
2606 is zero. Array index 0 refers to the first window in FORWARD, 1 to
2607 the second, and so on.
2609 This function tries to keep windows at least at the minimum size
2610 and resize other windows before it resizes any window to zero (i.e.
2611 delete that window).
2613 Windows are resized proportional to their size, so bigger windows
2614 shrink more than smaller windows. */
2616 shrink_windows (total
, size
, nchildren
, shrinkable
,
2617 min_size
, resize_fixed_p
, forward
, width_p
)
2618 int total
, size
, nchildren
, shrinkable
, min_size
;
2619 int resize_fixed_p
, width_p
;
2620 Lisp_Object forward
;
2622 int available_resize
= 0;
2626 int smallest
= total
;
2627 int total_removed
= 0;
2628 int total_shrink
= total
- size
;
2631 new_sizes
= xmalloc (sizeof (*new_sizes
) * nchildren
);
2633 for (i
= 0, child
= forward
; !NILP (child
); child
= c
->next
, ++i
)
2637 c
= XWINDOW (child
);
2638 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2640 if (! resize_fixed_p
&& window_fixed_size_p (c
, width_p
, 0))
2644 new_sizes
[i
] = child_size
;
2645 if (child_size
> min_size
)
2646 available_resize
+= child_size
- min_size
;
2649 /* We might need to shrink some windows to zero. Find the smallest
2650 windows and set them to 0 until we can fulfil the new size. */
2652 while (shrinkable
> 1 && size
+ available_resize
< total
)
2654 for (i
= 0; i
< nchildren
; ++i
)
2655 if (new_sizes
[i
] > 0 && smallest
> new_sizes
[i
])
2656 smallest
= new_sizes
[i
];
2658 for (i
= 0; i
< nchildren
; ++i
)
2659 if (new_sizes
[i
] == smallest
)
2661 /* Resize this window down to zero. */
2663 if (smallest
> min_size
)
2664 available_resize
-= smallest
- min_size
;
2665 available_resize
+= smallest
;
2667 total_removed
+= smallest
;
2669 /* We don't know what the smallest is now. */
2672 /* Out of for, just remove one window at the time and
2673 check again if we have enough space. */
2678 /* Now, calculate the new sizes. Try to shrink each window
2679 proportional to its size. */
2680 for (i
= 0; i
< nchildren
; ++i
)
2682 if (new_sizes
[i
] > min_size
)
2684 int to_shrink
= total_shrink
*new_sizes
[i
]/total
;
2685 if (new_sizes
[i
] - to_shrink
< min_size
)
2686 to_shrink
= new_sizes
[i
] - min_size
;
2687 new_sizes
[i
] -= to_shrink
;
2688 total_removed
+= to_shrink
;
2692 /* Any reminder due to rounding, we just subtract from windows
2693 that are left and still can be shrunk. */
2694 while (total_shrink
> total_removed
)
2696 int nonzero_sizes
= 0;
2697 int nonzero_idx
= -1;
2699 for (i
= 0; i
< nchildren
; ++i
)
2700 if (new_sizes
[i
] > 0)
2706 for (i
= 0; i
< nchildren
; ++i
)
2707 if (new_sizes
[i
] > min_size
)
2712 /* Out of for, just shrink one window at the time and
2713 check again if we have enough space. */
2718 /* Special case, only one window left. */
2719 if (nonzero_sizes
== 1)
2723 /* Any surplus due to rounding, we add to windows that are left. */
2724 while (total_shrink
< total_removed
)
2726 for (i
= 0; i
< nchildren
; ++i
)
2728 if (new_sizes
[i
] != 0 && total_shrink
< total_removed
)
2740 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2741 WINDOW's width. Resize WINDOW's children, if any, so that they
2742 keep their proportionate size relative to WINDOW. Propagate
2743 WINDOW's top or left edge position to children. Delete windows
2744 that become too small unless NODELETE_P is non-zero.
2746 If NODELETE_P is 2, that means we do delete windows that are
2747 too small, even if they were too small before! */
2750 size_window (window
, size
, width_p
, nodelete_p
)
2752 int size
, width_p
, nodelete_p
;
2754 struct window
*w
= XWINDOW (window
);
2756 Lisp_Object child
, *forward
, *sideward
;
2757 int old_size
, min_size
, safe_min_size
;
2759 /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
2760 seems like it's too soon to do this here. ++KFS. */
2761 if (nodelete_p
== 2)
2764 check_min_window_sizes ();
2765 size
= max (0, size
);
2767 /* If the window has been "too small" at one point,
2768 don't delete it for being "too small" in the future.
2769 Preserve it as long as that is at all possible. */
2772 old_size
= WINDOW_TOTAL_COLS (w
);
2773 min_size
= window_min_width
;
2774 /* Ensure that there is room for the scroll bar and fringes!
2775 We may reduce display margins though. */
2776 safe_min_size
= (MIN_SAFE_WINDOW_WIDTH
2777 + WINDOW_FRINGE_COLS (w
)
2778 + WINDOW_SCROLL_BAR_COLS (w
));
2782 old_size
= XINT (w
->total_lines
);
2783 min_size
= window_min_height
;
2784 safe_min_size
= MIN_SAFE_WINDOW_HEIGHT
;
2787 if (old_size
< min_size
&& nodelete_p
!= 2)
2788 w
->too_small_ok
= Qt
;
2790 /* Maybe delete WINDOW if it's too small. */
2791 if (nodelete_p
!= 1 && !NILP (w
->parent
))
2793 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2794 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2795 if (min_size
< safe_min_size
)
2796 min_size
= safe_min_size
;
2797 if (size
< min_size
)
2799 delete_window (window
);
2804 /* Set redisplay hints. */
2805 w
->last_modified
= make_number (0);
2806 w
->last_overlay_modified
= make_number (0);
2807 windows_or_buffers_changed
++;
2808 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2812 sideward
= &w
->vchild
;
2813 forward
= &w
->hchild
;
2814 w
->total_cols
= make_number (size
);
2815 adjust_window_margins (w
);
2819 sideward
= &w
->hchild
;
2820 forward
= &w
->vchild
;
2821 w
->total_lines
= make_number (size
);
2822 w
->orig_total_lines
= Qnil
;
2825 if (!NILP (*sideward
))
2827 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2829 c
= XWINDOW (child
);
2831 c
->left_col
= w
->left_col
;
2833 c
->top_line
= w
->top_line
;
2834 size_window (child
, size
, width_p
, nodelete_p
);
2837 else if (!NILP (*forward
))
2839 int fixed_size
, each
, extra
, n
;
2840 int resize_fixed_p
, nfixed
;
2841 int last_pos
, first_pos
, nchildren
, total
;
2842 int *new_sizes
= NULL
;
2844 /* Determine the fixed-size portion of the this window, and the
2845 number of child windows. */
2846 fixed_size
= nchildren
= nfixed
= total
= 0;
2847 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2851 c
= XWINDOW (child
);
2852 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2853 total
+= child_size
;
2855 if (window_fixed_size_p (c
, width_p
, 0))
2857 fixed_size
+= child_size
;
2862 /* If the new size is smaller than fixed_size, or if there
2863 aren't any resizable windows, allow resizing fixed-size
2865 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2867 /* Compute how many lines/columns to add/remove to each child. The
2868 value of extra takes care of rounding errors. */
2869 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2870 if (size
< total
&& n
> 1)
2871 new_sizes
= shrink_windows (total
, size
, nchildren
, n
, min_size
,
2872 resize_fixed_p
, *forward
, width_p
);
2875 each
= (size
- total
) / n
;
2876 extra
= (size
- total
) - n
* each
;
2879 /* Compute new children heights and edge positions. */
2880 first_pos
= width_p
? XINT (w
->left_col
) : XINT (w
->top_line
);
2881 last_pos
= first_pos
;
2882 for (n
= 0, child
= *forward
; !NILP (child
); child
= c
->next
, ++n
)
2884 int new_size
, old_size
;
2886 c
= XWINDOW (child
);
2887 old_size
= width_p
? XFASTINT (c
->total_cols
) : XFASTINT (c
->total_lines
);
2888 new_size
= old_size
;
2890 /* The top or left edge position of this child equals the
2891 bottom or right edge of its predecessor. */
2893 c
->left_col
= make_number (last_pos
);
2895 c
->top_line
= make_number (last_pos
);
2897 /* If this child can be resized, do it. */
2898 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2900 new_size
= new_sizes
? new_sizes
[n
] : old_size
+ each
+ extra
;
2904 /* Set new height. Note that size_window also propagates
2905 edge positions to children, so it's not a no-op if we
2906 didn't change the child's size. */
2907 size_window (child
, new_size
, width_p
, 1);
2909 /* Remember the bottom/right edge position of this child; it
2910 will be used to set the top/left edge of the next child. */
2911 last_pos
+= new_size
;
2914 if (new_sizes
) xfree (new_sizes
);
2916 /* We should have covered the parent exactly with child windows. */
2917 xassert (size
== last_pos
- first_pos
);
2919 /* Now delete any children that became too small. */
2921 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2924 c
= XWINDOW (child
);
2925 child_size
= width_p
? XINT (c
->total_cols
) : XINT (c
->total_lines
);
2926 size_window (child
, child_size
, width_p
, 2);
2931 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2932 WINDOW's children. NODELETE non-zero means don't delete windows
2933 that become too small in the process. (The caller should check
2934 later and do so if appropriate.) */
2937 set_window_height (window
, height
, nodelete
)
2942 size_window (window
, height
, 0, nodelete
);
2946 /* Set WINDOW's width to WIDTH, and recursively change the width of
2947 WINDOW's children. NODELETE non-zero means don't delete windows
2948 that become too small in the process. (The caller should check
2949 later and do so if appropriate.) */
2952 set_window_width (window
, width
, nodelete
)
2957 size_window (window
, width
, 1, nodelete
);
2960 /* Change window heights in windows rooted in WINDOW by N lines. */
2963 change_window_heights (window
, n
)
2967 struct window
*w
= XWINDOW (window
);
2969 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
2970 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
2972 if (INTEGERP (w
->orig_top_line
))
2973 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
2974 if (INTEGERP (w
->orig_total_lines
))
2975 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
2977 /* Handle just the top child in a vertical split. */
2978 if (!NILP (w
->vchild
))
2979 change_window_heights (w
->vchild
, n
);
2981 /* Adjust all children in a horizontal split. */
2982 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
2984 w
= XWINDOW (window
);
2985 change_window_heights (window
, n
);
2990 int window_select_count
;
2993 Fset_window_buffer_unwind (obuf
)
3000 EXFUN (Fset_window_fringes
, 4);
3001 EXFUN (Fset_window_scroll_bars
, 4);
3003 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
3004 means it's allowed to run hooks. See make_frame for a case where
3005 it's not allowed. KEEP_MARGINS_P non-zero means that the current
3006 margins, fringes, and scroll-bar settings of the window are not
3007 reset from the buffer's local settings. */
3010 set_window_buffer (window
, buffer
, run_hooks_p
, keep_margins_p
)
3011 Lisp_Object window
, buffer
;
3012 int run_hooks_p
, keep_margins_p
;
3014 struct window
*w
= XWINDOW (window
);
3015 struct buffer
*b
= XBUFFER (buffer
);
3016 int count
= SPECPDL_INDEX ();
3020 if (EQ (window
, selected_window
))
3021 b
->last_selected_window
= window
;
3023 /* Let redisplay errors through. */
3024 b
->display_error_modiff
= 0;
3026 /* Update time stamps of buffer display. */
3027 if (INTEGERP (b
->display_count
))
3028 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
3029 b
->display_time
= Fcurrent_time ();
3031 XSETFASTINT (w
->window_end_pos
, 0);
3032 XSETFASTINT (w
->window_end_vpos
, 0);
3033 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
3034 w
->window_end_valid
= Qnil
;
3035 w
->hscroll
= w
->min_hscroll
= make_number (0);
3037 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
3038 set_marker_restricted (w
->start
,
3039 make_number (b
->last_window_start
),
3041 w
->start_at_line_beg
= Qnil
;
3042 w
->force_start
= Qnil
;
3043 XSETFASTINT (w
->last_modified
, 0);
3044 XSETFASTINT (w
->last_overlay_modified
, 0);
3045 windows_or_buffers_changed
++;
3047 /* We must select BUFFER for running the window-scroll-functions.
3048 If WINDOW is selected, switch permanently.
3049 Otherwise, switch but go back to the ambient buffer afterward. */
3050 if (EQ (window
, selected_window
))
3051 Fset_buffer (buffer
);
3052 /* We can't check ! NILP (Vwindow_scroll_functions) here
3053 because that might itself be a local variable. */
3054 else if (window_initialized
)
3056 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
3057 Fset_buffer (buffer
);
3060 if (!keep_margins_p
)
3062 /* Set left and right marginal area width etc. from buffer. */
3064 /* This may call adjust_window_margins three times, so
3065 temporarily disable window margins. */
3066 Lisp_Object save_left
= w
->left_margin_cols
;
3067 Lisp_Object save_right
= w
->right_margin_cols
;
3069 w
->left_margin_cols
= w
->right_margin_cols
= Qnil
;
3071 Fset_window_fringes (window
,
3072 b
->left_fringe_width
, b
->right_fringe_width
,
3073 b
->fringes_outside_margins
);
3075 Fset_window_scroll_bars (window
,
3076 b
->scroll_bar_width
,
3077 b
->vertical_scroll_bar_type
, Qnil
);
3079 w
->left_margin_cols
= save_left
;
3080 w
->right_margin_cols
= save_right
;
3082 Fset_window_margins (window
,
3083 b
->left_margin_cols
, b
->right_margin_cols
);
3088 if (! NILP (Vwindow_scroll_functions
))
3089 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
3090 Fmarker_position (w
->start
));
3092 if (! NILP (Vwindow_configuration_change_hook
)
3093 && ! NILP (Vrun_hooks
))
3094 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3097 unbind_to (count
, Qnil
);
3101 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 3, 0,
3102 doc
: /* Make WINDOW display BUFFER as its contents.
3103 BUFFER can be a buffer or the name of an existing buffer.
3104 Optional third arg KEEP-MARGINS non-nil means that WINDOW's current
3105 display margins, fringe widths, and scroll bar settings are maintained;
3106 the default is to reset these from BUFFER's local settings or the frame
3109 This function runs the hook `window-scroll-functions'. */)
3110 (window
, buffer
, keep_margins
)
3111 register Lisp_Object window
, buffer
, keep_margins
;
3113 register Lisp_Object tem
;
3114 register struct window
*w
= decode_window (window
);
3116 XSETWINDOW (window
, w
);
3117 buffer
= Fget_buffer (buffer
);
3118 CHECK_BUFFER (buffer
);
3120 if (NILP (XBUFFER (buffer
)->name
))
3121 error ("Attempt to display deleted buffer");
3125 error ("Window is deleted");
3126 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
3127 is first being set up. */
3129 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
3130 error ("Window is dedicated to `%s'",
3131 SDATA (XBUFFER (tem
)->name
));
3136 set_window_buffer (window
, buffer
, 1, !NILP (keep_margins
));
3140 /* Note that selected_window can be nil
3141 when this is called from Fset_window_configuration. */
3143 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 2, 0,
3144 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
3145 If WINDOW is not already selected, make WINDOW's buffer current
3146 and make WINDOW the frame's selected window. Return WINDOW.
3147 Optional second arg NORECORD non-nil means
3148 do not put this buffer at the front of the list of recently selected ones.
3150 Note that the main editor command loop
3151 selects the buffer of the selected window before each command. */)
3153 register Lisp_Object window
, norecord
;
3155 register struct window
*w
;
3156 register struct window
*ow
;
3159 CHECK_LIVE_WINDOW (window
);
3161 w
= XWINDOW (window
);
3162 w
->frozen_window_start_p
= 0;
3164 ++window_select_count
;
3165 XSETFASTINT (w
->use_time
, window_select_count
);
3166 if (EQ (window
, selected_window
))
3169 /* Store the current buffer's actual point into the
3170 old selected window. It belongs to that window,
3171 and when the window is not selected, must be in the window. */
3172 if (!NILP (selected_window
))
3174 ow
= XWINDOW (selected_window
);
3175 if (! NILP (ow
->buffer
))
3176 set_marker_both (ow
->pointm
, ow
->buffer
,
3177 BUF_PT (XBUFFER (ow
->buffer
)),
3178 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
3181 selected_window
= window
;
3182 sf
= SELECTED_FRAME ();
3183 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
3185 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
3186 /* Use this rather than Fhandle_switch_frame
3187 so that FRAME_FOCUS_FRAME is moved appropriately as we
3188 move around in the state where a minibuffer in a separate
3190 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
3193 sf
->selected_window
= window
;
3195 if (NILP (norecord
))
3196 record_buffer (w
->buffer
);
3197 Fset_buffer (w
->buffer
);
3199 XBUFFER (w
->buffer
)->last_selected_window
= window
;
3201 /* Go to the point recorded in the window.
3202 This is important when the buffer is in more
3203 than one window. It also matters when
3204 redisplay_window has altered point after scrolling,
3205 because it makes the change only in the window. */
3207 register int new_point
= marker_position (w
->pointm
);
3208 if (new_point
< BEGV
)
3210 else if (new_point
> ZV
)
3216 windows_or_buffers_changed
++;
3221 select_window_norecord (window
)
3224 return Fselect_window (window
, Qt
);
3227 /* Deiconify the frame containing the window WINDOW,
3228 unless it is the selected frame;
3231 The reason for the exception for the selected frame
3232 is that it seems better not to change the selected frames visibility
3233 merely because of displaying a different buffer in it.
3234 The deiconification is useful when a buffer gets shown in
3235 another frame that you were not using lately. */
3238 display_buffer_1 (window
)
3241 Lisp_Object frame
= XWINDOW (window
)->frame
;
3242 FRAME_PTR f
= XFRAME (frame
);
3244 FRAME_SAMPLE_VISIBILITY (f
);
3246 if (EQ (frame
, selected_frame
))
3247 ; /* Assume the selected frame is already visible enough. */
3248 else if (minibuf_level
> 0
3249 && MINI_WINDOW_P (XWINDOW (selected_window
))
3250 && WINDOW_LIVE_P (minibuf_selected_window
)
3251 && EQ (frame
, WINDOW_FRAME (XWINDOW (minibuf_selected_window
))))
3252 ; /* Assume the frame from which we invoked the minibuffer is visible. */
3255 if (FRAME_ICONIFIED_P (f
))
3256 Fmake_frame_visible (frame
);
3257 else if (FRAME_VISIBLE_P (f
))
3258 Fraise_frame (frame
);
3264 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
3265 doc
: /* Returns non-nil if a buffer named BUFFER-NAME gets a special frame.
3266 If the value is t, `display-buffer' or `pop-to-buffer' would create a
3267 special frame for that buffer using the default frame parameters.
3269 If the value is a list, it is a list of frame parameters that would be used
3270 to make a frame for that buffer.
3271 The variables `special-display-buffer-names'
3272 and `special-display-regexps' control this. */)
3274 Lisp_Object buffer_name
;
3278 CHECK_STRING (buffer_name
);
3280 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
3284 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
3288 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3290 Lisp_Object car
= XCAR (tem
);
3292 && fast_string_match (car
, buffer_name
) >= 0)
3294 else if (CONSP (car
)
3295 && STRINGP (XCAR (car
))
3296 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3302 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
3303 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would use the same window.
3304 More precisely, if `display-buffer' or `pop-to-buffer' would display
3305 that buffer in the selected window rather than (as usual) in some other window.
3306 See `same-window-buffer-names' and `same-window-regexps'. */)
3308 Lisp_Object buffer_name
;
3312 CHECK_STRING (buffer_name
);
3314 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
3318 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
3322 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
3324 Lisp_Object car
= XCAR (tem
);
3326 && fast_string_match (car
, buffer_name
) >= 0)
3328 else if (CONSP (car
)
3329 && STRINGP (XCAR (car
))
3330 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
3336 /* Use B so the default is (other-buffer). */
3337 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
3338 "BDisplay buffer: \nP",
3339 doc
: /* Make BUFFER appear in some window but don't select it.
3340 BUFFER must be the name of an existing buffer, or, when called from Lisp,
3342 If BUFFER is shown already in some window, just use that one,
3343 unless the window is the selected window and the optional second
3344 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
3345 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
3346 Returns the window displaying BUFFER.
3347 If `display-buffer-reuse-frames' is non-nil, and another frame is currently
3348 displaying BUFFER, then simply raise that frame.
3350 The variables `special-display-buffer-names',
3351 `special-display-regexps', `same-window-buffer-names', and
3352 `same-window-regexps' customize how certain buffer names are handled.
3353 The latter two take effect only if NOT-THIS-WINDOW is t.
3355 If optional argument FRAME is `visible', search all visible frames.
3356 If FRAME is 0, search all visible and iconified frames.
3357 If FRAME is t, search all frames.
3358 If FRAME is a frame, search only that frame.
3359 If FRAME is nil, search only the selected frame
3360 (actually the last nonminibuffer frame),
3361 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
3362 which means search visible and iconified frames.
3364 If a full-width window on a splittable frame is available to display
3365 the buffer, it may be split, subject to the value of the variable
3366 `split-height-threshold'.
3368 If `even-window-heights' is non-nil, window heights will be evened out
3369 if displaying the buffer causes two vertically adjacent windows to be
3371 (buffer
, not_this_window
, frame
)
3372 register Lisp_Object buffer
, not_this_window
, frame
;
3374 register Lisp_Object window
, tem
, swp
;
3378 buffer
= Fget_buffer (buffer
);
3379 CHECK_BUFFER (buffer
);
3381 if (!NILP (Vdisplay_buffer_function
))
3382 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
3384 if (NILP (not_this_window
)
3385 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
3386 return display_buffer_1 (selected_window
);
3388 /* See if the user has specified this buffer should appear
3389 in the selected window. */
3390 if (NILP (not_this_window
))
3392 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
3393 if (!NILP (swp
) && !no_switch_window (selected_window
))
3395 Fswitch_to_buffer (buffer
, Qnil
);
3396 return display_buffer_1 (selected_window
);
3400 /* If the user wants pop-up-frames or display-buffer-reuse-frames,
3401 look for a window showing BUFFER on any visible or iconified frame.
3402 Otherwise search only the current frame. */
3405 else if (pop_up_frames
3406 || display_buffer_reuse_frames
3407 || last_nonminibuf_frame
== 0)
3408 XSETFASTINT (tem
, 0);
3410 XSETFRAME (tem
, last_nonminibuf_frame
);
3412 window
= Fget_buffer_window (buffer
, tem
);
3414 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
3415 return display_buffer_1 (window
);
3417 /* Certain buffer names get special handling. */
3418 if (!NILP (Vspecial_display_function
) && NILP (swp
))
3420 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
3422 return call1 (Vspecial_display_function
, buffer
);
3424 return call2 (Vspecial_display_function
, buffer
, tem
);
3427 /* If there are no frames open that have more than a minibuffer,
3428 we need to create a new frame. */
3429 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
3431 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3432 Fset_window_buffer (window
, buffer
, Qnil
);
3433 return display_buffer_1 (window
);
3436 f
= SELECTED_FRAME ();
3438 || FRAME_MINIBUF_ONLY_P (f
)
3439 /* If the current frame is a special display frame,
3440 don't try to reuse its windows. */
3441 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
3446 if (FRAME_MINIBUF_ONLY_P (f
))
3447 XSETFRAME (frames
, last_nonminibuf_frame
);
3448 /* Don't try to create a window if we would get an error. */
3449 if (split_height_threshold
< window_min_height
<< 1)
3450 split_height_threshold
= window_min_height
<< 1;
3452 /* Note that both Fget_largest_window and Fget_lru_window
3453 ignore minibuffers and dedicated windows.
3454 This means they can return nil. */
3456 /* If the frame we would try to split cannot be split,
3457 try other frames. */
3458 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
3460 /* Try visible frames first. */
3461 window
= Fget_largest_window (Qvisible
);
3462 /* If that didn't work, try iconified frames. */
3464 window
= Fget_largest_window (make_number (0));
3466 window
= Fget_largest_window (Qt
);
3469 window
= Fget_largest_window (frames
);
3471 /* If we got a tall enough full-width window that can be split,
3474 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3475 && window_height (window
) >= split_height_threshold
3476 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3477 window
= Fsplit_window (window
, Qnil
, Qnil
);
3480 Lisp_Object upper
, lower
, other
;
3482 window
= Fget_lru_window (frames
);
3483 /* If the LRU window is selected, and big enough,
3484 and can be split, split it. */
3486 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3487 && (EQ (window
, selected_window
)
3488 || EQ (XWINDOW (window
)->parent
, Qnil
))
3489 && window_height (window
) >= window_min_height
<< 1)
3490 window
= Fsplit_window (window
, Qnil
, Qnil
);
3491 /* If Fget_lru_window returned nil, try other approaches. */
3493 /* Try visible frames first. */
3495 window
= Fget_buffer_window (buffer
, Qvisible
);
3497 window
= Fget_largest_window (Qvisible
);
3498 /* If that didn't work, try iconified frames. */
3500 window
= Fget_buffer_window (buffer
, make_number (0));
3502 window
= Fget_largest_window (make_number (0));
3503 /* Try invisible frames. */
3505 window
= Fget_buffer_window (buffer
, Qt
);
3507 window
= Fget_largest_window (Qt
);
3508 /* As a last resort, make a new frame. */
3510 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3511 /* If window appears above or below another,
3512 even out their heights. */
3513 other
= upper
= lower
= Qnil
;
3514 if (!NILP (XWINDOW (window
)->prev
))
3515 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3516 if (!NILP (XWINDOW (window
)->next
))
3517 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3519 && !NILP (Veven_window_heights
)
3520 /* Check that OTHER and WINDOW are vertically arrayed. */
3521 && !EQ (XWINDOW (other
)->top_line
, XWINDOW (window
)->top_line
)
3522 && (XFASTINT (XWINDOW (other
)->total_lines
)
3523 > XFASTINT (XWINDOW (window
)->total_lines
)))
3525 int total
= (XFASTINT (XWINDOW (other
)->total_lines
)
3526 + XFASTINT (XWINDOW (window
)->total_lines
));
3527 enlarge_window (upper
,
3528 total
/ 2 - XFASTINT (XWINDOW (upper
)->total_lines
),
3534 window
= Fget_lru_window (Qnil
);
3536 Fset_window_buffer (window
, buffer
, Qnil
);
3537 return display_buffer_1 (window
);
3541 DEFUN ("force-window-update", Fforce_window_update
, Sforce_window_update
,
3543 doc
: /* Force redisplay of all windows.
3544 If optional arg OBJECT is a window, force redisplay of that window only.
3545 If OBJECT is a buffer or buffer name, force redisplay of all windows
3546 displaying that buffer. */)
3552 windows_or_buffers_changed
++;
3553 update_mode_lines
++;
3557 if (WINDOWP (object
))
3559 struct window
*w
= XWINDOW (object
);
3560 mark_window_display_accurate (object
, 0);
3561 w
->update_mode_line
= Qt
;
3562 if (BUFFERP (w
->buffer
))
3563 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
3564 ++update_mode_lines
;
3568 if (STRINGP (object
))
3569 object
= Fget_buffer (object
);
3570 if (BUFFERP (object
) && !NILP (XBUFFER (object
)->name
))
3572 /* Walk all windows looking for buffer, and force update
3573 of each of those windows. */
3575 object
= window_loop (REDISPLAY_BUFFER_WINDOWS
, object
, 0, Qvisible
);
3576 return NILP (object
) ? Qnil
: Qt
;
3579 /* If nothing suitable was found, just return.
3580 We could signal an error, but this feature will typically be used
3581 asynchronously in timers or process sentinels, so we don't. */
3587 temp_output_buffer_show (buf
)
3588 register Lisp_Object buf
;
3590 register struct buffer
*old
= current_buffer
;
3591 register Lisp_Object window
;
3592 register struct window
*w
;
3594 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3597 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3601 #if 0 /* rms: there should be no reason for this. */
3602 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3604 set_buffer_internal (old
);
3606 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3607 call1 (Vtemp_buffer_show_function
, buf
);
3610 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3612 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3613 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3614 Vminibuf_scroll_window
= window
;
3615 w
= XWINDOW (window
);
3616 XSETFASTINT (w
->hscroll
, 0);
3617 XSETFASTINT (w
->min_hscroll
, 0);
3618 set_marker_restricted_both (w
->start
, buf
, BEG
, BEG
);
3619 set_marker_restricted_both (w
->pointm
, buf
, BEG
, BEG
);
3621 /* Run temp-buffer-show-hook, with the chosen window selected
3622 and its buffer current. */
3624 if (!NILP (Vrun_hooks
)
3625 && !NILP (Fboundp (Qtemp_buffer_show_hook
))
3626 && !NILP (Fsymbol_value (Qtemp_buffer_show_hook
)))
3628 int count
= SPECPDL_INDEX ();
3629 Lisp_Object prev_window
, prev_buffer
;
3630 prev_window
= selected_window
;
3631 XSETBUFFER (prev_buffer
, old
);
3633 /* Select the window that was chosen, for running the hook.
3634 Note: Both Fselect_window and select_window_norecord may
3635 set-buffer to the buffer displayed in the window,
3636 so we need to save the current buffer. --stef */
3637 record_unwind_protect (Fset_buffer
, prev_buffer
);
3638 record_unwind_protect (select_window_norecord
, prev_window
);
3639 Fselect_window (window
, Qt
);
3640 Fset_buffer (w
->buffer
);
3641 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3642 unbind_to (count
, Qnil
);
3648 make_dummy_parent (window
)
3652 register struct window
*o
, *p
;
3655 o
= XWINDOW (window
);
3656 p
= allocate_window ();
3657 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3658 ((struct Lisp_Vector
*) p
)->contents
[i
]
3659 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3660 XSETWINDOW (new, p
);
3663 XSETFASTINT (p
->sequence_number
, sequence_number
);
3665 /* Put new into window structure in place of window */
3666 replace_window (window
, new);
3679 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3680 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3681 WINDOW defaults to selected one and SIZE to half its size.
3682 If optional third arg HORFLAG is non-nil, split side by side
3683 and put SIZE columns in the first of the pair. In that case,
3684 SIZE includes that window's scroll bar, or the divider column to its right.
3685 Interactively, all arguments are nil.
3687 Returns the newly created window (which is the lower or rightmost one).
3688 The upper or leftmost window is the original one and remains selected.
3689 See Info node `(elisp)Splitting Windows' for more details and examples.*/)
3690 (window
, size
, horflag
)
3691 Lisp_Object window
, size
, horflag
;
3693 register Lisp_Object
new;
3694 register struct window
*o
, *p
;
3696 register int size_int
;
3699 window
= selected_window
;
3701 CHECK_LIVE_WINDOW (window
);
3703 o
= XWINDOW (window
);
3704 fo
= XFRAME (WINDOW_FRAME (o
));
3708 if (!NILP (horflag
))
3709 /* Calculate the size of the left-hand window, by dividing
3710 the usable space in columns by two.
3711 We round up, since the left-hand window may include
3712 a dividing line, while the right-hand may not. */
3713 size_int
= (XFASTINT (o
->total_cols
) + 1) >> 1;
3715 size_int
= XFASTINT (o
->total_lines
) >> 1;
3719 CHECK_NUMBER (size
);
3720 size_int
= XINT (size
);
3723 if (MINI_WINDOW_P (o
))
3724 error ("Attempt to split minibuffer window");
3725 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3726 error ("Attempt to split fixed-size window");
3728 check_min_window_sizes ();
3732 if (size_int
< window_min_height
)
3733 error ("Window height %d too small (after splitting)", size_int
);
3734 if (size_int
+ window_min_height
> XFASTINT (o
->total_lines
))
3735 error ("Window height %d too small (after splitting)",
3736 XFASTINT (o
->total_lines
) - size_int
);
3737 if (NILP (o
->parent
)
3738 || NILP (XWINDOW (o
->parent
)->vchild
))
3740 make_dummy_parent (window
);
3742 XWINDOW (new)->vchild
= window
;
3747 if (size_int
< window_min_width
)
3748 error ("Window width %d too small (after splitting)", size_int
);
3750 if (size_int
+ window_min_width
> XFASTINT (o
->total_cols
))
3751 error ("Window width %d too small (after splitting)",
3752 XFASTINT (o
->total_cols
) - size_int
);
3753 if (NILP (o
->parent
)
3754 || NILP (XWINDOW (o
->parent
)->hchild
))
3756 make_dummy_parent (window
);
3758 XWINDOW (new)->hchild
= window
;
3762 /* Now we know that window's parent is a vertical combination
3763 if we are dividing vertically, or a horizontal combination
3764 if we are making side-by-side windows */
3766 windows_or_buffers_changed
++;
3767 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3768 new = make_window ();
3771 p
->frame
= o
->frame
;
3773 if (!NILP (p
->next
))
3774 XWINDOW (p
->next
)->prev
= new;
3777 p
->parent
= o
->parent
;
3779 p
->window_end_valid
= Qnil
;
3780 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3782 /* Duplicate special geometry settings. */
3784 p
->left_margin_cols
= o
->left_margin_cols
;
3785 p
->right_margin_cols
= o
->right_margin_cols
;
3786 p
->left_fringe_width
= o
->left_fringe_width
;
3787 p
->right_fringe_width
= o
->right_fringe_width
;
3788 p
->fringes_outside_margins
= o
->fringes_outside_margins
;
3789 p
->scroll_bar_width
= o
->scroll_bar_width
;
3790 p
->vertical_scroll_bar_type
= o
->vertical_scroll_bar_type
;
3792 /* Apportion the available frame space among the two new windows */
3794 if (!NILP (horflag
))
3796 p
->total_lines
= o
->total_lines
;
3797 p
->top_line
= o
->top_line
;
3798 XSETFASTINT (p
->total_cols
, XFASTINT (o
->total_cols
) - size_int
);
3799 XSETFASTINT (o
->total_cols
, size_int
);
3800 XSETFASTINT (p
->left_col
, XFASTINT (o
->left_col
) + size_int
);
3801 adjust_window_margins (p
);
3802 adjust_window_margins (o
);
3806 p
->left_col
= o
->left_col
;
3807 p
->total_cols
= o
->total_cols
;
3808 XSETFASTINT (p
->total_lines
, XFASTINT (o
->total_lines
) - size_int
);
3809 XSETFASTINT (o
->total_lines
, size_int
);
3810 XSETFASTINT (p
->top_line
, XFASTINT (o
->top_line
) + size_int
);
3813 /* Adjust glyph matrices. */
3816 Fset_window_buffer (new, o
->buffer
, Qt
);
3820 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 3, "p",
3821 doc
: /* Make current window ARG lines bigger.
3822 From program, optional second arg non-nil means grow sideways ARG columns.
3823 Interactively, if an argument is not given, make the window one line bigger.
3825 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3826 of the siblings above or to the left of the selected window. Only
3827 siblings to the right or below are changed. */)
3828 (arg
, side
, preserve_before
)
3829 register Lisp_Object arg
, side
, preserve_before
;
3832 enlarge_window (selected_window
, XINT (arg
), !NILP (side
),
3833 !NILP (preserve_before
));
3835 if (! NILP (Vwindow_configuration_change_hook
))
3836 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3841 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 3, "p",
3842 doc
: /* Make current window ARG lines smaller.
3843 From program, optional second arg non-nil means shrink sideways arg columns.
3844 Interactively, if an argument is not given, make the window one line smaller.
3846 Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
3847 of the siblings above or to the left of the selected window. Only
3848 siblings to the right or below are changed. */)
3849 (arg
, side
, preserve_before
)
3850 register Lisp_Object arg
, side
, preserve_before
;
3853 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
),
3854 !NILP (preserve_before
));
3856 if (! NILP (Vwindow_configuration_change_hook
))
3857 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3863 window_height (window
)
3866 register struct window
*p
= XWINDOW (window
);
3867 return WINDOW_TOTAL_LINES (p
);
3871 window_width (window
)
3874 register struct window
*p
= XWINDOW (window
);
3875 return WINDOW_TOTAL_COLS (p
);
3880 *(widthflag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
3882 #define CURSIZE(w) \
3883 *(widthflag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
3886 /* Enlarge WINDOW by DELTA. WIDTHFLAG non-zero means
3887 increase its width. Siblings of the selected window are resized to
3888 fulfill the size request. If they become too small in the process,
3889 they will be deleted.
3891 If PRESERVE_BEFORE is nonzero, that means don't alter
3892 the siblings to the left or above WINDOW. */
3895 enlarge_window (window
, delta
, widthflag
, preserve_before
)
3897 int delta
, widthflag
, preserve_before
;
3899 Lisp_Object parent
, next
, prev
;
3903 int (*sizefun
) P_ ((Lisp_Object
))
3904 = widthflag
? window_width
: window_height
;
3905 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3906 = (widthflag
? set_window_width
: set_window_height
);
3908 /* Check values of window_min_width and window_min_height for
3910 check_min_window_sizes ();
3912 /* Give up if this window cannot be resized. */
3913 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3914 error ("Window is not resizable");
3916 /* Find the parent of the selected window. */
3919 p
= XWINDOW (window
);
3925 error ("No other window to side of this one");
3930 ? !NILP (XWINDOW (parent
)->hchild
)
3931 : !NILP (XWINDOW (parent
)->vchild
))
3937 sizep
= &CURSIZE (window
);
3940 register int maxdelta
;
3942 /* Compute the maximum size increment this window can have. */
3944 if (preserve_before
)
3948 maxdelta
= (*sizefun
) (parent
) - XINT (*sizep
);
3949 /* Subtract size of siblings before, since we can't take that. */
3950 maxdelta
-= XINT (CURBEG (window
)) - XINT (CURBEG (parent
));
3953 maxdelta
= (!NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3954 - window_min_size (XWINDOW (p
->next
),
3959 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3960 /* This is a main window followed by a minibuffer. */
3961 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3962 - window_min_size (XWINDOW (p
->next
),
3964 /* This is a minibuffer following a main window. */
3965 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3966 - window_min_size (XWINDOW (p
->prev
),
3968 /* This is a frame with only one window, a minibuffer-only
3969 or a minibufferless frame. */
3972 if (delta
> maxdelta
)
3973 /* This case traps trying to make the minibuffer
3974 the full frame, or make the only window aside from the
3975 minibuffer the full frame. */
3979 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3981 delete_window (window
);
3988 /* Find the total we can get from other siblings without deleting them. */
3990 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3991 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3993 if (! preserve_before
)
3994 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3995 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3998 /* If we can get it all from them without deleting them, do so. */
3999 if (delta
<= maximum
)
4001 Lisp_Object first_unaffected
;
4002 Lisp_Object first_affected
;
4007 first_affected
= window
;
4008 /* Look at one sibling at a time,
4009 moving away from this window in both directions alternately,
4010 and take as much as we can get without deleting that sibling. */
4012 && (!NILP (next
) || (!preserve_before
&& !NILP (prev
))))
4016 int this_one
= ((*sizefun
) (next
)
4017 - window_min_size (XWINDOW (next
),
4018 widthflag
, 0, &fixed_p
));
4021 if (this_one
> delta
)
4024 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
4025 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4030 next
= XWINDOW (next
)->next
;
4036 if (!preserve_before
&& ! NILP (prev
))
4038 int this_one
= ((*sizefun
) (prev
)
4039 - window_min_size (XWINDOW (prev
),
4040 widthflag
, 0, &fixed_p
));
4043 if (this_one
> delta
)
4046 first_affected
= prev
;
4048 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
4049 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
4054 prev
= XWINDOW (prev
)->prev
;
4058 xassert (delta
== 0);
4060 /* Now recalculate the edge positions of all the windows affected,
4061 based on the new sizes. */
4062 first_unaffected
= next
;
4063 prev
= first_affected
;
4064 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
4065 prev
= next
, next
= XWINDOW (next
)->next
)
4067 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
4068 /* This does not change size of NEXT,
4069 but it propagates the new top edge to its children */
4070 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
4075 register int delta1
;
4076 register int opht
= (*sizefun
) (parent
);
4078 if (opht
<= XINT (*sizep
) + delta
)
4080 /* If trying to grow this window to or beyond size of the parent,
4081 just delete all the sibling windows. */
4082 Lisp_Object start
, tem
, next
;
4084 start
= XWINDOW (parent
)->vchild
;
4086 start
= XWINDOW (parent
)->hchild
;
4088 /* Delete any siblings that come after WINDOW. */
4089 tem
= XWINDOW (window
)->next
;
4090 while (! NILP (tem
))
4092 next
= XWINDOW (tem
)->next
;
4093 delete_window (tem
);
4097 /* Delete any siblings that come after WINDOW.
4098 Note that if START is not WINDOW, then WINDOW still
4099 Fhas siblings, so WINDOW has not yet replaced its parent. */
4101 while (! EQ (tem
, window
))
4103 next
= XWINDOW (tem
)->next
;
4104 delete_window (tem
);
4110 /* Otherwise, make delta1 just right so that if we add
4111 delta1 lines to this window and to the parent, and then
4112 shrink the parent back to its original size, the new
4113 proportional size of this window will increase by delta.
4115 The function size_window will compute the new height h'
4116 of the window from delta1 as:
4119 x = delta1 - delta1/n * n for the 1st resizable child
4122 where n is the number of children that can be resized.
4123 We can ignore x by choosing a delta1 that is a multiple of
4124 n. We want the height of this window to come out as
4134 The number of children n equals the number of resizable
4135 children of this window + 1 because we know window itself
4136 is resizable (otherwise we would have signalled an error. */
4138 struct window
*w
= XWINDOW (window
);
4142 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
4143 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4145 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
4146 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
4151 /* Add delta1 lines or columns to this window, and to the parent,
4152 keeping things consistent while not affecting siblings. */
4153 XSETINT (CURSIZE (parent
), opht
+ delta1
);
4154 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
4156 /* Squeeze out delta1 lines or columns from our parent,
4157 shriking this window and siblings proportionately.
4158 This brings parent back to correct size.
4159 Delta1 was calculated so this makes this window the desired size,
4160 taking it all out of the siblings. */
4161 (*setsizefun
) (parent
, opht
, 0);
4166 XSETFASTINT (p
->last_modified
, 0);
4167 XSETFASTINT (p
->last_overlay_modified
, 0);
4169 /* Adjust glyph matrices. */
4170 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
4178 /***********************************************************************
4179 Resizing Mini-Windows
4180 ***********************************************************************/
4182 static void shrink_window_lowest_first
P_ ((struct window
*, int));
4184 enum save_restore_action
4191 static int save_restore_orig_size
P_ ((struct window
*,
4192 enum save_restore_action
));
4194 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
4195 from lowest windows first. */
4198 shrink_window_lowest_first (w
, height
)
4206 xassert (!MINI_WINDOW_P (w
));
4208 /* Set redisplay hints. */
4209 XSETFASTINT (w
->last_modified
, 0);
4210 XSETFASTINT (w
->last_overlay_modified
, 0);
4211 windows_or_buffers_changed
++;
4212 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
4214 old_height
= XFASTINT (w
->total_lines
);
4215 XSETFASTINT (w
->total_lines
, height
);
4217 if (!NILP (w
->hchild
))
4219 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
4221 c
= XWINDOW (child
);
4222 c
->top_line
= w
->top_line
;
4223 shrink_window_lowest_first (c
, height
);
4226 else if (!NILP (w
->vchild
))
4228 Lisp_Object last_child
;
4229 int delta
= old_height
- height
;
4234 /* Find the last child. We are taking space from lowest windows
4235 first, so we iterate over children from the last child
4237 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
4240 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
4241 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
4245 c
= XWINDOW (child
);
4246 this_one
= XFASTINT (c
->total_lines
) - MIN_SAFE_WINDOW_HEIGHT
;
4248 if (this_one
> delta
)
4251 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
) - this_one
);
4255 /* Compute new positions. */
4256 last_top
= XINT (w
->top_line
);
4257 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
4259 c
= XWINDOW (child
);
4260 c
->top_line
= make_number (last_top
);
4261 shrink_window_lowest_first (c
, XFASTINT (c
->total_lines
));
4262 last_top
+= XFASTINT (c
->total_lines
);
4268 /* Save, restore, or check positions and sizes in the window tree
4269 rooted at W. ACTION says what to do.
4271 If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
4272 orig_total_lines members are valid for all windows in the window
4273 tree. Value is non-zero if they are valid.
4275 If ACTION is SAVE_ORIG_SIZES, save members top and height in
4276 orig_top_line and orig_total_lines for all windows in the tree.
4278 If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
4279 stored in orig_top_line and orig_total_lines for all windows. */
4282 save_restore_orig_size (w
, action
)
4284 enum save_restore_action action
;
4290 if (!NILP (w
->hchild
))
4292 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
4295 else if (!NILP (w
->vchild
))
4297 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
4303 case CHECK_ORIG_SIZES
:
4304 if (!INTEGERP (w
->orig_top_line
) || !INTEGERP (w
->orig_total_lines
))
4308 case SAVE_ORIG_SIZES
:
4309 w
->orig_top_line
= w
->top_line
;
4310 w
->orig_total_lines
= w
->total_lines
;
4311 XSETFASTINT (w
->last_modified
, 0);
4312 XSETFASTINT (w
->last_overlay_modified
, 0);
4315 case RESTORE_ORIG_SIZES
:
4316 xassert (INTEGERP (w
->orig_top_line
) && INTEGERP (w
->orig_total_lines
));
4317 w
->top_line
= w
->orig_top_line
;
4318 w
->total_lines
= w
->orig_total_lines
;
4319 w
->orig_total_lines
= w
->orig_top_line
= Qnil
;
4320 XSETFASTINT (w
->last_modified
, 0);
4321 XSETFASTINT (w
->last_overlay_modified
, 0);
4328 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
4335 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
4336 without deleting other windows. */
4339 grow_mini_window (w
, delta
)
4343 struct frame
*f
= XFRAME (w
->frame
);
4344 struct window
*root
;
4346 xassert (MINI_WINDOW_P (w
));
4347 xassert (delta
>= 0);
4349 /* Check values of window_min_width and window_min_height for
4351 check_min_window_sizes ();
4353 /* Compute how much we can enlarge the mini-window without deleting
4355 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4358 int min_height
= window_min_size (root
, 0, 0, 0);
4359 if (XFASTINT (root
->total_lines
) - delta
< min_height
)
4360 /* Note that the root window may already be smaller than
4362 delta
= max (0, XFASTINT (root
->total_lines
) - min_height
);
4367 /* Save original window sizes and positions, if not already done. */
4368 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4369 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
4371 /* Shrink other windows. */
4372 shrink_window_lowest_first (root
, XFASTINT (root
->total_lines
) - delta
);
4374 /* Grow the mini-window. */
4375 w
->top_line
= make_number (XFASTINT (root
->top_line
) + XFASTINT (root
->total_lines
));
4376 w
->total_lines
= make_number (XFASTINT (w
->total_lines
) + delta
);
4377 XSETFASTINT (w
->last_modified
, 0);
4378 XSETFASTINT (w
->last_overlay_modified
, 0);
4385 /* Shrink mini-window W. If there is recorded info about window sizes
4386 before a call to grow_mini_window, restore recorded window sizes.
4387 Otherwise, if the mini-window is higher than 1 line, resize it to 1
4391 shrink_mini_window (w
)
4394 struct frame
*f
= XFRAME (w
->frame
);
4395 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4397 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
4399 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
4401 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4402 windows_or_buffers_changed
= 1;
4404 else if (XFASTINT (w
->total_lines
) > 1)
4406 /* Distribute the additional lines of the mini-window
4407 among the other windows. */
4409 XSETWINDOW (window
, w
);
4410 enlarge_window (window
, 1 - XFASTINT (w
->total_lines
), 0, 0);
4416 /* Mark window cursors off for all windows in the window tree rooted
4417 at W by setting their phys_cursor_on_p flag to zero. Called from
4418 xterm.c, e.g. when a frame is cleared and thereby all cursors on
4419 the frame are cleared. */
4422 mark_window_cursors_off (w
)
4427 if (!NILP (w
->hchild
))
4428 mark_window_cursors_off (XWINDOW (w
->hchild
));
4429 else if (!NILP (w
->vchild
))
4430 mark_window_cursors_off (XWINDOW (w
->vchild
));
4432 w
->phys_cursor_on_p
= 0;
4434 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4439 /* Return number of lines of text (not counting mode lines) in W. */
4442 window_internal_height (w
)
4445 int ht
= XFASTINT (w
->total_lines
);
4447 if (!MINI_WINDOW_P (w
))
4449 if (!NILP (w
->parent
)
4450 || !NILP (w
->vchild
)
4451 || !NILP (w
->hchild
)
4454 || WINDOW_WANTS_MODELINE_P (w
))
4457 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4465 /* Return the number of columns in W.
4466 Don't count columns occupied by scroll bars or the vertical bar
4467 separating W from the sibling to its right. */
4470 window_box_text_cols (w
)
4473 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4474 int width
= XINT (w
->total_cols
);
4476 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4477 /* Scroll bars occupy a few columns. */
4478 width
-= WINDOW_CONFIG_SCROLL_BAR_COLS (w
);
4479 else if (!FRAME_WINDOW_P (f
)
4480 && !WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
4481 /* The column of `|' characters separating side-by-side windows
4482 occupies one column only. */
4485 if (FRAME_WINDOW_P (f
))
4486 /* On window-systems, fringes and display margins cannot be
4487 used for normal text. */
4488 width
-= (WINDOW_FRINGE_COLS (w
)
4489 + WINDOW_LEFT_MARGIN_COLS (w
)
4490 + WINDOW_RIGHT_MARGIN_COLS (w
));
4496 /************************************************************************
4498 ***********************************************************************/
4500 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
4501 N screen-fulls, which is defined as the height of the window minus
4502 next_screen_context_lines. If WHOLE is zero, scroll up N lines
4503 instead. Negative values of N mean scroll down. NOERROR non-zero
4504 means don't signal an error if we try to move over BEGV or ZV,
4508 window_scroll (window
, n
, whole
, noerror
)
4516 /* If we must, use the pixel-based version which is much slower than
4517 the line-based one but can handle varying line heights. */
4518 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
4519 window_scroll_pixel_based (window
, n
, whole
, noerror
);
4521 window_scroll_line_based (window
, n
, whole
, noerror
);
4527 /* Implementation of window_scroll that works based on pixel line
4528 heights. See the comment of window_scroll for parameter
4532 window_scroll_pixel_based (window
, n
, whole
, noerror
)
4539 struct window
*w
= XWINDOW (window
);
4540 struct text_pos start
;
4542 int this_scroll_margin
;
4544 /* True if we fiddled the window vscroll field without really scrolling. */
4547 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4549 /* If PT is not visible in WINDOW, move back one half of
4550 the screen. Allow PT to be partially visible, otherwise
4551 something like (scroll-down 1) with PT in the line before
4552 the partially visible one would recenter. */
4553 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
4556 /* Move backward half the height of the window. Performance note:
4557 vmotion used here is about 10% faster, but would give wrong
4558 results for variable height lines. */
4559 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4560 it
.current_y
= it
.last_visible_y
;
4561 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
4563 /* The function move_iterator_vertically may move over more than
4564 the specified y-distance. If it->w is small, e.g. a
4565 mini-buffer window, we may end up in front of the window's
4566 display area. This is the case when Start displaying at the
4567 start of the line containing PT in this case. */
4568 if (it
.current_y
<= 0)
4570 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
4571 move_it_vertically_backward (&it
, 0);
4575 start
= it
.current
.pos
;
4577 else if (auto_window_vscroll_p
)
4579 if (tem
= XCAR (XCDR (XCDR (tem
))), CONSP (tem
))
4582 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4584 dy
= max ((window_box_height (w
)
4585 - next_screen_context_lines
* dy
),
4589 if (n
< 0 && (px
= XINT (XCAR (tem
))) > 0)
4591 px
= max (0, -w
->vscroll
- min (px
, -dy
));
4592 Fset_window_vscroll (window
, make_number (px
), Qt
);
4595 if (n
> 0 && (px
= XINT (XCDR (tem
))) > 0)
4597 px
= max (0, -w
->vscroll
+ min (px
, dy
));
4598 Fset_window_vscroll (window
, make_number (px
), Qt
);
4602 Fset_window_vscroll (window
, make_number (0), Qt
);
4605 /* If scroll_preserve_screen_position is non-nil, we try to set
4606 point in the same window line as it is now, so get that line. */
4607 if (!NILP (Vscroll_preserve_screen_position
))
4609 start_display (&it
, w
, start
);
4610 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4611 preserve_y
= it
.current_y
;
4616 /* Move iterator it from start the specified distance forward or
4617 backward. The result is the new window start. */
4618 start_display (&it
, w
, start
);
4621 int start_pos
= IT_CHARPOS (it
);
4622 int dy
= WINDOW_FRAME_LINE_HEIGHT (w
);
4623 dy
= max ((window_box_height (w
)
4624 - next_screen_context_lines
* dy
),
4627 /* Note that move_it_vertically always moves the iterator to the
4628 start of a line. So, if the last line doesn't have a newline,
4629 we would end up at the start of the line ending at ZV. */
4632 move_it_vertically_backward (&it
, -dy
);
4633 /* Ensure we actually does move, e.g. in case we are currently
4634 looking at an image that is taller that the window height. */
4635 while (start_pos
== IT_CHARPOS (it
)
4636 && start_pos
> BEGV
)
4637 move_it_by_lines (&it
, -1, 1);
4641 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
4642 MOVE_TO_POS
| MOVE_TO_Y
);
4643 /* Ensure we actually does move, e.g. in case we are currently
4644 looking at an image that is taller that the window height. */
4645 while (start_pos
== IT_CHARPOS (it
)
4647 move_it_by_lines (&it
, 1, 1);
4651 move_it_by_lines (&it
, n
, 1);
4653 /* We failed if we find ZV is already on the screen (scrolling up,
4654 means there's nothing past the end), or if we can't start any
4655 earlier (scrolling down, means there's nothing past the top). */
4656 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4657 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4659 if (IT_CHARPOS (it
) == ZV
)
4661 if (it
.current_y
< it
.last_visible_y
4662 && (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4663 >= it
.last_visible_y
))
4665 /* The last line was only partially visible, make it fully
4667 w
->vscroll
= (it
.last_visible_y
4668 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4669 adjust_glyphs (it
.f
);
4674 Fsignal (Qend_of_buffer
, Qnil
);
4678 if (w
->vscroll
!= 0)
4679 /* The first line was only partially visible, make it fully
4685 Fsignal (Qbeginning_of_buffer
, Qnil
);
4688 /* If control gets here, then we vscrolled. */
4690 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4692 /* Don't try to change the window start below. */
4698 int pos
= IT_CHARPOS (it
);
4701 /* If in the middle of a multi-glyph character move forward to
4702 the next character. */
4703 if (in_display_vector_p (&it
))
4706 move_it_to (&it
, pos
, -1, -1, -1, MOVE_TO_POS
);
4709 /* Set the window start, and set up the window for redisplay. */
4710 set_marker_restricted (w
->start
, make_number (pos
),
4712 bytepos
= XMARKER (w
->start
)->bytepos
;
4713 w
->start_at_line_beg
= ((pos
== BEGV
|| FETCH_BYTE (bytepos
- 1) == '\n')
4715 w
->update_mode_line
= Qt
;
4716 XSETFASTINT (w
->last_modified
, 0);
4717 XSETFASTINT (w
->last_overlay_modified
, 0);
4718 /* Set force_start so that redisplay_window will run the
4719 window-scroll-functions. */
4720 w
->force_start
= Qt
;
4723 /* The rest of this function uses current_y in a nonstandard way,
4724 not including the height of the header line if any. */
4725 it
.current_y
= it
.vpos
= 0;
4727 /* Move PT out of scroll margins.
4728 This code wants current_y to be zero at the window start position
4729 even if there is a header line. */
4730 this_scroll_margin
= max (0, scroll_margin
);
4731 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->total_lines
) / 4);
4732 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
4736 /* We moved the window start towards ZV, so PT may be now
4737 in the scroll margin at the top. */
4738 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4739 if (IT_CHARPOS (it
) == PT
&& it
.current_y
>= this_scroll_margin
)
4740 /* We found PT at a legitimate height. Leave it alone. */
4742 else if (preserve_y
>= 0)
4744 /* If we have a header line, take account of it.
4745 This is necessary because we set it.current_y to 0, above. */
4746 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4747 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4749 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4750 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4754 while (it
.current_y
< this_scroll_margin
)
4756 int prev
= it
.current_y
;
4757 move_it_by_lines (&it
, 1, 1);
4758 if (prev
== it
.current_y
)
4761 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4766 int charpos
, bytepos
;
4769 /* Save our position, for the preserve_y case. */
4770 charpos
= IT_CHARPOS (it
);
4771 bytepos
= IT_BYTEPOS (it
);
4773 /* We moved the window start towards BEGV, so PT may be now
4774 in the scroll margin at the bottom. */
4775 move_it_to (&it
, PT
, -1,
4776 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4777 MOVE_TO_POS
| MOVE_TO_Y
);
4779 /* Save our position, in case it's correct. */
4780 charpos
= IT_CHARPOS (it
);
4781 bytepos
= IT_BYTEPOS (it
);
4783 /* See if point is on a partially visible line at the end. */
4784 if (it
.what
== IT_EOB
)
4785 partial_p
= it
.current_y
+ it
.ascent
+ it
.descent
> it
.last_visible_y
;
4788 move_it_by_lines (&it
, 1, 1);
4789 partial_p
= it
.current_y
> it
.last_visible_y
;
4792 if (charpos
== PT
&& !partial_p
)
4793 /* We found PT before we found the display margin, so PT is ok. */
4795 else if (preserve_y
>= 0)
4797 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4798 start_display (&it
, w
, start
);
4799 #if 0 /* It's wrong to subtract this here
4800 because we called start_display again
4801 and did not alter it.current_y this time. */
4803 /* If we have a header line, take account of it. */
4804 if (WINDOW_WANTS_HEADER_LINE_P (w
))
4805 preserve_y
-= CURRENT_HEADER_LINE_HEIGHT (w
);
4808 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4809 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4814 /* The last line was only partially visible, so back up two
4815 lines to make sure we're on a fully visible line. */
4817 move_it_by_lines (&it
, -2, 0);
4818 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4821 /* No, the position we saved is OK, so use it. */
4822 SET_PT_BOTH (charpos
, bytepos
);
4828 /* Implementation of window_scroll that works based on screen lines.
4829 See the comment of window_scroll for parameter descriptions. */
4832 window_scroll_line_based (window
, n
, whole
, noerror
)
4838 register struct window
*w
= XWINDOW (window
);
4839 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4840 register int pos
, pos_byte
;
4841 register int ht
= window_internal_height (w
);
4842 register Lisp_Object tem
;
4846 struct position posit
;
4849 /* If scrolling screen-fulls, compute the number of lines to
4850 scroll from the window's height. */
4852 n
*= max (1, ht
- next_screen_context_lines
);
4854 startpos
= marker_position (w
->start
);
4856 posit
= *compute_motion (startpos
, 0, 0, 0,
4858 -1, XINT (w
->hscroll
),
4860 original_vpos
= posit
.vpos
;
4862 XSETFASTINT (tem
, PT
);
4863 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4867 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4872 lose
= n
< 0 && PT
== BEGV
;
4873 Fvertical_motion (make_number (n
), window
);
4877 SET_PT_BOTH (opoint
, opoint_byte
);
4884 Fsignal (Qbeginning_of_buffer
, Qnil
);
4889 int this_scroll_margin
= scroll_margin
;
4891 /* Don't use a scroll margin that is negative or too large. */
4892 if (this_scroll_margin
< 0)
4893 this_scroll_margin
= 0;
4895 if (XINT (w
->total_lines
) < 4 * scroll_margin
)
4896 this_scroll_margin
= XINT (w
->total_lines
) / 4;
4898 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4899 w
->start_at_line_beg
= bolp
;
4900 w
->update_mode_line
= Qt
;
4901 XSETFASTINT (w
->last_modified
, 0);
4902 XSETFASTINT (w
->last_overlay_modified
, 0);
4903 /* Set force_start so that redisplay_window will run
4904 the window-scroll-functions. */
4905 w
->force_start
= Qt
;
4907 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4909 SET_PT_BOTH (pos
, pos_byte
);
4910 Fvertical_motion (make_number (original_vpos
), window
);
4912 /* If we scrolled forward, put point enough lines down
4913 that it is outside the scroll margin. */
4918 if (this_scroll_margin
> 0)
4920 SET_PT_BOTH (pos
, pos_byte
);
4921 Fvertical_motion (make_number (this_scroll_margin
), window
);
4927 if (top_margin
<= opoint
)
4928 SET_PT_BOTH (opoint
, opoint_byte
);
4929 else if (!NILP (Vscroll_preserve_screen_position
))
4931 SET_PT_BOTH (pos
, pos_byte
);
4932 Fvertical_motion (make_number (original_vpos
), window
);
4935 SET_PT (top_margin
);
4941 /* If we scrolled backward, put point near the end of the window
4942 but not within the scroll margin. */
4943 SET_PT_BOTH (pos
, pos_byte
);
4944 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4945 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4948 bottom_margin
= PT
+ 1;
4950 if (bottom_margin
> opoint
)
4951 SET_PT_BOTH (opoint
, opoint_byte
);
4954 if (!NILP (Vscroll_preserve_screen_position
))
4956 SET_PT_BOTH (pos
, pos_byte
);
4957 Fvertical_motion (make_number (original_vpos
), window
);
4960 Fvertical_motion (make_number (-1), window
);
4969 Fsignal (Qend_of_buffer
, Qnil
);
4974 /* Scroll selected_window up or down. If N is nil, scroll a
4975 screen-full which is defined as the height of the window minus
4976 next_screen_context_lines. If N is the symbol `-', scroll.
4977 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4978 up. This is the guts of Fscroll_up and Fscroll_down. */
4981 scroll_command (n
, direction
)
4985 int count
= SPECPDL_INDEX ();
4987 xassert (abs (direction
) == 1);
4989 /* If selected window's buffer isn't current, make it current for
4990 the moment. But don't screw up if window_scroll gets an error. */
4991 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4993 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4994 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4996 /* Make redisplay consider other windows than just selected_window. */
4997 ++windows_or_buffers_changed
;
5001 window_scroll (selected_window
, direction
, 1, 0);
5002 else if (EQ (n
, Qminus
))
5003 window_scroll (selected_window
, -direction
, 1, 0);
5006 n
= Fprefix_numeric_value (n
);
5007 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
5010 unbind_to (count
, Qnil
);
5013 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
5014 doc
: /* Scroll text of current window upward ARG lines.
5015 If ARG is omitted or nil, scroll upward by a near full screen.
5016 A near full screen is `next-screen-context-lines' less than a full screen.
5017 Negative ARG means scroll downward.
5018 If ARG is the atom `-', scroll downward by nearly full screen.
5019 When calling from a program, supply as argument a number, nil, or `-'. */)
5023 scroll_command (arg
, 1);
5027 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
5028 doc
: /* Scroll text of current window down ARG lines.
5029 If ARG is omitted or nil, scroll down by a near full screen.
5030 A near full screen is `next-screen-context-lines' less than a full screen.
5031 Negative ARG means scroll upward.
5032 If ARG is the atom `-', scroll upward by nearly full screen.
5033 When calling from a program, supply as argument a number, nil, or `-'. */)
5037 scroll_command (arg
, -1);
5041 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
5042 doc
: /* Return the other window for \"other window scroll\" commands.
5043 If `other-window-scroll-buffer' is non-nil, a window
5044 showing that buffer is used.
5045 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5046 specifies the window. This takes precedence over
5047 `other-window-scroll-buffer'. */)
5052 if (MINI_WINDOW_P (XWINDOW (selected_window
))
5053 && !NILP (Vminibuf_scroll_window
))
5054 window
= Vminibuf_scroll_window
;
5055 /* If buffer is specified, scroll that buffer. */
5056 else if (!NILP (Vother_window_scroll_buffer
))
5058 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
5060 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
5064 /* Nothing specified; look for a neighboring window on the same
5066 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
5068 if (EQ (window
, selected_window
))
5069 /* That didn't get us anywhere; look for a window on another
5072 window
= Fnext_window (window
, Qnil
, Qt
);
5073 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
5074 && ! EQ (window
, selected_window
));
5077 CHECK_LIVE_WINDOW (window
);
5079 if (EQ (window
, selected_window
))
5080 error ("There is no other window");
5085 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
5086 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
5087 A near full screen is `next-screen-context-lines' less than a full screen.
5088 The next window is the one below the current one; or the one at the top
5089 if the current one is at the bottom. Negative ARG means scroll downward.
5090 If ARG is the atom `-', scroll downward by nearly full screen.
5091 When calling from a program, supply as argument a number, nil, or `-'.
5093 If `other-window-scroll-buffer' is non-nil, scroll the window
5094 showing that buffer, popping the buffer up if necessary.
5095 If in the minibuffer, `minibuffer-scroll-window' if non-nil
5096 specifies the window to scroll. This takes precedence over
5097 `other-window-scroll-buffer'. */)
5103 int count
= SPECPDL_INDEX ();
5105 window
= Fother_window_for_scrolling ();
5106 w
= XWINDOW (window
);
5108 /* Don't screw up if window_scroll gets an error. */
5109 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
5110 ++windows_or_buffers_changed
;
5112 Fset_buffer (w
->buffer
);
5113 SET_PT (marker_position (w
->pointm
));
5116 window_scroll (window
, 1, 1, 1);
5117 else if (EQ (arg
, Qminus
))
5118 window_scroll (window
, -1, 1, 1);
5124 window_scroll (window
, XINT (arg
), 0, 1);
5127 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
5128 unbind_to (count
, Qnil
);
5133 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 2, "P\np",
5134 doc
: /* Scroll selected window display ARG columns left.
5135 Default for ARG is window width minus 2.
5136 Value is the total amount of leftward horizontal scrolling in
5137 effect after the change.
5138 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5139 lower bound for automatic scrolling, i.e. automatic scrolling
5140 will not scroll a window to a column less than the value returned
5141 by this function. This happens in an interactive call. */)
5143 register Lisp_Object arg
, set_minimum
;
5147 struct window
*w
= XWINDOW (selected_window
);
5150 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5152 arg
= Fprefix_numeric_value (arg
);
5154 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
5155 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5157 if (!NILP (set_minimum
))
5158 w
->min_hscroll
= w
->hscroll
;
5163 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 2, "P\np",
5164 doc
: /* Scroll selected window display ARG columns right.
5165 Default for ARG is window width minus 2.
5166 Value is the total amount of leftward horizontal scrolling in
5167 effect after the change.
5168 If SET_MINIMUM is non-nil, the new scroll amount becomes the
5169 lower bound for automatic scrolling, i.e. automatic scrolling
5170 will not scroll a window to a column less than the value returned
5171 by this function. This happens in an interactive call. */)
5173 register Lisp_Object arg
, set_minimum
;
5177 struct window
*w
= XWINDOW (selected_window
);
5180 XSETFASTINT (arg
, window_box_text_cols (w
) - 2);
5182 arg
= Fprefix_numeric_value (arg
);
5184 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
5185 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
5187 if (!NILP (set_minimum
))
5188 w
->min_hscroll
= w
->hscroll
;
5193 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window
, Sminibuffer_selected_window
, 0, 0, 0,
5194 doc
: /* Return the window which was selected when entering the minibuffer.
5195 Returns nil, if current window is not a minibuffer window. */)
5198 if (minibuf_level
> 0
5199 && MINI_WINDOW_P (XWINDOW (selected_window
))
5200 && WINDOW_LIVE_P (minibuf_selected_window
))
5201 return minibuf_selected_window
;
5206 /* Value is the number of lines actually displayed in window W,
5207 as opposed to its height. */
5210 displayed_window_lines (w
)
5214 struct text_pos start
;
5215 int height
= window_box_height (w
);
5216 struct buffer
*old_buffer
;
5219 if (XBUFFER (w
->buffer
) != current_buffer
)
5221 old_buffer
= current_buffer
;
5222 set_buffer_internal (XBUFFER (w
->buffer
));
5227 /* In case W->start is out of the accessible range, do something
5228 reasonable. This happens in Info mode when Info-scroll-down
5229 calls (recenter -1) while W->start is 1. */
5230 if (XMARKER (w
->start
)->charpos
< BEGV
)
5231 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
5232 else if (XMARKER (w
->start
)->charpos
> ZV
)
5233 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
5235 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
5237 start_display (&it
, w
, start
);
5238 move_it_vertically (&it
, height
);
5239 bottom_y
= line_bottom_y (&it
);
5241 /* rms: On a non-window display,
5242 the value of it.vpos at the bottom of the screen
5243 seems to be 1 larger than window_box_height (w).
5244 This kludge fixes a bug whereby (move-to-window-line -1)
5245 when ZV is on the last screen line
5246 moves to the previous screen line instead of the last one. */
5247 if (! FRAME_WINDOW_P (XFRAME (w
->frame
)))
5250 /* Add in empty lines at the bottom of the window. */
5251 if (bottom_y
< height
)
5253 int uy
= FRAME_LINE_HEIGHT (it
.f
);
5254 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
5258 set_buffer_internal (old_buffer
);
5264 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
5265 doc
: /* Center point in window and redisplay frame.
5266 With prefix argument ARG, recenter putting point on screen line ARG
5267 relative to the current window. If ARG is negative, it counts up from the
5268 bottom of the window. (ARG should be less than the height of the window.)
5270 If ARG is omitted or nil, erase the entire frame and then
5271 redraw with point in the center of the current window.
5272 Just C-u as prefix means put point in the center of the window
5273 and redisplay normally--don't erase and redraw the frame. */)
5275 register Lisp_Object arg
;
5277 struct window
*w
= XWINDOW (selected_window
);
5278 struct buffer
*buf
= XBUFFER (w
->buffer
);
5279 struct buffer
*obuf
= current_buffer
;
5281 int charpos
, bytepos
;
5283 /* If redisplay is suppressed due to an error, try again. */
5284 obuf
->display_error_modiff
= 0;
5290 /* Invalidate pixel data calculated for all compositions. */
5291 for (i
= 0; i
< n_compositions
; i
++)
5292 composition_table
[i
]->font
= NULL
;
5294 Fredraw_frame (w
->frame
);
5295 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
5298 else if (CONSP (arg
)) /* Just C-u. */
5302 arg
= Fprefix_numeric_value (arg
);
5306 set_buffer_internal (buf
);
5308 /* Handle centering on a graphical frame specially. Such frames can
5309 have variable-height lines and centering point on the basis of
5310 line counts would lead to strange effects. */
5311 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
5318 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5319 start_display (&it
, w
, pt
);
5320 move_it_vertically_backward (&it
, window_box_height (w
) / 2);
5321 charpos
= IT_CHARPOS (it
);
5322 bytepos
= IT_BYTEPOS (it
);
5324 else if (XINT (arg
) < 0)
5328 int nlines
= - XINT (arg
);
5329 int extra_line_spacing
;
5330 int h
= window_box_height (w
);
5332 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
5333 start_display (&it
, w
, pt
);
5335 /* Be sure we have the exact height of the full line containing PT. */
5336 move_it_by_lines (&it
, 0, 1);
5338 /* The amount of pixels we have to move back is the window
5339 height minus what's displayed in the line containing PT,
5340 and the lines below. */
5343 move_it_by_lines (&it
, nlines
, 1);
5345 if (it
.vpos
== nlines
)
5349 /* Last line has no newline */
5350 h
-= line_bottom_y (&it
);
5354 /* Don't reserve space for extra line spacing of last line. */
5355 extra_line_spacing
= it
.max_extra_line_spacing
;
5357 /* If we can't move down NLINES lines because we hit
5358 the end of the buffer, count in some empty lines. */
5359 if (it
.vpos
< nlines
)
5362 extra_line_spacing
= it
.extra_line_spacing
;
5363 h
-= nlines
* (FRAME_LINE_HEIGHT (it
.f
) + extra_line_spacing
);
5368 /* Now find the new top line (starting position) of the window. */
5369 start_display (&it
, w
, pt
);
5371 move_it_vertically_backward (&it
, h
);
5373 /* If extra line spacing is present, we may move too far
5374 back. This causes the last line to be only partially
5375 visible (which triggers redisplay to recenter that line
5376 in the middle), so move forward.
5377 But ignore extra line spacing on last line, as it is not
5378 considered to be part of the visible height of the line.
5380 h
+= extra_line_spacing
;
5381 while (-it
.current_y
> h
)
5382 move_it_by_lines (&it
, 1, 1);
5384 charpos
= IT_CHARPOS (it
);
5385 bytepos
= IT_BYTEPOS (it
);
5389 struct position pos
;
5390 pos
= *vmotion (PT
, - XINT (arg
), w
);
5391 charpos
= pos
.bufpos
;
5392 bytepos
= pos
.bytepos
;
5397 struct position pos
;
5398 int ht
= window_internal_height (w
);
5401 arg
= make_number (ht
/ 2);
5402 else if (XINT (arg
) < 0)
5403 arg
= make_number (XINT (arg
) + ht
);
5405 pos
= *vmotion (PT
, - XINT (arg
), w
);
5406 charpos
= pos
.bufpos
;
5407 bytepos
= pos
.bytepos
;
5410 /* Set the new window start. */
5411 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
5412 w
->window_end_valid
= Qnil
;
5414 w
->optional_new_start
= Qt
;
5416 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
5417 w
->start_at_line_beg
= Qt
;
5419 w
->start_at_line_beg
= Qnil
;
5421 set_buffer_internal (obuf
);
5426 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
5428 doc
: /* Return the height in lines of the text display area of WINDOW.
5429 This doesn't include the mode-line (or header-line if any) or any
5430 partial-height lines in the text display area. */)
5434 struct window
*w
= decode_window (window
);
5435 int pixel_height
= window_box_height (w
);
5436 int line_height
= pixel_height
/ FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
5437 return make_number (line_height
);
5442 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
5444 doc
: /* Position point relative to window.
5445 With no argument, position point at center of window.
5446 An argument specifies vertical position within the window;
5447 zero means top of window, negative means relative to bottom of window. */)
5451 struct window
*w
= XWINDOW (selected_window
);
5455 window
= selected_window
;
5456 start
= marker_position (w
->start
);
5457 if (start
< BEGV
|| start
> ZV
)
5459 int height
= window_internal_height (w
);
5460 Fvertical_motion (make_number (- (height
/ 2)), window
);
5461 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
5462 w
->start_at_line_beg
= Fbolp ();
5463 w
->force_start
= Qt
;
5466 Fgoto_char (w
->start
);
5468 lines
= displayed_window_lines (w
);
5470 XSETFASTINT (arg
, lines
/ 2);
5473 arg
= Fprefix_numeric_value (arg
);
5475 XSETINT (arg
, XINT (arg
) + lines
);
5478 /* Skip past a partially visible first line. */
5480 XSETINT (arg
, XINT (arg
) + 1);
5482 return Fvertical_motion (arg
, window
);
5487 /***********************************************************************
5488 Window Configuration
5489 ***********************************************************************/
5491 struct save_window_data
5493 EMACS_INT size_from_Lisp_Vector_struct
;
5494 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5495 Lisp_Object frame_cols
, frame_lines
, frame_menu_bar_lines
;
5496 Lisp_Object frame_tool_bar_lines
;
5497 Lisp_Object selected_frame
;
5498 Lisp_Object current_window
;
5499 Lisp_Object current_buffer
;
5500 Lisp_Object minibuf_scroll_window
;
5501 Lisp_Object minibuf_selected_window
;
5502 Lisp_Object root_window
;
5503 Lisp_Object focus_frame
;
5504 /* Record the values of window-min-width and window-min-height
5505 so that window sizes remain consistent with them. */
5506 Lisp_Object min_width
, min_height
;
5507 /* A vector, each of whose elements is a struct saved_window
5509 Lisp_Object saved_windows
;
5512 /* This is saved as a Lisp_Vector */
5515 /* these first two must agree with struct Lisp_Vector in lisp.h */
5516 EMACS_INT size_from_Lisp_Vector_struct
;
5517 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
5520 Lisp_Object buffer
, start
, pointm
, mark
;
5521 Lisp_Object left_col
, top_line
, total_cols
, total_lines
;
5522 Lisp_Object hscroll
, min_hscroll
;
5523 Lisp_Object parent
, prev
;
5524 Lisp_Object start_at_line_beg
;
5525 Lisp_Object display_table
;
5526 Lisp_Object orig_top_line
, orig_total_lines
;
5527 Lisp_Object left_margin_cols
, right_margin_cols
;
5528 Lisp_Object left_fringe_width
, right_fringe_width
, fringes_outside_margins
;
5529 Lisp_Object scroll_bar_width
, vertical_scroll_bar_type
;
5532 #define SAVED_WINDOW_VECTOR_SIZE 24 /* Arg to Fmake_vector */
5534 #define SAVED_WINDOW_N(swv,n) \
5535 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
5537 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
5538 doc
: /* Return t if OBJECT is a window-configuration object. */)
5542 if (WINDOW_CONFIGURATIONP (object
))
5547 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
5548 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
5552 register struct save_window_data
*data
;
5553 struct Lisp_Vector
*saved_windows
;
5555 if (! WINDOW_CONFIGURATIONP (config
))
5556 wrong_type_argument (Qwindow_configuration_p
, config
);
5558 data
= (struct save_window_data
*) XVECTOR (config
);
5559 saved_windows
= XVECTOR (data
->saved_windows
);
5560 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5563 DEFUN ("set-window-configuration", Fset_window_configuration
,
5564 Sset_window_configuration
, 1, 1, 0,
5565 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
5566 CONFIGURATION must be a value previously returned
5567 by `current-window-configuration' (which see).
5568 If CONFIGURATION was made from a frame that is now deleted,
5569 only frame-independent values can be restored. In this case,
5570 the return value is nil. Otherwise the value is t. */)
5572 Lisp_Object configuration
;
5574 register struct save_window_data
*data
;
5575 struct Lisp_Vector
*saved_windows
;
5576 Lisp_Object new_current_buffer
;
5581 while (!WINDOW_CONFIGURATIONP (configuration
))
5582 wrong_type_argument (Qwindow_configuration_p
, configuration
);
5584 data
= (struct save_window_data
*) XVECTOR (configuration
);
5585 saved_windows
= XVECTOR (data
->saved_windows
);
5587 new_current_buffer
= data
->current_buffer
;
5588 if (NILP (XBUFFER (new_current_buffer
)->name
))
5589 new_current_buffer
= Qnil
;
5592 if (XBUFFER (new_current_buffer
) == current_buffer
)
5595 /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
5596 point in new_current_buffer as of the last time this buffer was
5597 used. This can be non-deterministic since it can be changed by
5598 things like jit-lock by mere temporary selection of some random
5599 window that happens to show this buffer.
5600 So if possible we want this arbitrary choice of "which point" to
5601 be the one from the to-be-selected-window so as to prevent this
5602 window's cursor from being copied from another window. */
5603 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
)
5604 /* If current_window = selected_window, its point is in BUF_PT. */
5605 && !EQ (selected_window
, data
->current_window
))
5606 old_point
= XMARKER (XWINDOW (data
->current_window
)->pointm
)->charpos
;
5608 old_point
= BUF_PT (XBUFFER (new_current_buffer
));
5611 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
5614 /* If f is a dead frame, don't bother rebuilding its window tree.
5615 However, there is other stuff we should still try to do below. */
5616 if (FRAME_LIVE_P (f
))
5618 register struct window
*w
;
5619 register struct saved_window
*p
;
5620 struct window
*root_window
;
5621 struct window
**leaf_windows
;
5625 /* If the frame has been resized since this window configuration was
5626 made, we change the frame to the size specified in the
5627 configuration, restore the configuration, and then resize it
5628 back. We keep track of the prevailing height in these variables. */
5629 int previous_frame_lines
= FRAME_LINES (f
);
5630 int previous_frame_cols
= FRAME_COLS (f
);
5631 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
5632 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
5634 /* The mouse highlighting code could get screwed up
5635 if it runs during this. */
5638 if (XFASTINT (data
->frame_lines
) != previous_frame_lines
5639 || XFASTINT (data
->frame_cols
) != previous_frame_cols
)
5640 change_frame_size (f
, XFASTINT (data
->frame_lines
),
5641 XFASTINT (data
->frame_cols
), 0, 0, 0);
5642 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5643 if (XFASTINT (data
->frame_menu_bar_lines
)
5644 != previous_frame_menu_bar_lines
)
5645 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
5646 #ifdef HAVE_WINDOW_SYSTEM
5647 if (XFASTINT (data
->frame_tool_bar_lines
)
5648 != previous_frame_tool_bar_lines
)
5649 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
5653 /* "Swap out" point from the selected window's buffer
5654 into the window itself. (Normally the pointm of the selected
5655 window holds garbage.) We do this now, before
5656 restoring the window contents, and prevent it from
5657 being done later on when we select a new window. */
5658 if (! NILP (XWINDOW (selected_window
)->buffer
))
5660 w
= XWINDOW (selected_window
);
5661 set_marker_both (w
->pointm
,
5663 BUF_PT (XBUFFER (w
->buffer
)),
5664 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5667 windows_or_buffers_changed
++;
5668 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
5670 /* Problem: Freeing all matrices and later allocating them again
5671 is a serious redisplay flickering problem. What we would
5672 really like to do is to free only those matrices not reused
5674 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5676 = (struct window
**) alloca (count_windows (root_window
)
5677 * sizeof (struct window
*));
5678 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
5680 /* Temporarily avoid any problems with windows that are smaller
5681 than they are supposed to be. */
5682 window_min_height
= 1;
5683 window_min_width
= 1;
5686 Mark all windows now on frame as "deleted".
5687 Restoring the new configuration "undeletes" any that are in it.
5689 Save their current buffers in their height fields, since we may
5690 need it later, if a buffer saved in the configuration is now
5692 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5694 for (k
= 0; k
< saved_windows
->size
; k
++)
5696 p
= SAVED_WINDOW_N (saved_windows
, k
);
5697 w
= XWINDOW (p
->window
);
5700 if (!NILP (p
->parent
))
5701 w
->parent
= SAVED_WINDOW_N (saved_windows
,
5702 XFASTINT (p
->parent
))->window
;
5706 if (!NILP (p
->prev
))
5708 w
->prev
= SAVED_WINDOW_N (saved_windows
,
5709 XFASTINT (p
->prev
))->window
;
5710 XWINDOW (w
->prev
)->next
= p
->window
;
5715 if (!NILP (w
->parent
))
5717 if (EQ (p
->total_cols
, XWINDOW (w
->parent
)->total_cols
))
5719 XWINDOW (w
->parent
)->vchild
= p
->window
;
5720 XWINDOW (w
->parent
)->hchild
= Qnil
;
5724 XWINDOW (w
->parent
)->hchild
= p
->window
;
5725 XWINDOW (w
->parent
)->vchild
= Qnil
;
5730 /* If we squirreled away the buffer in the window's height,
5732 if (BUFFERP (w
->total_lines
))
5733 w
->buffer
= w
->total_lines
;
5734 w
->left_col
= p
->left_col
;
5735 w
->top_line
= p
->top_line
;
5736 w
->total_cols
= p
->total_cols
;
5737 w
->total_lines
= p
->total_lines
;
5738 w
->hscroll
= p
->hscroll
;
5739 w
->min_hscroll
= p
->min_hscroll
;
5740 w
->display_table
= p
->display_table
;
5741 w
->orig_top_line
= p
->orig_top_line
;
5742 w
->orig_total_lines
= p
->orig_total_lines
;
5743 w
->left_margin_cols
= p
->left_margin_cols
;
5744 w
->right_margin_cols
= p
->right_margin_cols
;
5745 w
->left_fringe_width
= p
->left_fringe_width
;
5746 w
->right_fringe_width
= p
->right_fringe_width
;
5747 w
->fringes_outside_margins
= p
->fringes_outside_margins
;
5748 w
->scroll_bar_width
= p
->scroll_bar_width
;
5749 w
->vertical_scroll_bar_type
= p
->vertical_scroll_bar_type
;
5750 XSETFASTINT (w
->last_modified
, 0);
5751 XSETFASTINT (w
->last_overlay_modified
, 0);
5753 /* Reinstall the saved buffer and pointers into it. */
5754 if (NILP (p
->buffer
))
5755 w
->buffer
= p
->buffer
;
5758 if (!NILP (XBUFFER (p
->buffer
)->name
))
5759 /* If saved buffer is alive, install it. */
5761 w
->buffer
= p
->buffer
;
5762 w
->start_at_line_beg
= p
->start_at_line_beg
;
5763 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
5764 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
5765 Fset_marker (XBUFFER (w
->buffer
)->mark
,
5766 p
->mark
, w
->buffer
);
5768 /* As documented in Fcurrent_window_configuration, don't
5769 restore the location of point in the buffer which was
5770 current when the window configuration was recorded. */
5771 if (!EQ (p
->buffer
, new_current_buffer
)
5772 && XBUFFER (p
->buffer
) == current_buffer
)
5773 Fgoto_char (w
->pointm
);
5775 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
5776 /* Else unless window has a live buffer, get one. */
5778 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
5779 /* This will set the markers to beginning of visible
5781 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
5782 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
5783 w
->start_at_line_beg
= Qt
;
5786 /* Keeping window's old buffer; make sure the markers
5789 /* Set window markers at start of visible range. */
5790 if (XMARKER (w
->start
)->buffer
== 0)
5791 set_marker_restricted (w
->start
, make_number (0),
5793 if (XMARKER (w
->pointm
)->buffer
== 0)
5794 set_marker_restricted_both (w
->pointm
, w
->buffer
,
5795 BUF_PT (XBUFFER (w
->buffer
)),
5796 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5797 w
->start_at_line_beg
= Qt
;
5802 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
5803 /* Prevent "swapping out point" in the old selected window
5804 using the buffer that has been restored into it.
5805 We already swapped out point that from that window's old buffer. */
5806 selected_window
= Qnil
;
5808 /* Arrange *not* to restore point in the buffer that was
5809 current when the window configuration was saved. */
5810 if (EQ (XWINDOW (data
->current_window
)->buffer
, new_current_buffer
))
5811 set_marker_restricted (XWINDOW (data
->current_window
)->pointm
,
5812 make_number (old_point
),
5813 XWINDOW (data
->current_window
)->buffer
);
5815 Fselect_window (data
->current_window
, Qnil
);
5816 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
5819 if (NILP (data
->focus_frame
)
5820 || (FRAMEP (data
->focus_frame
)
5821 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
5822 Fredirect_frame_focus (frame
, data
->focus_frame
);
5824 #if 0 /* I don't understand why this is needed, and it causes problems
5825 when the frame's old selected window has been deleted. */
5826 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
5827 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5831 /* Set the screen height to the value it had before this function. */
5832 if (previous_frame_lines
!= FRAME_LINES (f
)
5833 || previous_frame_cols
!= FRAME_COLS (f
))
5834 change_frame_size (f
, previous_frame_lines
, previous_frame_cols
,
5836 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5837 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5838 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5840 #ifdef HAVE_WINDOW_SYSTEM
5841 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5842 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5847 /* Now, free glyph matrices in windows that were not reused. */
5848 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5850 if (NILP (leaf_windows
[i
]->buffer
))
5852 /* Assert it's not reused as a combination. */
5853 xassert (NILP (leaf_windows
[i
]->hchild
)
5854 && NILP (leaf_windows
[i
]->vchild
));
5855 free_window_matrices (leaf_windows
[i
]);
5857 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5865 /* Fselect_window will have made f the selected frame, so we
5866 reselect the proper frame here. Fhandle_switch_frame will change the
5867 selected window too, but that doesn't make the call to
5868 Fselect_window above totally superfluous; it still sets f's
5870 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5871 do_switch_frame (data
->selected_frame
, 0, 0);
5873 if (! NILP (Vwindow_configuration_change_hook
)
5874 && ! NILP (Vrun_hooks
))
5875 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5878 if (!NILP (new_current_buffer
))
5879 Fset_buffer (new_current_buffer
);
5881 /* Restore the minimum heights recorded in the configuration. */
5882 window_min_height
= XINT (data
->min_height
);
5883 window_min_width
= XINT (data
->min_width
);
5885 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5886 minibuf_selected_window
= data
->minibuf_selected_window
;
5888 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5891 /* Mark all windows now on frame as deleted
5892 by setting their buffers to nil. */
5895 delete_all_subwindows (w
)
5896 register struct window
*w
;
5898 if (!NILP (w
->next
))
5899 delete_all_subwindows (XWINDOW (w
->next
));
5900 if (!NILP (w
->vchild
))
5901 delete_all_subwindows (XWINDOW (w
->vchild
));
5902 if (!NILP (w
->hchild
))
5903 delete_all_subwindows (XWINDOW (w
->hchild
));
5905 w
->total_lines
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5907 if (!NILP (w
->buffer
))
5910 /* We set all three of these fields to nil, to make sure that we can
5911 distinguish this dead window from any live window. Live leaf
5912 windows will have buffer set, and combination windows will have
5913 vchild or hchild set. */
5918 Vwindow_list
= Qnil
;
5922 count_windows (window
)
5923 register struct window
*window
;
5925 register int count
= 1;
5926 if (!NILP (window
->next
))
5927 count
+= count_windows (XWINDOW (window
->next
));
5928 if (!NILP (window
->vchild
))
5929 count
+= count_windows (XWINDOW (window
->vchild
));
5930 if (!NILP (window
->hchild
))
5931 count
+= count_windows (XWINDOW (window
->hchild
));
5936 /* Fill vector FLAT with leaf windows under W, starting at index I.
5937 Value is last index + 1. */
5940 get_leaf_windows (w
, flat
, i
)
5942 struct window
**flat
;
5947 if (!NILP (w
->hchild
))
5948 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5949 else if (!NILP (w
->vchild
))
5950 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5954 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5961 /* Return a pointer to the glyph W's physical cursor is on. Value is
5962 null if W's current matrix is invalid, so that no meaningfull glyph
5966 get_phys_cursor_glyph (w
)
5969 struct glyph_row
*row
;
5970 struct glyph
*glyph
;
5972 if (w
->phys_cursor
.vpos
>= 0
5973 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5974 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5976 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5977 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5986 save_window_save (window
, vector
, i
)
5988 struct Lisp_Vector
*vector
;
5991 register struct saved_window
*p
;
5992 register struct window
*w
;
5993 register Lisp_Object tem
;
5995 for (;!NILP (window
); window
= w
->next
)
5997 p
= SAVED_WINDOW_N (vector
, i
);
5998 w
= XWINDOW (window
);
6000 XSETFASTINT (w
->temslot
, i
); i
++;
6002 p
->buffer
= w
->buffer
;
6003 p
->left_col
= w
->left_col
;
6004 p
->top_line
= w
->top_line
;
6005 p
->total_cols
= w
->total_cols
;
6006 p
->total_lines
= w
->total_lines
;
6007 p
->hscroll
= w
->hscroll
;
6008 p
->min_hscroll
= w
->min_hscroll
;
6009 p
->display_table
= w
->display_table
;
6010 p
->orig_top_line
= w
->orig_top_line
;
6011 p
->orig_total_lines
= w
->orig_total_lines
;
6012 p
->left_margin_cols
= w
->left_margin_cols
;
6013 p
->right_margin_cols
= w
->right_margin_cols
;
6014 p
->left_fringe_width
= w
->left_fringe_width
;
6015 p
->right_fringe_width
= w
->right_fringe_width
;
6016 p
->fringes_outside_margins
= w
->fringes_outside_margins
;
6017 p
->scroll_bar_width
= w
->scroll_bar_width
;
6018 p
->vertical_scroll_bar_type
= w
->vertical_scroll_bar_type
;
6019 if (!NILP (w
->buffer
))
6021 /* Save w's value of point in the window configuration.
6022 If w is the selected window, then get the value of point
6023 from the buffer; pointm is garbage in the selected window. */
6024 if (EQ (window
, selected_window
))
6026 p
->pointm
= Fmake_marker ();
6027 set_marker_both (p
->pointm
, w
->buffer
,
6028 BUF_PT (XBUFFER (w
->buffer
)),
6029 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
6032 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
6034 p
->start
= Fcopy_marker (w
->start
, Qnil
);
6035 p
->start_at_line_beg
= w
->start_at_line_beg
;
6037 tem
= XBUFFER (w
->buffer
)->mark
;
6038 p
->mark
= Fcopy_marker (tem
, Qnil
);
6045 p
->start_at_line_beg
= Qnil
;
6048 if (NILP (w
->parent
))
6051 p
->parent
= XWINDOW (w
->parent
)->temslot
;
6056 p
->prev
= XWINDOW (w
->prev
)->temslot
;
6058 if (!NILP (w
->vchild
))
6059 i
= save_window_save (w
->vchild
, vector
, i
);
6060 if (!NILP (w
->hchild
))
6061 i
= save_window_save (w
->hchild
, vector
, i
);
6067 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
6068 Scurrent_window_configuration
, 0, 1, 0,
6069 doc
: /* Return an object representing the current window configuration of FRAME.
6070 If FRAME is nil or omitted, use the selected frame.
6071 This describes the number of windows, their sizes and current buffers,
6072 and for each displayed buffer, where display starts, and the positions of
6073 point and mark. An exception is made for point in the current buffer:
6074 its value is -not- saved.
6075 This also records the currently selected frame, and FRAME's focus
6076 redirection (see `redirect-frame-focus'). */)
6080 register Lisp_Object tem
;
6081 register int n_windows
;
6082 register struct save_window_data
*data
;
6083 register struct Lisp_Vector
*vec
;
6088 frame
= selected_frame
;
6089 CHECK_LIVE_FRAME (frame
);
6092 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
6093 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
6094 data
= (struct save_window_data
*)vec
;
6096 XSETFASTINT (data
->frame_cols
, FRAME_COLS (f
));
6097 XSETFASTINT (data
->frame_lines
, FRAME_LINES (f
));
6098 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
6099 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
6100 data
->selected_frame
= selected_frame
;
6101 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
6102 XSETBUFFER (data
->current_buffer
, current_buffer
);
6103 data
->minibuf_scroll_window
= minibuf_level
> 0 ? Vminibuf_scroll_window
: Qnil
;
6104 data
->minibuf_selected_window
= minibuf_level
> 0 ? minibuf_selected_window
: Qnil
;
6105 data
->root_window
= FRAME_ROOT_WINDOW (f
);
6106 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
6107 XSETINT (data
->min_height
, window_min_height
);
6108 XSETINT (data
->min_width
, window_min_width
);
6109 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
6110 data
->saved_windows
= tem
;
6111 for (i
= 0; i
< n_windows
; i
++)
6112 XVECTOR (tem
)->contents
[i
]
6113 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
6114 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
6115 XSETWINDOW_CONFIGURATION (tem
, data
);
6119 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
6121 doc
: /* Execute BODY, preserving window sizes and contents.
6122 Return the value of the last form in BODY.
6123 Restore which buffer appears in which window, where display starts,
6124 and the value of point and mark for each window.
6125 Also restore the choice of selected window.
6126 Also restore which buffer is current.
6127 Does not restore the value of point in current buffer.
6128 usage: (save-window-excursion BODY ...) */)
6132 register Lisp_Object val
;
6133 register int count
= SPECPDL_INDEX ();
6135 record_unwind_protect (Fset_window_configuration
,
6136 Fcurrent_window_configuration (Qnil
));
6137 val
= Fprogn (args
);
6138 return unbind_to (count
, val
);
6142 /***********************************************************************
6144 ***********************************************************************/
6146 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
6148 doc
: /* Set width of marginal areas of window WINDOW.
6149 If WINDOW is nil, set margins of the currently selected window.
6150 Second arg LEFT-WIDTH specifies the number of character cells to
6151 reserve for the left marginal area. Optional third arg RIGHT-WIDTH
6152 does the same for the right marginal area. A nil width parameter
6153 means no margin. */)
6154 (window
, left
, right
)
6155 Lisp_Object window
, left
, right
;
6157 struct window
*w
= decode_window (window
);
6159 /* Translate negative or zero widths to nil.
6160 Margins that are too wide have to be checked elsewhere. */
6164 CHECK_NUMBER (left
);
6165 if (XINT (left
) <= 0)
6171 CHECK_NUMBER (right
);
6172 if (XINT (right
) <= 0)
6176 if (!EQ (w
->left_margin_cols
, left
)
6177 || !EQ (w
->right_margin_cols
, right
))
6179 w
->left_margin_cols
= left
;
6180 w
->right_margin_cols
= right
;
6182 adjust_window_margins (w
);
6184 ++windows_or_buffers_changed
;
6185 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6192 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
6194 doc
: /* Get width of marginal areas of window WINDOW.
6195 If WINDOW is omitted or nil, use the currently selected window.
6196 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
6197 If a marginal area does not exist, its width will be returned
6202 struct window
*w
= decode_window (window
);
6203 return Fcons (w
->left_margin_cols
, w
->right_margin_cols
);
6208 /***********************************************************************
6210 ***********************************************************************/
6212 DEFUN ("set-window-fringes", Fset_window_fringes
, Sset_window_fringes
,
6214 doc
: /* Set the fringe widths of window WINDOW.
6215 If WINDOW is nil, set the fringe widths of the currently selected
6217 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
6218 the left fringe. Optional third arg RIGHT-WIDTH specifies the right
6219 fringe width. If a fringe width arg is nil, that means to use the
6220 frame's default fringe width. Default fringe widths can be set with
6221 the command `set-fringe-style'.
6222 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
6223 outside of the display margins. By default, fringes are drawn between
6224 display marginal areas and the text area. */)
6225 (window
, left
, right
, outside_margins
)
6226 Lisp_Object window
, left
, right
, outside_margins
;
6228 struct window
*w
= decode_window (window
);
6231 CHECK_NATNUM (left
);
6233 CHECK_NATNUM (right
);
6235 if (!EQ (w
->left_fringe_width
, left
)
6236 || !EQ (w
->right_fringe_width
, right
)
6237 || !EQ (w
->fringes_outside_margins
, outside_margins
))
6239 w
->left_fringe_width
= left
;
6240 w
->right_fringe_width
= right
;
6241 w
->fringes_outside_margins
= outside_margins
;
6243 adjust_window_margins (w
);
6245 clear_glyph_matrix (w
->current_matrix
);
6246 w
->window_end_valid
= Qnil
;
6248 ++windows_or_buffers_changed
;
6249 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6256 DEFUN ("window-fringes", Fwindow_fringes
, Swindow_fringes
,
6258 doc
: /* Get width of fringes of window WINDOW.
6259 If WINDOW is omitted or nil, use the currently selected window.
6260 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS). */)
6264 struct window
*w
= decode_window (window
);
6265 return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w
)),
6266 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w
)),
6267 Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
) ?
6268 Qt
: Qnil
), Qnil
)));
6273 /***********************************************************************
6275 ***********************************************************************/
6277 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars
, Sset_window_scroll_bars
,
6279 doc
: /* Set width and type of scroll bars of window WINDOW.
6280 If window is nil, set scroll bars of the currently selected window.
6281 Second parameter WIDTH specifies the pixel width for the scroll bar;
6282 this is automatically adjusted to a multiple of the frame column width.
6283 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
6284 bar: left, right, or nil.
6285 If WIDTH is nil, use the frame's scroll-bar width.
6286 If TYPE is t, use the frame's scroll-bar type. */)
6287 (window
, width
, vertical_type
, horizontal_type
)
6288 Lisp_Object window
, width
, vertical_type
, horizontal_type
;
6290 struct window
*w
= decode_window (window
);
6294 CHECK_NATNUM (width
);
6296 if (XINT (width
) == 0)
6297 vertical_type
= Qnil
;
6300 if (!(EQ (vertical_type
, Qnil
)
6301 || EQ (vertical_type
, Qleft
)
6302 || EQ (vertical_type
, Qright
)
6303 || EQ (vertical_type
, Qt
)))
6304 error ("Invalid type of vertical scroll bar");
6306 if (!EQ (w
->scroll_bar_width
, width
)
6307 || !EQ (w
->vertical_scroll_bar_type
, vertical_type
))
6309 w
->scroll_bar_width
= width
;
6310 w
->vertical_scroll_bar_type
= vertical_type
;
6312 adjust_window_margins (w
);
6314 clear_glyph_matrix (w
->current_matrix
);
6315 w
->window_end_valid
= Qnil
;
6317 ++windows_or_buffers_changed
;
6318 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
6325 DEFUN ("window-scroll-bars", Fwindow_scroll_bars
, Swindow_scroll_bars
,
6327 doc
: /* Get width and type of scroll bars of window WINDOW.
6328 If WINDOW is omitted or nil, use the currently selected window.
6329 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
6330 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
6335 struct window
*w
= decode_window (window
);
6336 return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6337 ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
)
6338 : WINDOW_SCROLL_BAR_AREA_WIDTH (w
))),
6339 Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w
)),
6340 Fcons (w
->vertical_scroll_bar_type
,
6341 Fcons (Qnil
, Qnil
))));
6346 /***********************************************************************
6348 ***********************************************************************/
6350 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 2, 0,
6351 doc
: /* Return the amount by which WINDOW is scrolled vertically.
6352 Use the selected window if WINDOW is nil or omitted.
6353 Normally, value is a multiple of the canonical character height of WINDOW;
6354 optional second arg PIXELS_P means value is measured in pixels. */)
6356 Lisp_Object window
, pixels_p
;
6363 window
= selected_window
;
6365 CHECK_WINDOW (window
);
6366 w
= XWINDOW (window
);
6367 f
= XFRAME (w
->frame
);
6369 if (FRAME_WINDOW_P (f
))
6370 result
= (NILP (pixels_p
)
6371 ? FRAME_CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
)
6372 : make_number (-w
->vscroll
));
6374 result
= make_number (0);
6379 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
6381 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
6382 WINDOW nil means use the selected window. Normally, VSCROLL is a
6383 non-negative multiple of the canonical character height of WINDOW;
6384 optional third arg PIXELS_P non-nil means that VSCROLL is in pixels.
6385 If PIXELS-P is nil, VSCROLL may have to be rounded so that it
6386 corresponds to an integral number of pixels. The return value is the
6387 result of this rounding.
6388 If PIXELS-P is non-nil, the return value is VSCROLL. */)
6389 (window
, vscroll
, pixels_p
)
6390 Lisp_Object window
, vscroll
, pixels_p
;
6396 window
= selected_window
;
6398 CHECK_WINDOW (window
);
6399 CHECK_NUMBER_OR_FLOAT (vscroll
);
6401 w
= XWINDOW (window
);
6402 f
= XFRAME (w
->frame
);
6404 if (FRAME_WINDOW_P (f
))
6406 int old_dy
= w
->vscroll
;
6408 w
->vscroll
= - (NILP (pixels_p
)
6409 ? FRAME_LINE_HEIGHT (f
) * XFLOATINT (vscroll
)
6410 : XFLOATINT (vscroll
));
6411 w
->vscroll
= min (w
->vscroll
, 0);
6413 if (w
->vscroll
!= old_dy
)
6415 /* Adjust glyph matrix of the frame if the virtual display
6416 area becomes larger than before. */
6417 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
6420 /* Prevent redisplay shortcuts. */
6421 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
6425 return Fwindow_vscroll (window
, pixels_p
);
6429 /* Call FN for all leaf windows on frame F. FN is called with the
6430 first argument being a pointer to the leaf window, and with
6431 additional argument USER_DATA. Stops when FN returns 0. */
6434 foreach_window (f
, fn
, user_data
)
6436 int (* fn
) P_ ((struct window
*, void *));
6439 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
6443 /* Helper function for foreach_window. Call FN for all leaf windows
6444 reachable from W. FN is called with the first argument being a
6445 pointer to the leaf window, and with additional argument USER_DATA.
6446 Stop when FN returns 0. Value is 0 if stopped by FN. */
6449 foreach_window_1 (w
, fn
, user_data
)
6451 int (* fn
) P_ ((struct window
*, void *));
6456 for (cont
= 1; w
&& cont
;)
6458 if (!NILP (w
->hchild
))
6459 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
6460 else if (!NILP (w
->vchild
))
6461 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
6463 cont
= fn (w
, user_data
);
6465 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
6472 /* Freeze or unfreeze the window start of W unless it is a
6473 mini-window or the selected window. FREEZE_P non-null means freeze
6474 the window start. */
6477 freeze_window_start (w
, freeze_p
)
6481 if (w
== XWINDOW (selected_window
)
6482 || MINI_WINDOW_P (w
)
6483 || (MINI_WINDOW_P (XWINDOW (selected_window
))
6484 && ! NILP (Vminibuf_scroll_window
)
6485 && w
== XWINDOW (Vminibuf_scroll_window
)))
6488 w
->frozen_window_start_p
= freeze_p
!= NULL
;
6493 /* Freeze or unfreeze the window starts of all leaf windows on frame
6494 F, except the selected window and a mini-window. FREEZE_P non-zero
6495 means freeze the window start. */
6498 freeze_window_starts (f
, freeze_p
)
6502 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
6506 /***********************************************************************
6508 ***********************************************************************/
6510 /* Return 1 if window configurations C1 and C2
6511 describe the same state of affairs. This is used by Fequal. */
6514 compare_window_configurations (c1
, c2
, ignore_positions
)
6516 int ignore_positions
;
6518 register struct save_window_data
*d1
, *d2
;
6519 struct Lisp_Vector
*sw1
, *sw2
;
6522 if (!WINDOW_CONFIGURATIONP (c1
))
6523 wrong_type_argument (Qwindow_configuration_p
, c1
);
6524 if (!WINDOW_CONFIGURATIONP (c2
))
6525 wrong_type_argument (Qwindow_configuration_p
, c2
);
6527 d1
= (struct save_window_data
*) XVECTOR (c1
);
6528 d2
= (struct save_window_data
*) XVECTOR (c2
);
6529 sw1
= XVECTOR (d1
->saved_windows
);
6530 sw2
= XVECTOR (d2
->saved_windows
);
6532 if (! EQ (d1
->frame_cols
, d2
->frame_cols
))
6534 if (! EQ (d1
->frame_lines
, d2
->frame_lines
))
6536 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
6538 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
6540 /* Don't compare the current_window field directly.
6541 Instead see w1_is_current and w2_is_current, below. */
6542 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
6544 if (! ignore_positions
)
6546 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
6548 if (! EQ (d1
->minibuf_selected_window
, d2
->minibuf_selected_window
))
6551 /* Don't compare the root_window field.
6552 We don't require the two configurations
6553 to use the same window object,
6554 and the two root windows must be equivalent
6555 if everything else compares equal. */
6556 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
6558 if (! EQ (d1
->min_width
, d2
->min_width
))
6560 if (! EQ (d1
->min_height
, d2
->min_height
))
6563 /* Verify that the two confis have the same number of windows. */
6564 if (sw1
->size
!= sw2
->size
)
6567 for (i
= 0; i
< sw1
->size
; i
++)
6569 struct saved_window
*p1
, *p2
;
6570 int w1_is_current
, w2_is_current
;
6572 p1
= SAVED_WINDOW_N (sw1
, i
);
6573 p2
= SAVED_WINDOW_N (sw2
, i
);
6575 /* Verify that the current windows in the two
6576 configurations correspond to each other. */
6577 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
6578 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
6580 if (w1_is_current
!= w2_is_current
)
6583 /* Verify that the corresponding windows do match. */
6584 if (! EQ (p1
->buffer
, p2
->buffer
))
6586 if (! EQ (p1
->left_col
, p2
->left_col
))
6588 if (! EQ (p1
->top_line
, p2
->top_line
))
6590 if (! EQ (p1
->total_cols
, p2
->total_cols
))
6592 if (! EQ (p1
->total_lines
, p2
->total_lines
))
6594 if (! EQ (p1
->display_table
, p2
->display_table
))
6596 if (! EQ (p1
->parent
, p2
->parent
))
6598 if (! EQ (p1
->prev
, p2
->prev
))
6600 if (! ignore_positions
)
6602 if (! EQ (p1
->hscroll
, p2
->hscroll
))
6604 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
6606 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
6608 if (NILP (Fequal (p1
->start
, p2
->start
)))
6610 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
6612 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
6615 if (! EQ (p1
->left_margin_cols
, p2
->left_margin_cols
))
6617 if (! EQ (p1
->right_margin_cols
, p2
->right_margin_cols
))
6619 if (! EQ (p1
->left_fringe_width
, p2
->left_fringe_width
))
6621 if (! EQ (p1
->right_fringe_width
, p2
->right_fringe_width
))
6623 if (! EQ (p1
->fringes_outside_margins
, p2
->fringes_outside_margins
))
6625 if (! EQ (p1
->scroll_bar_width
, p2
->scroll_bar_width
))
6627 if (! EQ (p1
->vertical_scroll_bar_type
, p2
->vertical_scroll_bar_type
))
6634 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
6635 Scompare_window_configurations
, 2, 2, 0,
6636 doc
: /* Compare two window configurations as regards the structure of windows.
6637 This function ignores details such as the values of point and mark
6638 and scrolling positions. */)
6642 if (compare_window_configurations (x
, y
, 1))
6650 struct frame
*f
= make_terminal_frame ();
6651 XSETFRAME (selected_frame
, f
);
6652 Vterminal_frame
= selected_frame
;
6653 minibuf_window
= f
->minibuffer_window
;
6654 selected_window
= f
->selected_window
;
6655 last_nonminibuf_frame
= f
;
6657 window_initialized
= 1;
6663 Vwindow_list
= Qnil
;
6669 Qwindow_size_fixed
= intern ("window-size-fixed");
6670 staticpro (&Qwindow_size_fixed
);
6671 Fset (Qwindow_size_fixed
, Qnil
);
6673 staticpro (&Qwindow_configuration_change_hook
);
6674 Qwindow_configuration_change_hook
6675 = intern ("window-configuration-change-hook");
6677 Qwindowp
= intern ("windowp");
6678 staticpro (&Qwindowp
);
6680 Qwindow_configuration_p
= intern ("window-configuration-p");
6681 staticpro (&Qwindow_configuration_p
);
6683 Qwindow_live_p
= intern ("window-live-p");
6684 staticpro (&Qwindow_live_p
);
6686 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
6687 staticpro (&Qtemp_buffer_show_hook
);
6689 staticpro (&Vwindow_list
);
6691 minibuf_selected_window
= Qnil
;
6692 staticpro (&minibuf_selected_window
);
6694 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
6695 doc
: /* Non-nil means call as function to display a help buffer.
6696 The function is called with one argument, the buffer to be displayed.
6697 Used by `with-output-to-temp-buffer'.
6698 If this function is used, then it must do the entire job of showing
6699 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
6700 Vtemp_buffer_show_function
= Qnil
;
6702 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
6703 doc
: /* If non-nil, function to call to handle `display-buffer'.
6704 It will receive two args, the buffer and a flag which if non-nil means
6705 that the currently selected window is not acceptable.
6706 It should choose or create a window, display the specified buffer in it,
6707 and return the window.
6708 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
6709 work using this function. */);
6710 Vdisplay_buffer_function
= Qnil
;
6712 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
6713 doc
: /* *If non-nil, `display-buffer' should even the window heights.
6714 If nil, `display-buffer' will leave the window configuration alone. */);
6715 Veven_window_heights
= Qt
;
6717 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
6718 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
6719 Vminibuf_scroll_window
= Qnil
;
6721 DEFVAR_BOOL ("mode-line-in-non-selected-windows", &mode_line_in_non_selected_windows
,
6722 doc
: /* Non-nil means to use `mode-line-inactive' face in non-selected windows.
6723 If the minibuffer is active, the `minibuffer-scroll-window' mode line
6724 is displayed in the `mode-line' face. */);
6725 mode_line_in_non_selected_windows
= 1;
6727 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
6728 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
6729 Vother_window_scroll_buffer
= Qnil
;
6731 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
6732 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
6735 DEFVAR_BOOL ("auto-window-vscroll", &auto_window_vscroll_p
,
6736 doc
: /* *Non-nil means to automatically adjust `window-vscroll' to view tall lines. */);
6737 auto_window_vscroll_p
= 1;
6739 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
6740 doc
: /* *Non-nil means `display-buffer' should reuse frames.
6741 If the buffer in question is already displayed in a frame, raise that frame. */);
6742 display_buffer_reuse_frames
= 0;
6744 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
6745 doc
: /* Function to call to handle automatic new frame creation.
6746 It is called with no arguments and should return a newly created frame.
6748 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
6749 where `pop-up-frame-alist' would hold the default frame parameters. */);
6750 Vpop_up_frame_function
= Qnil
;
6752 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
6753 doc
: /* *List of buffer names that should have their own special frames.
6754 Displaying a buffer with `display-buffer' or `pop-to-buffer',
6755 if its name is in this list, makes a special frame for it
6756 using `special-display-function'. See also `special-display-regexps'.
6758 An element of the list can be a list instead of just a string.
6759 There are two ways to use a list as an element:
6760 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
6761 In the first case, the FRAME-PARAMETERS are pairs of the form
6762 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6763 In the second case, FUNCTION is called with BUFFER as the first argument,
6764 followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
6765 All this is done by the function found in `special-display-function'.
6767 If the specified frame parameters include (same-buffer . t), the
6768 buffer is displayed in the currently selected window. Otherwise, if
6769 they include (same-frame . t), the buffer is displayed in a new window
6770 in the currently selected frame.
6772 If this variable appears \"not to work\", because you add a name to it
6773 but that buffer still appears in the selected window, look at the
6774 values of `same-window-buffer-names' and `same-window-regexps'.
6775 Those variables take precedence over this one. */);
6776 Vspecial_display_buffer_names
= Qnil
;
6778 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
6779 doc
: /* *List of regexps saying which buffers should have their own special frames.
6780 When displaying a buffer with `display-buffer' or `pop-to-buffer',
6781 if any regexp in this list matches the buffer name, it makes a
6782 special frame for the buffer by calling `special-display-function'.
6784 An element of the list can be a list instead of just a string.
6785 There are two ways to use a list as an element:
6786 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
6787 In the first case, the FRAME-PARAMETERS are pairs of the form
6788 \(PARAMETER . VALUE); these parameter values are used to create the frame.
6789 In the second case, FUNCTION is called with BUFFER as the first argument,
6790 followed by the OTHER-ARGS--it can display the buffer in any way it likes.
6791 All this is done by the function found in `special-display-function'.
6793 If the specified frame parameters include (same-buffer . t), the
6794 buffer is displayed in the currently selected window. Otherwise, if
6795 they include (same-frame . t), the buffer is displayed in a new window
6796 in the currently selected frame.
6798 If this variable appears \"not to work\", because you add a regexp to it
6799 but the matching buffers still appear in the selected window, look at the
6800 values of `same-window-buffer-names' and `same-window-regexps'.
6801 Those variables take precedence over this one. */);
6802 Vspecial_display_regexps
= Qnil
;
6804 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
6805 doc
: /* Function to call to make a new frame for a special buffer.
6806 It is called with two arguments, the buffer and optional buffer specific
6807 data, and should return a window displaying that buffer.
6808 The default value normally makes a separate frame for the buffer,
6809 using `special-display-frame-alist' to specify the frame parameters.
6810 But if the buffer specific data includes (same-buffer . t) then the
6811 buffer is displayed in the current selected window.
6812 Otherwise if it includes (same-frame . t) then the buffer is displayed in
6813 a new window in the currently selected frame.
6815 A buffer is special if it is listed in `special-display-buffer-names'
6816 or matches a regexp in `special-display-regexps'. */);
6817 Vspecial_display_function
= Qnil
;
6819 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
6820 doc
: /* *List of buffer names that should appear in the selected window.
6821 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
6822 switches to it in the selected window, rather than making it appear
6823 in some other window.
6825 An element of the list can be a cons cell instead of just a string.
6826 Then the car must be a string, which specifies the buffer name.
6827 This is for compatibility with `special-display-buffer-names';
6828 the cdr of the cons cell is ignored.
6830 See also `same-window-regexps'. */);
6831 Vsame_window_buffer_names
= Qnil
;
6833 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
6834 doc
: /* *List of regexps saying which buffers should appear in the selected window.
6835 If a buffer name matches one of these regexps, then displaying it
6836 using `display-buffer' or `pop-to-buffer' switches to it
6837 in the selected window, rather than making it appear in some other window.
6839 An element of the list can be a cons cell instead of just a string.
6840 Then the car must be a string, which specifies the buffer name.
6841 This is for compatibility with `special-display-buffer-names';
6842 the cdr of the cons cell is ignored.
6844 See also `same-window-buffer-names'. */);
6845 Vsame_window_regexps
= Qnil
;
6847 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
6848 doc
: /* *Non-nil means display-buffer should make new windows. */);
6851 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
6852 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
6853 next_screen_context_lines
= 2;
6855 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
6856 doc
: /* *A window must be at least this tall to be eligible for splitting by `display-buffer'.
6857 If there is only one window, it is split regardless of this value. */);
6858 split_height_threshold
= 500;
6860 DEFVAR_INT ("window-min-height", &window_min_height
,
6861 doc
: /* *Delete any window less than this tall (including its mode line). */);
6862 window_min_height
= 4;
6864 DEFVAR_INT ("window-min-width", &window_min_width
,
6865 doc
: /* *Delete any window less than this wide. */);
6866 window_min_width
= 10;
6868 DEFVAR_LISP ("scroll-preserve-screen-position",
6869 &Vscroll_preserve_screen_position
,
6870 doc
: /* *Non-nil means scroll commands move point to keep its screen line unchanged.
6871 This is only when it is impossible to keep point fixed and still
6872 scroll as specified. */);
6873 Vscroll_preserve_screen_position
= Qnil
;
6875 DEFVAR_LISP ("window-configuration-change-hook",
6876 &Vwindow_configuration_change_hook
,
6877 doc
: /* Functions to call when window configuration changes.
6878 The selected frame is the one whose configuration has changed. */);
6879 Vwindow_configuration_change_hook
= Qnil
;
6881 defsubr (&Sselected_window
);
6882 defsubr (&Sminibuffer_window
);
6883 defsubr (&Swindow_minibuffer_p
);
6884 defsubr (&Swindowp
);
6885 defsubr (&Swindow_live_p
);
6886 defsubr (&Spos_visible_in_window_p
);
6887 defsubr (&Swindow_buffer
);
6888 defsubr (&Swindow_height
);
6889 defsubr (&Swindow_width
);
6890 defsubr (&Swindow_hscroll
);
6891 defsubr (&Sset_window_hscroll
);
6892 defsubr (&Swindow_redisplay_end_trigger
);
6893 defsubr (&Sset_window_redisplay_end_trigger
);
6894 defsubr (&Swindow_edges
);
6895 defsubr (&Swindow_pixel_edges
);
6896 defsubr (&Swindow_inside_edges
);
6897 defsubr (&Swindow_inside_pixel_edges
);
6898 defsubr (&Scoordinates_in_window_p
);
6899 defsubr (&Swindow_at
);
6900 defsubr (&Swindow_point
);
6901 defsubr (&Swindow_start
);
6902 defsubr (&Swindow_end
);
6903 defsubr (&Sset_window_point
);
6904 defsubr (&Sset_window_start
);
6905 defsubr (&Swindow_dedicated_p
);
6906 defsubr (&Sset_window_dedicated_p
);
6907 defsubr (&Swindow_display_table
);
6908 defsubr (&Sset_window_display_table
);
6909 defsubr (&Snext_window
);
6910 defsubr (&Sprevious_window
);
6911 defsubr (&Sother_window
);
6912 defsubr (&Sget_lru_window
);
6913 defsubr (&Sget_largest_window
);
6914 defsubr (&Sget_buffer_window
);
6915 defsubr (&Sdelete_other_windows
);
6916 defsubr (&Sdelete_windows_on
);
6917 defsubr (&Sreplace_buffer_in_windows
);
6918 defsubr (&Sdelete_window
);
6919 defsubr (&Sset_window_buffer
);
6920 defsubr (&Sselect_window
);
6921 defsubr (&Sspecial_display_p
);
6922 defsubr (&Ssame_window_p
);
6923 defsubr (&Sdisplay_buffer
);
6924 defsubr (&Sforce_window_update
);
6925 defsubr (&Ssplit_window
);
6926 defsubr (&Senlarge_window
);
6927 defsubr (&Sshrink_window
);
6928 defsubr (&Sscroll_up
);
6929 defsubr (&Sscroll_down
);
6930 defsubr (&Sscroll_left
);
6931 defsubr (&Sscroll_right
);
6932 defsubr (&Sother_window_for_scrolling
);
6933 defsubr (&Sscroll_other_window
);
6934 defsubr (&Sminibuffer_selected_window
);
6935 defsubr (&Srecenter
);
6936 defsubr (&Swindow_text_height
);
6937 defsubr (&Smove_to_window_line
);
6938 defsubr (&Swindow_configuration_p
);
6939 defsubr (&Swindow_configuration_frame
);
6940 defsubr (&Sset_window_configuration
);
6941 defsubr (&Scurrent_window_configuration
);
6942 defsubr (&Ssave_window_excursion
);
6943 defsubr (&Sset_window_margins
);
6944 defsubr (&Swindow_margins
);
6945 defsubr (&Sset_window_fringes
);
6946 defsubr (&Swindow_fringes
);
6947 defsubr (&Sset_window_scroll_bars
);
6948 defsubr (&Swindow_scroll_bars
);
6949 defsubr (&Swindow_vscroll
);
6950 defsubr (&Sset_window_vscroll
);
6951 defsubr (&Scompare_window_configurations
);
6952 defsubr (&Swindow_list
);
6958 initial_define_key (control_x_map
, '1', "delete-other-windows");
6959 initial_define_key (control_x_map
, '2', "split-window");
6960 initial_define_key (control_x_map
, '0', "delete-window");
6961 initial_define_key (control_x_map
, 'o', "other-window");
6962 initial_define_key (control_x_map
, '^', "enlarge-window");
6963 initial_define_key (control_x_map
, '<', "scroll-left");
6964 initial_define_key (control_x_map
, '>', "scroll-right");
6966 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
6967 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
6968 initial_define_key (meta_map
, 'v', "scroll-down");
6970 initial_define_key (global_map
, Ctl('L'), "recenter");
6971 initial_define_key (meta_map
, 'r', "move-to-window-line");
6974 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
6975 (do not change this comment) */