1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985,86,87,93,94,95,96,97,1998,2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
34 #include "dispextern.h"
35 #include "blockinput.h"
36 #include "intervals.h"
40 #endif /* HAVE_X_WINDOWS */
52 #define max(a, b) ((a) < (b) ? (b) : (a))
55 /* Values returned from coordinates_in_window. */
69 Lisp_Object Qwindowp
, Qwindow_live_p
, Qwindow_configuration_p
;
70 Lisp_Object Qwindow_size_fixed
, Qleft_fringe
, Qright_fringe
;
71 extern Lisp_Object Qheight
, Qwidth
;
73 static int displayed_window_lines
P_ ((struct window
*));
74 static struct window
*decode_window
P_ ((Lisp_Object
));
75 static Lisp_Object select_window_1
P_ ((Lisp_Object
, int));
76 static int count_windows
P_ ((struct window
*));
77 static int get_leaf_windows
P_ ((struct window
*, struct window
**, int));
78 static void window_scroll
P_ ((Lisp_Object
, int, int, int));
79 static void window_scroll_pixel_based
P_ ((Lisp_Object
, int, int, int));
80 static void window_scroll_line_based
P_ ((Lisp_Object
, int, int, int));
81 static int window_min_size_1
P_ ((struct window
*, int));
82 static int window_min_size
P_ ((struct window
*, int, int, int *));
83 static void size_window
P_ ((Lisp_Object
, int, int, int));
84 static int freeze_window_start
P_ ((struct window
*, void *));
85 static int window_fixed_size_p
P_ ((struct window
*, int, int));
86 static void enlarge_window
P_ ((Lisp_Object
, int, int));
87 static Lisp_Object window_list
P_ ((void));
88 static int add_window_to_list
P_ ((struct window
*, void *));
89 static int candidate_window_p
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
91 static Lisp_Object next_window
P_ ((Lisp_Object
, Lisp_Object
,
93 static void decode_next_window_args
P_ ((Lisp_Object
*, Lisp_Object
*,
95 static int foreach_window_1
P_ ((struct window
*,
96 int (* fn
) (struct window
*, void *),
98 static Lisp_Object window_list_1
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
100 /* The value of `window-size-fixed'. */
102 int window_size_fixed
;
104 /* This is the window in which the terminal's cursor should
105 be left when nothing is being done with it. This must
106 always be a leaf window, and its buffer is selected by
107 the top level editing loop at the end of each command.
109 This value is always the same as
110 FRAME_SELECTED_WINDOW (selected_frame). */
112 Lisp_Object selected_window
;
114 /* A list of all windows for use by next_window and Fwindow_list.
115 Functions creating or deleting windows should invalidate this cache
116 by setting it to nil. */
118 Lisp_Object Vwindow_list
;
120 /* The mini-buffer window of the selected frame.
121 Note that you cannot test for mini-bufferness of an arbitrary window
122 by comparing against this; but you can test for mini-bufferness of
123 the selected window. */
125 Lisp_Object minibuf_window
;
127 /* Non-nil means it is the window for C-M-v to scroll
128 when the mini-buffer is selected. */
130 Lisp_Object Vminibuf_scroll_window
;
132 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
134 Lisp_Object Vother_window_scroll_buffer
;
136 /* Non-nil means it's function to call to display temp buffers. */
138 Lisp_Object Vtemp_buffer_show_function
;
140 /* If a window gets smaller than either of these, it is removed. */
142 int window_min_height
;
143 int window_min_width
;
145 /* Nonzero implies Fdisplay_buffer should create windows. */
149 /* Nonzero implies make new frames for Fdisplay_buffer. */
153 /* Nonzero means reuse existing frames for displaying buffers. */
155 int display_buffer_reuse_frames
;
157 /* Non-nil means use this function instead of default */
159 Lisp_Object Vpop_up_frame_function
;
161 /* Function to call to handle Fdisplay_buffer. */
163 Lisp_Object Vdisplay_buffer_function
;
165 /* Non-nil means that Fdisplay_buffer should even the heights of windows. */
167 Lisp_Object Veven_window_heights
;
169 /* List of buffer *names* for buffers that should have their own frames. */
171 Lisp_Object Vspecial_display_buffer_names
;
173 /* List of regexps for buffer names that should have their own frames. */
175 Lisp_Object Vspecial_display_regexps
;
177 /* Function to pop up a special frame. */
179 Lisp_Object Vspecial_display_function
;
181 /* List of buffer *names* for buffers to appear in selected window. */
183 Lisp_Object Vsame_window_buffer_names
;
185 /* List of regexps for buffer names to appear in selected window. */
187 Lisp_Object Vsame_window_regexps
;
189 /* Hook run at end of temp_output_buffer_show. */
191 Lisp_Object Qtemp_buffer_show_hook
;
193 /* Fdisplay_buffer always splits the largest window
194 if that window is more than this high. */
196 int split_height_threshold
;
198 /* Number of lines of continuity in scrolling by screenfuls. */
200 int next_screen_context_lines
;
202 /* Incremented for each window created. */
204 static int sequence_number
;
206 /* Nonzero after init_window_once has finished. */
208 static int window_initialized
;
210 /* Hook to run when window config changes. */
212 Lisp_Object Qwindow_configuration_change_hook
;
213 Lisp_Object Vwindow_configuration_change_hook
;
215 /* Nonzero means scroll commands try to put point
216 at the same screen height as previously. */
218 Lisp_Object Vscroll_preserve_screen_position
;
220 #if 0 /* This isn't used anywhere. */
221 /* Nonzero means we can split a frame even if it is "unsplittable". */
222 static int inhibit_frame_unsplittable
;
225 extern int scroll_margin
;
227 extern Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
229 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
230 doc
: /* Returns t if OBJECT is a window. */)
234 return WINDOWP (object
) ? Qt
: Qnil
;
237 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
238 doc
: /* Returns t if OBJECT is a window which is currently visible. */)
242 return WINDOW_LIVE_P (object
) ? Qt
: Qnil
;
249 register struct window
*p
;
251 p
= allocate_window ();
252 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
253 XSETFASTINT (p
->left
, 0);
254 XSETFASTINT (p
->top
, 0);
255 XSETFASTINT (p
->height
, 0);
256 XSETFASTINT (p
->width
, 0);
257 XSETFASTINT (p
->hscroll
, 0);
258 XSETFASTINT (p
->min_hscroll
, 0);
259 p
->orig_top
= p
->orig_height
= Qnil
;
260 p
->start
= Fmake_marker ();
261 p
->pointm
= Fmake_marker ();
262 XSETFASTINT (p
->use_time
, 0);
264 p
->display_table
= Qnil
;
266 p
->pseudo_window_p
= 0;
267 bzero (&p
->cursor
, sizeof (p
->cursor
));
268 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
269 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
270 p
->desired_matrix
= p
->current_matrix
= 0;
271 p
->phys_cursor_type
= -1;
272 p
->must_be_updated_p
= 0;
273 XSETFASTINT (p
->window_end_vpos
, 0);
274 XSETFASTINT (p
->window_end_pos
, 0);
275 p
->window_end_valid
= Qnil
;
278 XSETFASTINT (p
->last_point
, 0);
279 p
->frozen_window_start_p
= 0;
285 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
286 doc
: /* Return the window that the cursor now appears in and commands apply to. */)
289 return selected_window
;
292 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
293 doc
: /* Return the window used now for minibuffers.
294 If the optional argument FRAME is specified, return the minibuffer window
295 used by that frame. */)
300 frame
= selected_frame
;
301 CHECK_LIVE_FRAME (frame
, 0);
302 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
305 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
306 doc
: /* Returns non-nil if WINDOW is a minibuffer window. */)
310 struct window
*w
= decode_window (window
);
311 return MINI_WINDOW_P (w
) ? Qt
: Qnil
;
315 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
316 Spos_visible_in_window_p
, 0, 3, 0,
317 doc
: /* Return t if position POS is currently on the frame in WINDOW.
318 Return nil if that position is scrolled vertically out of view.
319 If a character is only partially visible, nil is returned, unless the
320 optional argument PARTIALLY is non-nil.
321 POS defaults to point in WINDOW; WINDOW defaults to the selected window. */)
322 (pos
, window
, partially
)
323 Lisp_Object pos
, window
, partially
;
325 register struct window
*w
;
327 register struct buffer
*buf
;
329 Lisp_Object in_window
;
332 w
= decode_window (window
);
333 buf
= XBUFFER (w
->buffer
);
334 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
338 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
341 else if (w
== XWINDOW (selected_window
))
344 posint
= XMARKER (w
->pointm
)->charpos
;
346 /* If position is above window start, it's not visible. */
347 if (posint
< CHARPOS (top
))
349 else if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
)
350 && XFASTINT (w
->last_overlay_modified
) >= BUF_OVERLAY_MODIFF (buf
)
351 && posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
))
353 /* If frame is up-to-date, and POSINT is < window end pos, use
354 that info. This doesn't work for POSINT == end pos, because
355 the window end pos is actually the position _after_ the last
356 char in the window. */
357 if (NILP (partially
))
359 pos_visible_p (w
, posint
, &fully_p
, NILP (partially
));
360 in_window
= fully_p
? Qt
: Qnil
;
365 else if (posint
> BUF_ZV (buf
))
367 else if (CHARPOS (top
) < BUF_BEGV (buf
) || CHARPOS (top
) > BUF_ZV (buf
))
368 /* If window start is out of range, do something reasonable. */
372 if (pos_visible_p (w
, posint
, &fully_p
, NILP (partially
)))
373 in_window
= !NILP (partially
) || fully_p
? Qt
: Qnil
;
382 static struct window
*
383 decode_window (window
)
384 register Lisp_Object window
;
387 return XWINDOW (selected_window
);
389 CHECK_LIVE_WINDOW (window
, 0);
390 return XWINDOW (window
);
393 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
394 doc
: /* Return the buffer that WINDOW is displaying. */)
398 return decode_window (window
)->buffer
;
401 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
402 doc
: /* Return the number of lines in WINDOW (including its mode line). */)
406 return decode_window (window
)->height
;
409 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
410 doc
: /* Return the number of display columns in WINDOW.
411 This is the width that is usable columns available for text in WINDOW.
412 If you want to find out how many columns WINDOW takes up,
413 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
417 return make_number (window_internal_width (decode_window (window
)));
420 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
421 doc
: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
425 return decode_window (window
)->hscroll
;
428 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
429 doc
: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
430 NCOL should be zero or positive. */)
432 Lisp_Object window
, ncol
;
434 struct window
*w
= decode_window (window
);
437 CHECK_NUMBER (ncol
, 1);
438 hscroll
= max (0, XINT (ncol
));
440 /* Prevent redisplay shortcuts when changing the hscroll. */
441 if (XINT (w
->hscroll
) != hscroll
)
442 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
444 w
->hscroll
= make_number (hscroll
);
448 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger
,
449 Swindow_redisplay_end_trigger
, 0, 1, 0,
450 doc
: /* Return WINDOW's redisplay end trigger value.
451 See `set-window-redisplay-end-trigger' for more information. */)
455 return decode_window (window
)->redisplay_end_trigger
;
458 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger
,
459 Sset_window_redisplay_end_trigger
, 2, 2, 0,
460 doc
: /* Set WINDOW's redisplay end trigger value to VALUE.
461 VALUE should be a buffer position (typically a marker) or nil.
462 If it is a buffer position, then if redisplay in WINDOW reaches a position
463 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
464 with two arguments: WINDOW, and the end trigger value.
465 Afterwards the end-trigger value is reset to nil. */)
467 register Lisp_Object window
, value
;
469 register struct window
*w
;
471 w
= decode_window (window
);
472 w
->redisplay_end_trigger
= value
;
476 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
477 doc
: /* Return a list of the edge coordinates of WINDOW.
478 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
479 RIGHT is one more than the rightmost column used by WINDOW,
480 and BOTTOM is one more than the bottommost row used by WINDOW
481 and its mode-line. */)
485 register struct window
*w
= decode_window (window
);
487 return Fcons (w
->left
, Fcons (w
->top
,
488 Fcons (make_number (WINDOW_RIGHT_EDGE (w
)),
489 Fcons (make_number (XFASTINT (w
->top
)
490 + XFASTINT (w
->height
)),
494 /* Test if the character at column *X, row *Y is within window W.
495 If it is not, return 0;
496 if it is in the window's text area,
497 set *x and *y to its location relative to the upper left corner
500 if it is on the window's modeline, return 2;
501 if it is on the border between the window and its right sibling,
503 if it is on the window's top line, return 4;
504 if it is in the bitmap area to the left/right of the window,
505 return 5 or 6, and convert *X and *Y to window-relative corrdinates.
507 X and Y are frame relative pixel coordinates. */
509 static enum window_part
510 coordinates_in_window (w
, x
, y
)
511 register struct window
*w
;
514 /* Let's make this a global enum later, instead of using numbers
516 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
517 int left_x
, right_x
, top_y
, bottom_y
;
518 int flags_area_width
= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
519 enum window_part part
;
520 int ux
= CANON_X_UNIT (f
), uy
= CANON_Y_UNIT (f
);
521 int x0
= XFASTINT (w
->left
) * ux
;
522 int x1
= x0
+ XFASTINT (w
->width
) * ux
;
523 /* The width of the area where the vertical line can be dragged.
524 (Between mode lines for instance. */
525 int grabbable_width
= ux
;
527 if (*x
< x0
|| *x
>= x1
)
530 /* In what's below, we subtract 1 when computing right_x because we
531 want the rightmost pixel, which is given by left_pixel+width-1. */
532 if (w
->pseudo_window_p
)
535 right_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
) - 1;
536 top_y
= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
537 bottom_y
= WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w
);
541 left_x
= (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
)
542 - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
));
543 right_x
= WINDOW_DISPLAY_RIGHT_EDGE_PIXEL_X (w
) - 1;
544 top_y
= (WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
)
545 - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
));
546 bottom_y
= WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w
);
549 /* On the mode line or header line? If it's near the start of
550 the mode or header line of window that's has a horizontal
551 sibling, say it's on the vertical line. That's to be able
552 to resize windows horizontally in case we're using toolkit
555 if (WINDOW_WANTS_MODELINE_P (w
)
556 && *y
>= bottom_y
- CURRENT_MODE_LINE_HEIGHT (w
)
559 /* We're somewhere on the mode line. We consider the place
560 between mode lines of horizontally adjacent mode lines
561 as the vertical border. If scroll bars on the left,
562 return the right window. */
565 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
567 if (abs (*x
- x0
) < grabbable_width
)
568 part
= ON_VERTICAL_BORDER
;
570 else if (!WINDOW_RIGHTMOST_P (w
) && abs (*x
- x1
) < grabbable_width
)
571 part
= ON_VERTICAL_BORDER
;
573 else if (WINDOW_WANTS_HEADER_LINE_P (w
)
574 && *y
< top_y
+ CURRENT_HEADER_LINE_HEIGHT (w
)
577 part
= ON_HEADER_LINE
;
579 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
581 if (abs (*x
- x0
) < grabbable_width
)
582 part
= ON_VERTICAL_BORDER
;
584 else if (!WINDOW_RIGHTMOST_P (w
) && abs (*x
- x1
) < grabbable_width
)
585 part
= ON_VERTICAL_BORDER
;
587 /* Outside anything interesting? */
592 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * ux
)
595 + FRAME_RIGHT_SCROLL_BAR_WIDTH (f
) * ux
))
599 else if (FRAME_WINDOW_P (f
))
601 if (!w
->pseudo_window_p
602 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
603 && !WINDOW_RIGHTMOST_P (w
)
604 && (abs (*x
- right_x
- flags_area_width
) < grabbable_width
))
606 part
= ON_VERTICAL_BORDER
;
608 else if (*x
< left_x
|| *x
> right_x
)
610 /* Other lines than the mode line don't include flags areas and
611 scroll bars on the left. */
613 /* Convert X and Y to window-relative pixel coordinates. */
616 part
= *x
< left_x
? ON_LEFT_FRINGE
: ON_RIGHT_FRINGE
;
627 /* Need to say "*x > right_x" rather than >=, since on character
628 terminals, the vertical line's x coordinate is right_x. */
629 if (*x
< left_x
|| *x
> right_x
)
631 /* Other lines than the mode line don't include flags areas and
632 scroll bars on the left. */
634 /* Convert X and Y to window-relative pixel coordinates. */
637 part
= *x
< left_x
? ON_LEFT_FRINGE
: ON_RIGHT_FRINGE
;
639 /* Here, too, "*x > right_x" is because of character terminals. */
640 else if (!w
->pseudo_window_p
641 && !WINDOW_RIGHTMOST_P (w
)
642 && *x
> right_x
- ux
)
644 /* On the border on the right side of the window? Assume that
645 this area begins at RIGHT_X minus a canonical char width. */
646 part
= ON_VERTICAL_BORDER
;
650 /* Convert X and Y to window-relative pixel coordinates. */
661 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
662 Scoordinates_in_window_p
, 2, 2, 0,
663 doc
: /* Return non-nil if COORDINATES are in WINDOW.
664 COORDINATES is a cons of the form (X . Y), X and Y being distances
665 measured in characters from the upper-left corner of the frame.
666 \(0 . 0) denotes the character in the upper left corner of the
668 If COORDINATES are in the text portion of WINDOW,
669 the coordinates relative to the window are returned.
670 If they are in the mode line of WINDOW, `mode-line' is returned.
671 If they are in the top mode line of WINDOW, `header-line' is returned.
672 If they are in the fringe to the left of the window,
673 `left-fringe' is returned, if they are in the area on the right of
674 the window, `right-fringe' is returned.
675 If they are on the border between WINDOW and its right sibling,
676 `vertical-line' is returned. */)
677 (coordinates
, window
)
678 register Lisp_Object coordinates
, window
;
685 CHECK_LIVE_WINDOW (window
, 0);
686 w
= XWINDOW (window
);
687 f
= XFRAME (w
->frame
);
688 CHECK_CONS (coordinates
, 1);
689 lx
= Fcar (coordinates
);
690 ly
= Fcdr (coordinates
);
691 CHECK_NUMBER_OR_FLOAT (lx
, 1);
692 CHECK_NUMBER_OR_FLOAT (ly
, 1);
693 x
= PIXEL_X_FROM_CANON_X (f
, lx
);
694 y
= PIXEL_Y_FROM_CANON_Y (f
, ly
);
696 switch (coordinates_in_window (w
, &x
, &y
))
702 /* X and Y are now window relative pixel coordinates. Convert
703 them to canonical char units before returning them. */
704 return Fcons (CANON_X_FROM_PIXEL_X (f
, x
),
705 CANON_Y_FROM_PIXEL_Y (f
, y
));
710 case ON_VERTICAL_BORDER
:
711 return Qvertical_line
;
719 case ON_RIGHT_FRINGE
:
720 return Qright_fringe
;
728 /* Callback for foreach_window, used in window_from_coordinates.
729 Check if window W contains coordinates specified by USER_DATA which
730 is actually a pointer to a struct check_window_data CW.
732 Check if window W contains coordinates *CW->x and *CW->y. If it
733 does, return W in *CW->window, as Lisp_Object, and return in
734 *CW->part the part of the window under coordinates *X,*Y. Return
735 zero from this function to stop iterating over windows. */
737 struct check_window_data
744 check_window_containing (w
, user_data
)
748 struct check_window_data
*cw
= (struct check_window_data
*) user_data
;
749 enum window_part found
;
752 found
= coordinates_in_window (w
, cw
->x
, cw
->y
);
753 if (found
!= ON_NOTHING
)
755 *cw
->part
= found
- 1;
756 XSETWINDOW (*cw
->window
, w
);
764 /* Find the window containing frame-relative pixel position X/Y and
765 return it as a Lisp_Object. If X, Y is on the window's modeline,
766 set *PART to 1; if it is on the separating line between the window
767 and its right sibling, set it to 2; otherwise set it to 0. If
768 there is no window under X, Y return nil and leave *PART
769 unmodified. TOOL_BAR_P non-zero means detect tool-bar windows.
771 This function was previously implemented with a loop cycling over
772 windows with Fnext_window, and starting with the frame's selected
773 window. It turned out that this doesn't work with an
774 implementation of next_window using Vwindow_list, because
775 FRAME_SELECTED_WINDOW (F) is not always contained in the window
776 tree of F when this function is called asynchronously from
777 note_mouse_highlight. The original loop didn't terminate in this
781 window_from_coordinates (f
, x
, y
, part
, tool_bar_p
)
788 struct check_window_data cw
;
791 cw
.window
= &window
, cw
.x
= &x
, cw
.y
= &y
; cw
.part
= part
;
792 foreach_window (f
, check_window_containing
, &cw
);
794 /* If not found above, see if it's in the tool bar window, if a tool
798 && WINDOWP (f
->tool_bar_window
)
799 && XINT (XWINDOW (f
->tool_bar_window
)->height
) > 0
800 && (coordinates_in_window (XWINDOW (f
->tool_bar_window
), &x
, &y
)
804 window
= f
->tool_bar_window
;
810 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
811 doc
: /* Return window containing coordinates X and Y on FRAME.
812 If omitted, FRAME defaults to the currently selected frame.
813 The top left corner of the frame is considered to be row 0,
816 Lisp_Object x
, y
, frame
;
822 frame
= selected_frame
;
823 CHECK_LIVE_FRAME (frame
, 2);
826 /* Check that arguments are integers or floats. */
827 CHECK_NUMBER_OR_FLOAT (x
, 0);
828 CHECK_NUMBER_OR_FLOAT (y
, 1);
830 return window_from_coordinates (f
,
831 PIXEL_X_FROM_CANON_X (f
, x
),
832 PIXEL_Y_FROM_CANON_Y (f
, y
),
836 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
837 doc
: /* Return current value of point in WINDOW.
838 For a nonselected window, this is the value point would have
839 if that window were selected.
841 Note that, when WINDOW is the selected window and its buffer
842 is also currently selected, the value returned is the same as (point).
843 It would be more strictly correct to return the `top-level' value
844 of point, outside of any save-excursion forms.
845 But that is hard to define. */)
849 register struct window
*w
= decode_window (window
);
851 if (w
== XWINDOW (selected_window
)
852 && current_buffer
== XBUFFER (w
->buffer
))
854 return Fmarker_position (w
->pointm
);
857 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
858 doc
: /* Return position at which display currently starts in WINDOW.
859 This is updated by redisplay or by calling `set-window-start'. */)
863 return Fmarker_position (decode_window (window
)->start
);
866 /* This is text temporarily removed from the doc string below.
868 This function returns nil if the position is not currently known.
869 That happens when redisplay is preempted and doesn't finish.
870 If in that case you want to compute where the end of the window would
871 have been if redisplay had finished, do this:
873 (goto-char (window-start window))
874 (vertical-motion (1- (window-height window)) window)
877 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 2, 0,
878 doc
: /* Return position at which display currently ends in WINDOW.
879 This is updated by redisplay, when it runs to completion.
880 Simply changing the buffer text or setting `window-start'
881 does not update this value.
882 If UPDATE is non-nil, compute the up-to-date position
883 if it isn't already recorded. */)
885 Lisp_Object window
, update
;
888 struct window
*w
= decode_window (window
);
892 CHECK_BUFFER (buf
, 0);
894 #if 0 /* This change broke some things. We should make it later. */
895 /* If we don't know the end position, return nil.
896 The user can compute it with vertical-motion if he wants to.
897 It would be nicer to do it automatically,
898 but that's so slow that it would probably bother people. */
899 if (NILP (w
->window_end_valid
))
904 && ! (! NILP (w
->window_end_valid
)
905 && XFASTINT (w
->last_modified
) >= MODIFF
))
907 struct text_pos startp
;
909 struct buffer
*old_buffer
= NULL
, *b
= XBUFFER (buf
);
911 /* In case W->start is out of the range, use something
912 reasonable. This situation occured when loading a file with
913 `-l' containing a call to `rmail' with subsequent other
914 commands. At the end, W->start happened to be BEG, while
915 rmail had already narrowed the buffer. */
916 if (XMARKER (w
->start
)->charpos
< BEGV
)
917 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
918 else if (XMARKER (w
->start
)->charpos
> ZV
)
919 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
921 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
923 /* Cannot use Fvertical_motion because that function doesn't
924 cope with variable-height lines. */
925 if (b
!= current_buffer
)
927 old_buffer
= current_buffer
;
928 set_buffer_internal (b
);
931 start_display (&it
, w
, startp
);
932 move_it_vertically (&it
, window_box_height (w
));
933 if (it
.current_y
< it
.last_visible_y
)
934 move_it_past_eol (&it
);
935 value
= make_number (IT_CHARPOS (it
));
938 set_buffer_internal (old_buffer
);
941 XSETINT (value
, BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
946 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
947 doc
: /* Make point value in WINDOW be at position POS in WINDOW's buffer. */)
949 Lisp_Object window
, pos
;
951 register struct window
*w
= decode_window (window
);
953 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
954 if (w
== XWINDOW (selected_window
)
955 && XBUFFER (w
->buffer
) == current_buffer
)
958 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
960 /* We have to make sure that redisplay updates the window to show
961 the new value of point. */
962 if (!EQ (window
, selected_window
))
963 ++windows_or_buffers_changed
;
968 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
969 doc
: /* Make display in WINDOW start at position POS in WINDOW's buffer.
970 Optional third arg NOFORCE non-nil inhibits next redisplay
971 from overriding motion of point in order to display at this exact start. */)
972 (window
, pos
, noforce
)
973 Lisp_Object window
, pos
, noforce
;
975 register struct window
*w
= decode_window (window
);
977 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
978 set_marker_restricted (w
->start
, pos
, w
->buffer
);
979 /* this is not right, but much easier than doing what is right. */
980 w
->start_at_line_beg
= Qnil
;
983 w
->update_mode_line
= Qt
;
984 XSETFASTINT (w
->last_modified
, 0);
985 XSETFASTINT (w
->last_overlay_modified
, 0);
986 if (!EQ (window
, selected_window
))
987 windows_or_buffers_changed
++;
992 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
994 doc
: /* Return WINDOW's dedicated object, usually t or nil.
995 See also `set-window-dedicated-p'. */)
999 return decode_window (window
)->dedicated
;
1002 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
1003 Sset_window_dedicated_p
, 2, 2, 0,
1004 doc
: /* Control whether WINDOW is dedicated to the buffer it displays.
1005 If it is dedicated, Emacs will not automatically change
1006 which buffer appears in it.
1007 The second argument is the new value for the dedication flag;
1008 non-nil means yes. */)
1010 Lisp_Object window
, arg
;
1012 register struct window
*w
= decode_window (window
);
1015 w
->dedicated
= Qnil
;
1019 return w
->dedicated
;
1022 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
1024 doc
: /* Return the display-table that WINDOW is using. */)
1028 return decode_window (window
)->display_table
;
1031 /* Get the display table for use on window W. This is either W's
1032 display table or W's buffer's display table. Ignore the specified
1033 tables if they are not valid; if no valid table is specified,
1036 struct Lisp_Char_Table
*
1037 window_display_table (w
)
1040 struct Lisp_Char_Table
*dp
= NULL
;
1042 if (DISP_TABLE_P (w
->display_table
))
1043 dp
= XCHAR_TABLE (w
->display_table
);
1044 else if (BUFFERP (w
->buffer
))
1046 struct buffer
*b
= XBUFFER (w
->buffer
);
1048 if (DISP_TABLE_P (b
->display_table
))
1049 dp
= XCHAR_TABLE (b
->display_table
);
1050 else if (DISP_TABLE_P (Vstandard_display_table
))
1051 dp
= XCHAR_TABLE (Vstandard_display_table
);
1057 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
1058 doc
: /* Set WINDOW's display-table to TABLE. */)
1060 register Lisp_Object window
, table
;
1062 register struct window
*w
;
1064 w
= decode_window (window
);
1065 w
->display_table
= table
;
1069 /* Record info on buffer window w is displaying
1070 when it is about to cease to display that buffer. */
1073 register struct window
*w
;
1080 if (b
!= XMARKER (w
->pointm
)->buffer
)
1084 if (w
== XWINDOW (selected_window
)
1085 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
1086 /* Do this except when the selected window's buffer
1087 is being removed from some other window. */
1089 /* last_window_start records the start position that this buffer
1090 had in the last window to be disconnected from it.
1091 Now that this statement is unconditional,
1092 it is possible for the buffer to be displayed in the
1093 selected window, while last_window_start reflects another
1094 window which was recently showing the same buffer.
1095 Some people might say that might be a good thing. Let's see. */
1096 b
->last_window_start
= marker_position (w
->start
);
1098 /* Point in the selected window's buffer
1099 is actually stored in that buffer, and the window's pointm isn't used.
1100 So don't clobber point in that buffer. */
1101 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
)
1102 /* This line helps to fix Horsley's testbug.el bug. */
1103 && !(WINDOWP (b
->last_selected_window
)
1104 && w
!= XWINDOW (b
->last_selected_window
)
1105 && EQ (buf
, XWINDOW (b
->last_selected_window
)->buffer
)))
1106 temp_set_point_both (b
,
1107 clip_to_bounds (BUF_BEGV (b
),
1108 XMARKER (w
->pointm
)->charpos
,
1110 clip_to_bounds (BUF_BEGV_BYTE (b
),
1111 marker_byte_position (w
->pointm
),
1114 if (WINDOWP (b
->last_selected_window
)
1115 && w
== XWINDOW (b
->last_selected_window
))
1116 b
->last_selected_window
= Qnil
;
1119 /* Put replacement into the window structure in place of old. */
1121 replace_window (old
, replacement
)
1122 Lisp_Object old
, replacement
;
1124 register Lisp_Object tem
;
1125 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
1127 /* If OLD is its frame's root_window, then replacement is the new
1128 root_window for that frame. */
1130 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
1131 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
1135 p
->width
= o
->width
;
1136 p
->height
= o
->height
;
1137 p
->desired_matrix
= p
->current_matrix
= 0;
1139 bzero (&p
->cursor
, sizeof (p
->cursor
));
1140 bzero (&p
->last_cursor
, sizeof (p
->last_cursor
));
1141 bzero (&p
->phys_cursor
, sizeof (p
->phys_cursor
));
1142 p
->phys_cursor_type
= -1;
1143 p
->must_be_updated_p
= 0;
1144 p
->pseudo_window_p
= 0;
1145 XSETFASTINT (p
->window_end_vpos
, 0);
1146 XSETFASTINT (p
->window_end_pos
, 0);
1147 p
->window_end_valid
= Qnil
;
1148 p
->frozen_window_start_p
= 0;
1149 p
->orig_top
= p
->orig_height
= Qnil
;
1151 p
->next
= tem
= o
->next
;
1153 XWINDOW (tem
)->prev
= replacement
;
1155 p
->prev
= tem
= o
->prev
;
1157 XWINDOW (tem
)->next
= replacement
;
1159 p
->parent
= tem
= o
->parent
;
1162 if (EQ (XWINDOW (tem
)->vchild
, old
))
1163 XWINDOW (tem
)->vchild
= replacement
;
1164 if (EQ (XWINDOW (tem
)->hchild
, old
))
1165 XWINDOW (tem
)->hchild
= replacement
;
1168 /*** Here, if replacement is a vertical combination
1169 and so is its new parent, we should make replacement's
1170 children be children of that parent instead. ***/
1173 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
1174 doc
: /* Remove WINDOW from the display. Default is selected window. */)
1176 register Lisp_Object window
;
1178 delete_window (window
);
1180 if (! NILP (Vwindow_configuration_change_hook
)
1181 && ! NILP (Vrun_hooks
))
1182 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
1188 delete_window (window
)
1189 register Lisp_Object window
;
1191 register Lisp_Object tem
, parent
, sib
;
1192 register struct window
*p
;
1193 register struct window
*par
;
1196 /* Because this function is called by other C code on non-leaf
1197 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
1198 so we can't decode_window here. */
1200 window
= selected_window
;
1202 CHECK_WINDOW (window
, 0);
1203 p
= XWINDOW (window
);
1205 /* It's okay to delete an already-deleted window. */
1206 if (NILP (p
->buffer
)
1208 && NILP (p
->vchild
))
1213 error ("Attempt to delete minibuffer or sole ordinary window");
1214 par
= XWINDOW (parent
);
1216 windows_or_buffers_changed
++;
1217 Vwindow_list
= Qnil
;
1218 f
= XFRAME (WINDOW_FRAME (p
));
1219 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
1221 /* Are we trying to delete any frame's selected window? */
1223 Lisp_Object pwindow
;
1225 /* See if the frame's selected window is either WINDOW
1226 or any subwindow of it, by finding all that window's parents
1227 and comparing each one with WINDOW. */
1228 pwindow
= FRAME_SELECTED_WINDOW (f
);
1230 while (!NILP (pwindow
))
1232 if (EQ (window
, pwindow
))
1234 pwindow
= XWINDOW (pwindow
)->parent
;
1237 if (EQ (window
, pwindow
))
1239 Lisp_Object alternative
;
1240 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
1242 /* If we're about to delete the selected window on the
1243 selected frame, then we should use Fselect_window to select
1244 the new window. On the other hand, if we're about to
1245 delete the selected window on any other frame, we shouldn't do
1246 anything but set the frame's selected_window slot. */
1247 if (EQ (window
, selected_window
))
1248 Fselect_window (alternative
);
1250 FRAME_SELECTED_WINDOW (f
) = alternative
;
1255 /* tem is null for dummy parent windows
1256 (which have inferiors but not any contents themselves) */
1260 unchain_marker (p
->pointm
);
1261 unchain_marker (p
->start
);
1264 /* Free window glyph matrices. It is sure that they are allocated
1265 again when ADJUST_GLYPHS is called. Block input so that expose
1266 events and other events that access glyph matrices are not
1267 processed while we are changing them. */
1269 free_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)));
1273 XWINDOW (tem
)->prev
= p
->prev
;
1277 XWINDOW (tem
)->next
= p
->next
;
1279 if (EQ (window
, par
->hchild
))
1280 par
->hchild
= p
->next
;
1281 if (EQ (window
, par
->vchild
))
1282 par
->vchild
= p
->next
;
1284 /* Find one of our siblings to give our space to. */
1288 /* If p gives its space to its next sibling, that sibling needs
1289 to have its top/left side pulled back to where p's is.
1290 set_window_{height,width} will re-position the sibling's
1293 XWINDOW (sib
)->top
= p
->top
;
1294 XWINDOW (sib
)->left
= p
->left
;
1297 /* Stretch that sibling. */
1298 if (!NILP (par
->vchild
))
1299 set_window_height (sib
,
1300 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
1302 if (!NILP (par
->hchild
))
1303 set_window_width (sib
,
1304 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
1307 /* If parent now has only one child,
1308 put the child into the parent's place. */
1312 if (NILP (XWINDOW (tem
)->next
))
1313 replace_window (parent
, tem
);
1315 /* Since we may be deleting combination windows, we must make sure that
1316 not only p but all its children have been marked as deleted. */
1317 if (! NILP (p
->hchild
))
1318 delete_all_subwindows (XWINDOW (p
->hchild
));
1319 else if (! NILP (p
->vchild
))
1320 delete_all_subwindows (XWINDOW (p
->vchild
));
1322 /* Mark this window as deleted. */
1323 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
1325 /* Adjust glyph matrices. */
1332 /***********************************************************************
1334 ***********************************************************************/
1336 /* Add window W to *USER_DATA. USER_DATA is actually a Lisp_Object
1337 pointer. This is a callback function for foreach_window, used in
1338 function window_list. */
1341 add_window_to_list (w
, user_data
)
1345 Lisp_Object
*list
= (Lisp_Object
*) user_data
;
1347 XSETWINDOW (window
, w
);
1348 *list
= Fcons (window
, *list
);
1353 /* Return a list of all windows, for use by next_window. If
1354 Vwindow_list is a list, return that list. Otherwise, build a new
1355 list, cache it in Vwindow_list, and return that. */
1360 if (!CONSP (Vwindow_list
))
1364 Vwindow_list
= Qnil
;
1365 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1367 Lisp_Object args
[2];
1369 /* We are visiting windows in canonical order, and add
1370 new windows at the front of args[1], which means we
1371 have to reverse this list at the end. */
1373 foreach_window (XFRAME (XCAR (tail
)), add_window_to_list
, &args
[1]);
1374 args
[0] = Vwindow_list
;
1375 args
[1] = Fnreverse (args
[1]);
1376 Vwindow_list
= Fnconc (2, args
);
1380 return Vwindow_list
;
1384 /* Value is non-zero if WINDOW satisfies the constraints given by
1385 OWINDOW, MINIBUF and ALL_FRAMES.
1387 MINIBUF t means WINDOW may be minibuffer windows.
1388 `lambda' means WINDOW may not be a minibuffer window.
1389 a window means a specific minibuffer window
1391 ALL_FRAMES t means search all frames,
1392 nil means search just current frame,
1393 `visible' means search just visible frames,
1394 0 means search visible and iconified frames,
1395 a window means search the frame that window belongs to,
1396 a frame means consider windows on that frame, only. */
1399 candidate_window_p (window
, owindow
, minibuf
, all_frames
)
1400 Lisp_Object window
, owindow
, minibuf
, all_frames
;
1402 struct window
*w
= XWINDOW (window
);
1403 struct frame
*f
= XFRAME (w
->frame
);
1404 int candidate_p
= 1;
1406 if (!BUFFERP (w
->buffer
))
1408 else if (MINI_WINDOW_P (w
)
1409 && (EQ (minibuf
, Qlambda
)
1410 || (WINDOWP (minibuf
) && !EQ (minibuf
, window
))))
1412 /* If MINIBUF is `lambda' don't consider any mini-windows.
1413 If it is a window, consider only that one. */
1416 else if (EQ (all_frames
, Qt
))
1418 else if (NILP (all_frames
))
1420 xassert (WINDOWP (owindow
));
1421 candidate_p
= EQ (w
->frame
, XWINDOW (owindow
)->frame
);
1423 else if (EQ (all_frames
, Qvisible
))
1425 FRAME_SAMPLE_VISIBILITY (f
);
1426 candidate_p
= FRAME_VISIBLE_P (f
);
1428 else if (INTEGERP (all_frames
) && XINT (all_frames
) == 0)
1430 FRAME_SAMPLE_VISIBILITY (f
);
1431 candidate_p
= FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
);
1433 else if (WINDOWP (all_frames
))
1434 candidate_p
= (EQ (FRAME_MINIBUF_WINDOW (f
), all_frames
)
1435 || EQ (XWINDOW (all_frames
)->frame
, w
->frame
)
1436 || EQ (XWINDOW (all_frames
)->frame
, FRAME_FOCUS_FRAME (f
)));
1437 else if (FRAMEP (all_frames
))
1438 candidate_p
= EQ (all_frames
, w
->frame
);
1444 /* Decode arguments as allowed by Fnext_window, Fprevious_window, and
1445 Fwindow_list. See there for the meaning of WINDOW, MINIBUF, and
1449 decode_next_window_args (window
, minibuf
, all_frames
)
1450 Lisp_Object
*window
, *minibuf
, *all_frames
;
1453 *window
= selected_window
;
1455 CHECK_LIVE_WINDOW (*window
, 0);
1457 /* MINIBUF nil may or may not include minibuffers. Decide if it
1459 if (NILP (*minibuf
))
1460 *minibuf
= minibuf_level
? minibuf_window
: Qlambda
;
1461 else if (!EQ (*minibuf
, Qt
))
1464 /* Now *MINIBUF can be t => count all minibuffer windows, `lambda'
1465 => count none of them, or a specific minibuffer window (the
1466 active one) to count. */
1468 /* ALL_FRAMES nil doesn't specify which frames to include. */
1469 if (NILP (*all_frames
))
1470 *all_frames
= (!EQ (*minibuf
, Qlambda
)
1471 ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window
)->frame
))
1473 else if (EQ (*all_frames
, Qvisible
))
1475 else if (XFASTINT (*all_frames
) == 0)
1477 else if (FRAMEP (*all_frames
))
1479 else if (!EQ (*all_frames
, Qt
))
1482 /* Now *ALL_FRAMES is t meaning search all frames, nil meaning
1483 search just current frame, `visible' meaning search just visible
1484 frames, 0 meaning search visible and iconified frames, or a
1485 window, meaning search the frame that window belongs to, or a
1486 frame, meaning consider windows on that frame, only. */
1490 /* Return the next or previous window of WINDOW in canonical ordering
1491 of windows. NEXT_P non-zero means return the next window. See the
1492 documentation string of next-window for the meaning of MINIBUF and
1496 next_window (window
, minibuf
, all_frames
, next_p
)
1497 Lisp_Object window
, minibuf
, all_frames
;
1500 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1502 /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
1503 return the first window on the frame. */
1504 if (FRAMEP (all_frames
)
1505 && !EQ (all_frames
, XWINDOW (window
)->frame
))
1506 return Fframe_first_window (all_frames
);
1512 /* Find WINDOW in the list of all windows. */
1513 list
= Fmemq (window
, window_list ());
1515 /* Scan forward from WINDOW to the end of the window list. */
1517 for (list
= XCDR (list
); CONSP (list
); list
= XCDR (list
))
1518 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1521 /* Scan from the start of the window list up to WINDOW. */
1523 for (list
= Vwindow_list
;
1524 CONSP (list
) && !EQ (XCAR (list
), window
);
1526 if (candidate_window_p (XCAR (list
), window
, minibuf
, all_frames
))
1530 window
= XCAR (list
);
1534 Lisp_Object candidate
, list
;
1536 /* Scan through the list of windows for candidates. If there are
1537 candidate windows in front of WINDOW, the last one of these
1538 is the one we want. If there are candidates following WINDOW
1539 in the list, again the last one of these is the one we want. */
1541 for (list
= window_list (); CONSP (list
); list
= XCDR (list
))
1543 if (EQ (XCAR (list
), window
))
1545 if (WINDOWP (candidate
))
1548 else if (candidate_window_p (XCAR (list
), window
, minibuf
,
1550 candidate
= XCAR (list
);
1553 if (WINDOWP (candidate
))
1561 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
1562 doc
: /* Return next window after WINDOW in canonical ordering of windows.
1563 If omitted, WINDOW defaults to the selected window.
1565 Optional second arg MINIBUF t means count the minibuffer window even
1566 if not active. MINIBUF nil or omitted means count the minibuffer iff
1567 it is active. MINIBUF neither t nor nil means not to count the
1568 minibuffer even if it is active.
1570 Several frames may share a single minibuffer; if the minibuffer
1571 counts, all windows on all frames that share that minibuffer count
1572 too. Therefore, `next-window' can be used to iterate through the
1573 set of windows even when the minibuffer is on another frame. If the
1574 minibuffer does not count, only windows from WINDOW's frame count.
1576 Optional third arg ALL-FRAMES t means include windows on all frames.
1577 ALL-FRAMES nil or omitted means cycle within the frames as specified
1578 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1579 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1580 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1581 Anything else means restrict to WINDOW's frame.
1583 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1584 `next-window' to iterate through the entire cycle of acceptable
1585 windows, eventually ending up back at the window you started with.
1586 `previous-window' traverses the same cycle, in the reverse order. */)
1587 (window
, minibuf
, all_frames
)
1588 Lisp_Object window
, minibuf
, all_frames
;
1590 return next_window (window
, minibuf
, all_frames
, 1);
1594 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1595 doc
: /* Return the window preceding WINDOW in canonical ordering of windows.
1596 If omitted, WINDOW defaults to the selected window.
1598 Optional second arg MINIBUF t means count the minibuffer window even
1599 if not active. MINIBUF nil or omitted means count the minibuffer iff
1600 it is active. MINIBUF neither t nor nil means not to count the
1601 minibuffer even if it is active.
1603 Several frames may share a single minibuffer; if the minibuffer
1604 counts, all windows on all frames that share that minibuffer count
1605 too. Therefore, `previous-window' can be used to iterate through
1606 the set of windows even when the minibuffer is on another frame. If
1607 the minibuffer does not count, only windows from WINDOW's frame count
1609 Optional third arg ALL-FRAMES t means include windows on all frames.
1610 ALL-FRAMES nil or omitted means cycle within the frames as specified
1611 above. ALL-FRAMES = `visible' means include windows on all visible frames.
1612 ALL-FRAMES = 0 means include windows on all visible and iconified frames.
1613 If ALL-FRAMES is a frame, restrict search to windows on that frame.
1614 Anything else means restrict to WINDOW's frame.
1616 If you use consistent values for MINIBUF and ALL-FRAMES, you can use
1617 `previous-window' to iterate through the entire cycle of acceptable
1618 windows, eventually ending up back at the window you started with.
1619 `next-window' traverses the same cycle, in the reverse order. */)
1620 (window
, minibuf
, all_frames
)
1621 Lisp_Object window
, minibuf
, all_frames
;
1623 return next_window (window
, minibuf
, all_frames
, 0);
1627 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1628 doc
: /* Select the ARG'th different window on this frame.
1629 All windows on current frame are arranged in a cyclic order.
1630 This command selects the window ARG steps away in that order.
1631 A negative ARG moves in the opposite order. If the optional second
1632 argument ALL_FRAMES is non-nil, cycle through all frames. */)
1634 Lisp_Object arg
, all_frames
;
1639 CHECK_NUMBER (arg
, 0);
1640 window
= selected_window
;
1642 for (i
= XINT (arg
); i
> 0; --i
)
1643 window
= Fnext_window (window
, Qnil
, all_frames
);
1645 window
= Fprevious_window (window
, Qnil
, all_frames
);
1647 Fselect_window (window
);
1652 DEFUN ("window-list", Fwindow_list
, Swindow_list
, 0, 3, 0,
1653 doc
: /* Return a list of windows on FRAME, starting with WINDOW.
1654 FRAME nil or omitted means use the selected frame.
1655 WINDOW nil or omitted means use the selected window.
1656 MINIBUF t means include the minibuffer window, even if it isn't active.
1657 MINIBUF nil or omitted means include the minibuffer window only
1659 MINIBUF neither nil nor t means never include the minibuffer window. */)
1660 (frame
, minibuf
, window
)
1661 Lisp_Object frame
, minibuf
, window
;
1664 window
= selected_window
;
1666 frame
= selected_frame
;
1668 if (!EQ (frame
, XWINDOW (window
)->frame
))
1669 error ("Window is on a different frame");
1671 return window_list_1 (window
, minibuf
, frame
);
1675 /* Return a list of windows in canonical ordering. Arguments are like
1676 for `next-window'. */
1679 window_list_1 (window
, minibuf
, all_frames
)
1680 Lisp_Object window
, minibuf
, all_frames
;
1682 Lisp_Object tail
, list
;
1684 decode_next_window_args (&window
, &minibuf
, &all_frames
);
1687 for (tail
= window_list (); CONSP (tail
); tail
= XCDR (tail
))
1688 if (candidate_window_p (XCAR (tail
), window
, minibuf
, all_frames
))
1689 list
= Fcons (XCAR (tail
), list
);
1691 return Fnreverse (list
);
1696 /* Look at all windows, performing an operation specified by TYPE
1698 If FRAMES is Qt, look at all frames;
1699 Qnil, look at just the selected frame;
1700 Qvisible, look at visible frames;
1701 a frame, just look at windows on that frame.
1702 If MINI is non-zero, perform the operation on minibuffer windows too. */
1707 GET_BUFFER_WINDOW
, /* Arg is buffer */
1708 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1709 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1710 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1712 UNSHOW_BUFFER
, /* Arg is buffer */
1717 window_loop (type
, obj
, mini
, frames
)
1718 enum window_loop type
;
1719 Lisp_Object obj
, frames
;
1722 Lisp_Object window
, windows
, best_window
, frame_arg
;
1724 struct gcpro gcpro1
;
1726 /* If we're only looping through windows on a particular frame,
1727 frame points to that frame. If we're looping through windows
1728 on all frames, frame is 0. */
1729 if (FRAMEP (frames
))
1730 f
= XFRAME (frames
);
1731 else if (NILP (frames
))
1732 f
= SELECTED_FRAME ();
1737 frame_arg
= Qlambda
;
1738 else if (XFASTINT (frames
) == 0)
1740 else if (EQ (frames
, Qvisible
))
1745 /* frame_arg is Qlambda to stick to one frame,
1746 Qvisible to consider all visible frames,
1749 /* Pick a window to start with. */
1753 window
= FRAME_SELECTED_WINDOW (f
);
1755 window
= FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1757 windows
= window_list_1 (window
, mini
? Qt
: Qnil
, frame_arg
);
1761 for (; CONSP (windows
); windows
= CDR (windows
))
1765 window
= XCAR (windows
);
1766 w
= XWINDOW (window
);
1768 /* Note that we do not pay attention here to whether the frame
1769 is visible, since Fwindow_list skips non-visible frames if
1770 that is desired, under the control of frame_arg. */
1771 if (!MINI_WINDOW_P (w
)
1772 /* For UNSHOW_BUFFER, we must always consider all windows. */
1773 || type
== UNSHOW_BUFFER
1774 || (mini
&& minibuf_level
> 0))
1777 case GET_BUFFER_WINDOW
:
1778 if (EQ (w
->buffer
, obj
)
1779 /* Don't find any minibuffer window
1780 except the one that is currently in use. */
1781 && (MINI_WINDOW_P (w
)
1782 ? EQ (window
, minibuf_window
)
1785 if (NILP (best_window
))
1786 best_window
= window
;
1787 else if (EQ (window
, selected_window
))
1788 /* For compatibility with 20.x, prefer to return
1790 best_window
= window
;
1794 case GET_LRU_WINDOW
:
1795 /* t as arg means consider only full-width windows */
1796 if (!NILP (obj
) && !WINDOW_FULL_WIDTH_P (w
))
1798 /* Ignore dedicated windows and minibuffers. */
1799 if (MINI_WINDOW_P (w
) || !NILP (w
->dedicated
))
1801 if (NILP (best_window
)
1802 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1803 > XFASTINT (w
->use_time
)))
1804 best_window
= window
;
1807 case DELETE_OTHER_WINDOWS
:
1808 if (!EQ (window
, obj
))
1809 Fdelete_window (window
);
1812 case DELETE_BUFFER_WINDOWS
:
1813 if (EQ (w
->buffer
, obj
))
1815 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1817 /* If this window is dedicated, and in a frame of its own,
1819 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1820 && !NILP (w
->dedicated
)
1821 && other_visible_frames (f
))
1823 /* Skip the other windows on this frame.
1824 There might be one, the minibuffer! */
1825 while (CONSP (XCDR (windows
))
1826 && EQ (XWINDOW (XCAR (windows
))->frame
,
1827 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1828 windows
= XCDR (windows
);
1830 /* Now we can safely delete the frame. */
1831 Fdelete_frame (w
->frame
, Qnil
);
1833 else if (NILP (w
->parent
))
1835 /* If we're deleting the buffer displayed in the
1836 only window on the frame, find a new buffer to
1839 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1840 Fset_window_buffer (window
, buffer
);
1841 if (EQ (window
, selected_window
))
1842 Fset_buffer (w
->buffer
);
1845 Fdelete_window (window
);
1849 case GET_LARGEST_WINDOW
:
1851 /* Ignore dedicated windows and minibuffers. */
1852 if (MINI_WINDOW_P (w
) || !NILP (w
->dedicated
))
1855 if (NILP (best_window
))
1856 best_window
= window
;
1859 struct window
*b
= XWINDOW (best_window
);
1860 if (XFASTINT (w
->height
) * XFASTINT (w
->width
)
1861 > XFASTINT (b
->height
) * XFASTINT (b
->width
))
1862 best_window
= window
;
1868 if (EQ (w
->buffer
, obj
))
1871 struct frame
*f
= XFRAME (w
->frame
);
1873 /* Find another buffer to show in this window. */
1874 buffer
= Fother_buffer (obj
, Qnil
, w
->frame
);
1876 /* If this window is dedicated, and in a frame of its own,
1878 if (EQ (window
, FRAME_ROOT_WINDOW (f
))
1879 && !NILP (w
->dedicated
)
1880 && other_visible_frames (f
))
1882 /* Skip the other windows on this frame.
1883 There might be one, the minibuffer! */
1884 while (CONSP (XCDR (windows
))
1885 && EQ (XWINDOW (XCAR (windows
))->frame
,
1886 XWINDOW (XCAR (XCDR (windows
)))->frame
))
1887 windows
= XCDR (windows
);
1889 /* Now we can safely delete the frame. */
1890 Fdelete_frame (w
->frame
, Qnil
);
1894 /* Otherwise show a different buffer in the window. */
1895 w
->dedicated
= Qnil
;
1896 Fset_window_buffer (window
, buffer
);
1897 if (EQ (window
, selected_window
))
1898 Fset_buffer (w
->buffer
);
1903 /* Check for a window that has a killed buffer. */
1904 case CHECK_ALL_WINDOWS
:
1905 if (! NILP (w
->buffer
)
1906 && NILP (XBUFFER (w
->buffer
)->name
))
1910 case WINDOW_LOOP_UNUSED
:
1919 /* Used for debugging. Abort if any window has a dead buffer. */
1922 check_all_windows ()
1924 window_loop (CHECK_ALL_WINDOWS
, Qnil
, 1, Qt
);
1927 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1928 doc
: /* Return the window least recently selected or used for display.
1929 If optional argument FRAME is `visible', search all visible frames.
1930 If FRAME is 0, search all visible and iconified frames.
1931 If FRAME is t, search all frames.
1932 If FRAME is nil, search only the selected frame.
1933 If FRAME is a frame, search only that frame. */)
1937 register Lisp_Object w
;
1938 /* First try for a window that is full-width */
1939 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1940 if (!NILP (w
) && !EQ (w
, selected_window
))
1942 /* If none of them, try the rest */
1943 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1946 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1947 doc
: /* Return the largest window in area.
1948 If optional argument FRAME is `visible', search all visible frames.
1949 If FRAME is 0, search all visible and iconified frames.
1950 If FRAME is t, search all frames.
1951 If FRAME is nil, search only the selected frame.
1952 If FRAME is a frame, search only that frame. */)
1956 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1960 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1961 doc
: /* Return a window currently displaying BUFFER, or nil if none.
1962 If optional argument FRAME is `visible', search all visible frames.
1963 If optional argument FRAME is 0, search all visible and iconified frames.
1964 If FRAME is t, search all frames.
1965 If FRAME is nil, search only the selected frame.
1966 If FRAME is a frame, search only that frame. */)
1968 Lisp_Object buffer
, frame
;
1970 buffer
= Fget_buffer (buffer
);
1971 if (BUFFERP (buffer
))
1972 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1977 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1979 doc
: /* Make WINDOW (or the selected window) fill its frame.
1980 Only the frame WINDOW is on is affected.
1981 This function tries to reduce display jumps
1982 by keeping the text previously visible in WINDOW
1983 in the same place on the frame. Doing this depends on
1984 the value of (window-start WINDOW), so if calling this function
1985 in a program gives strange scrolling, make sure the window-start
1986 value is reasonable when this function is called. */)
1995 window
= selected_window
;
1997 CHECK_LIVE_WINDOW (window
, 0);
1998 w
= XWINDOW (window
);
2000 startpos
= marker_position (w
->start
);
2001 top
= XFASTINT (w
->top
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2003 if (MINI_WINDOW_P (w
) && top
> 0)
2004 error ("Can't expand minibuffer to full frame");
2006 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
2008 /* Try to minimize scrolling, by setting the window start to the point
2009 will cause the text at the old window start to be at the same place
2010 on the frame. But don't try to do this if the window start is
2011 outside the visible portion (as might happen when the display is
2012 not current, due to typeahead). */
2013 new_top
= XFASTINT (w
->top
) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w
)));
2015 && startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
2016 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
2018 struct position pos
;
2019 struct buffer
*obuf
= current_buffer
;
2021 Fset_buffer (w
->buffer
);
2022 /* This computation used to temporarily move point, but that can
2023 have unwanted side effects due to text properties. */
2024 pos
= *vmotion (startpos
, -top
, w
);
2026 set_marker_both (w
->start
, w
->buffer
, pos
.bufpos
, pos
.bytepos
);
2027 w
->window_end_valid
= Qnil
;
2028 w
->start_at_line_beg
= ((pos
.bytepos
== BEGV_BYTE
2029 || FETCH_BYTE (pos
.bytepos
- 1) == '\n') ? Qt
2031 /* We need to do this, so that the window-scroll-functions
2033 w
->optional_new_start
= Qt
;
2035 set_buffer_internal (obuf
);
2041 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
2042 1, 2, "bDelete windows on (buffer): ",
2043 doc
: /* Delete all windows showing BUFFER.
2044 Optional second argument FRAME controls which frames are affected.
2045 If optional argument FRAME is `visible', search all visible frames.
2046 If FRAME is 0, search all visible and iconified frames.
2047 If FRAME is nil, search all frames.
2048 If FRAME is t, search only the selected frame.
2049 If FRAME is a frame, search only that frame. */)
2051 Lisp_Object buffer
, frame
;
2053 /* FRAME uses t and nil to mean the opposite of what window_loop
2057 else if (EQ (frame
, Qt
))
2062 buffer
= Fget_buffer (buffer
);
2063 CHECK_BUFFER (buffer
, 0);
2064 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
2070 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
2071 Sreplace_buffer_in_windows
,
2072 1, 1, "bReplace buffer in windows: ",
2073 doc
: /* Replace BUFFER with some other buffer in all windows showing it. */)
2079 buffer
= Fget_buffer (buffer
);
2080 CHECK_BUFFER (buffer
, 0);
2081 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
2086 /* Replace BUFFER with some other buffer in all windows
2087 of all frames, even those on other keyboards. */
2090 replace_buffer_in_all_windows (buffer
)
2094 Lisp_Object tail
, frame
;
2096 /* A single call to window_loop won't do the job
2097 because it only considers frames on the current keyboard.
2098 So loop manually over frames, and handle each one. */
2099 FOR_EACH_FRAME (tail
, frame
)
2100 window_loop (UNSHOW_BUFFER
, buffer
, 1, frame
);
2102 window_loop (UNSHOW_BUFFER
, buffer
, 1, Qt
);
2106 /* Set the height of WINDOW and all its inferiors. */
2108 /* The smallest acceptable dimensions for a window. Anything smaller
2109 might crash Emacs. */
2111 #define MIN_SAFE_WINDOW_WIDTH (2)
2112 #define MIN_SAFE_WINDOW_HEIGHT (2)
2114 /* Make sure that window_min_height and window_min_width are
2115 not too small; if they are, set them to safe minima. */
2118 check_min_window_sizes ()
2120 /* Smaller values might permit a crash. */
2121 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
2122 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
2123 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
2124 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
2127 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
2128 minimum allowable size. */
2131 check_frame_size (frame
, rows
, cols
)
2135 /* For height, we have to see:
2136 whether the frame has a minibuffer,
2137 whether it wants a mode line, and
2138 whether it has a menu bar. */
2140 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
2141 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
2142 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
2144 if (FRAME_TOP_MARGIN (frame
) > 0)
2145 min_height
+= FRAME_TOP_MARGIN (frame
);
2147 if (*rows
< min_height
)
2149 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
2150 *cols
= MIN_SAFE_WINDOW_WIDTH
;
2154 /* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
2155 check if W's width can be changed, otherwise check W's height.
2156 CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
2157 siblings, too. If none of the siblings is resizable, WINDOW isn't
2161 window_fixed_size_p (w
, width_p
, check_siblings_p
)
2163 int width_p
, check_siblings_p
;
2168 if (!NILP (w
->hchild
))
2170 c
= XWINDOW (w
->hchild
);
2174 /* A horiz. combination is fixed-width if all of if its
2176 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2177 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2178 fixed_p
= c
== NULL
;
2182 /* A horiz. combination is fixed-height if one of if its
2184 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2185 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2186 fixed_p
= c
!= NULL
;
2189 else if (!NILP (w
->vchild
))
2191 c
= XWINDOW (w
->vchild
);
2195 /* A vert. combination is fixed-width if one of if its
2197 while (c
&& !window_fixed_size_p (c
, width_p
, 0))
2198 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2199 fixed_p
= c
!= NULL
;
2203 /* A vert. combination is fixed-height if all of if its
2205 while (c
&& window_fixed_size_p (c
, width_p
, 0))
2206 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2207 fixed_p
= c
== NULL
;
2210 else if (BUFFERP (w
->buffer
))
2212 if (w
->height_fixed_p
&& !width_p
)
2216 struct buffer
*old
= current_buffer
;
2219 current_buffer
= XBUFFER (w
->buffer
);
2220 val
= find_symbol_value (Qwindow_size_fixed
);
2221 current_buffer
= old
;
2224 if (!EQ (val
, Qunbound
))
2226 fixed_p
= !NILP (val
);
2229 && ((EQ (val
, Qheight
) && width_p
)
2230 || (EQ (val
, Qwidth
) && !width_p
)))
2235 /* Can't tell if this one is resizable without looking at
2236 siblings. If all siblings are fixed-size this one is too. */
2237 if (!fixed_p
&& check_siblings_p
&& WINDOWP (w
->parent
))
2241 for (child
= w
->prev
; !NILP (child
); child
= XWINDOW (child
)->prev
)
2242 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2246 for (child
= w
->next
; !NILP (child
); child
= XWINDOW (child
)->next
)
2247 if (!window_fixed_size_p (XWINDOW (child
), width_p
, 0))
2261 /* Return the minimum size of window W, not taking fixed-width windows
2262 into account. WIDTH_P non-zero means return the minimum width,
2263 otherwise return the minimum height. If W is a combination window,
2264 compute the minimum size from the minimum sizes of W's children. */
2267 window_min_size_1 (w
, width_p
)
2274 if (!NILP (w
->hchild
))
2276 c
= XWINDOW (w
->hchild
);
2281 /* The min width of a horizontal combination is
2282 the sum of the min widths of its children. */
2285 size
+= window_min_size_1 (c
, width_p
);
2286 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2291 /* The min height a horizontal combination equals
2292 the maximum of all min height of its children. */
2295 int min_size
= window_min_size_1 (c
, width_p
);
2296 size
= max (min_size
, size
);
2297 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2301 else if (!NILP (w
->vchild
))
2303 c
= XWINDOW (w
->vchild
);
2308 /* The min width of a vertical combination is
2309 the maximum of the min widths of its children. */
2312 int min_size
= window_min_size_1 (c
, width_p
);
2313 size
= max (min_size
, size
);
2314 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2319 /* The min height of a vertical combination equals
2320 the sum of the min height of its children. */
2323 size
+= window_min_size_1 (c
, width_p
);
2324 c
= WINDOWP (c
->next
) ? XWINDOW (c
->next
) : NULL
;
2331 size
= window_min_width
;
2334 if (MINI_WINDOW_P (w
)
2335 || (!WINDOW_WANTS_MODELINE_P (w
)
2336 && !WINDOW_WANTS_HEADER_LINE_P (w
)))
2339 size
= window_min_height
;
2347 /* Return the minimum size of window W, taking fixed-size windows into
2348 account. WIDTH_P non-zero means return the minimum width,
2349 otherwise return the minimum height. IGNORE_FIXED_P non-zero means
2350 ignore if W is fixed-size. Set *FIXED to 1 if W is fixed-size
2351 unless FIXED is null. */
2354 window_min_size (w
, width_p
, ignore_fixed_p
, fixed
)
2356 int width_p
, ignore_fixed_p
, *fixed
;
2363 fixed_p
= window_fixed_size_p (w
, width_p
, 1);
2369 size
= width_p
? XFASTINT (w
->width
) : XFASTINT (w
->height
);
2371 size
= window_min_size_1 (w
, width_p
);
2377 /* Set WINDOW's height or width to SIZE. WIDTH_P non-zero means set
2378 WINDOW's width. Resize WINDOW's children, if any, so that they
2379 keep their proportionate size relative to WINDOW. Propagate
2380 WINDOW's top or left edge position to children. Delete windows
2381 that become too small unless NODELETE_P is non-zero. */
2384 size_window (window
, size
, width_p
, nodelete_p
)
2386 int size
, width_p
, nodelete_p
;
2388 struct window
*w
= XWINDOW (window
);
2390 Lisp_Object child
, *forward
, *sideward
;
2391 int old_size
, min_size
;
2393 check_min_window_sizes ();
2394 size
= max (0, size
);
2396 /* If the window has been "too small" at one point,
2397 don't delete it for being "too small" in the future.
2398 Preserve it as long as that is at all possible. */
2401 old_size
= XINT (w
->width
);
2402 min_size
= window_min_width
;
2406 old_size
= XINT (w
->height
);
2407 min_size
= window_min_height
;
2410 if (old_size
< min_size
)
2411 w
->too_small_ok
= Qt
;
2413 /* Maybe delete WINDOW if it's too small. */
2414 if (!nodelete_p
&& !NILP (w
->parent
))
2416 if (!MINI_WINDOW_P (w
) && !NILP (w
->too_small_ok
))
2417 min_size
= width_p
? MIN_SAFE_WINDOW_WIDTH
: MIN_SAFE_WINDOW_HEIGHT
;
2419 min_size
= width_p
? window_min_width
: window_min_height
;
2421 if (size
< min_size
)
2423 delete_window (window
);
2428 /* Set redisplay hints. */
2429 w
->last_modified
= make_number (0);
2430 w
->last_overlay_modified
= make_number (0);
2431 windows_or_buffers_changed
++;
2432 FRAME_WINDOW_SIZES_CHANGED (XFRAME (w
->frame
)) = 1;
2436 sideward
= &w
->vchild
;
2437 forward
= &w
->hchild
;
2438 w
->width
= make_number (size
);
2442 sideward
= &w
->hchild
;
2443 forward
= &w
->vchild
;
2444 w
->height
= make_number (size
);
2445 w
->orig_height
= Qnil
;
2448 if (!NILP (*sideward
))
2450 for (child
= *sideward
; !NILP (child
); child
= c
->next
)
2452 c
= XWINDOW (child
);
2457 size_window (child
, size
, width_p
, nodelete_p
);
2460 else if (!NILP (*forward
))
2462 int fixed_size
, each
, extra
, n
;
2463 int resize_fixed_p
, nfixed
;
2464 int last_pos
, first_pos
, nchildren
, total
;
2466 /* Determine the fixed-size portion of the this window, and the
2467 number of child windows. */
2468 fixed_size
= nchildren
= nfixed
= total
= 0;
2469 for (child
= *forward
; !NILP (child
); child
= c
->next
, ++nchildren
)
2473 c
= XWINDOW (child
);
2474 child_size
= width_p
? XINT (c
->width
) : XINT (c
->height
);
2475 total
+= child_size
;
2477 if (window_fixed_size_p (c
, width_p
, 0))
2479 fixed_size
+= child_size
;
2484 /* If the new size is smaller than fixed_size, or if there
2485 aren't any resizable windows, allow resizing fixed-size
2487 resize_fixed_p
= nfixed
== nchildren
|| size
< fixed_size
;
2489 /* Compute how many lines/columns to add to each child. The
2490 value of extra takes care of rounding errors. */
2491 n
= resize_fixed_p
? nchildren
: nchildren
- nfixed
;
2492 each
= (size
- total
) / n
;
2493 extra
= (size
- total
) - n
* each
;
2495 /* Compute new children heights and edge positions. */
2496 first_pos
= width_p
? XINT (w
->left
) : XINT (w
->top
);
2497 last_pos
= first_pos
;
2498 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2500 int new_size
, old_size
;
2502 c
= XWINDOW (child
);
2503 old_size
= width_p
? XFASTINT (c
->width
) : XFASTINT (c
->height
);
2504 new_size
= old_size
;
2506 /* The top or left edge position of this child equals the
2507 bottom or right edge of its predecessor. */
2509 c
->left
= make_number (last_pos
);
2511 c
->top
= make_number (last_pos
);
2513 /* If this child can be resized, do it. */
2514 if (resize_fixed_p
|| !window_fixed_size_p (c
, width_p
, 0))
2516 new_size
= old_size
+ each
+ extra
;
2520 /* Set new height. Note that size_window also propagates
2521 edge positions to children, so it's not a no-op if we
2522 didn't change the child's size. */
2523 size_window (child
, new_size
, width_p
, 1);
2525 /* Remember the bottom/right edge position of this child; it
2526 will be used to set the top/left edge of the next child. */
2527 last_pos
+= new_size
;
2530 /* We should have covered the parent exactly with child windows. */
2531 xassert (size
== last_pos
- first_pos
);
2533 /* Now delete any children that became too small. */
2535 for (child
= *forward
; !NILP (child
); child
= c
->next
)
2538 c
= XWINDOW (child
);
2539 child_size
= width_p
? XINT (c
->width
) : XINT (c
->height
);
2540 size_window (child
, child_size
, width_p
, 0);
2545 /* Set WINDOW's height to HEIGHT, and recursively change the height of
2546 WINDOW's children. NODELETE non-zero means don't delete windows
2547 that become too small in the process. (The caller should check
2548 later and do so if appropriate.) */
2551 set_window_height (window
, height
, nodelete
)
2556 size_window (window
, height
, 0, nodelete
);
2560 /* Set WINDOW's width to WIDTH, and recursively change the width of
2561 WINDOW's children. NODELETE non-zero means don't delete windows
2562 that become too small in the process. (The caller should check
2563 later and do so if appropriate.) */
2566 set_window_width (window
, width
, nodelete
)
2571 size_window (window
, width
, 1, nodelete
);
2575 int window_select_count
;
2578 Fset_window_buffer_unwind (obuf
)
2586 /* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero
2587 means it's allowed to run hooks. See make_frame for a case where
2588 it's not allowed. */
2591 set_window_buffer (window
, buffer
, run_hooks_p
)
2592 Lisp_Object window
, buffer
;
2595 struct window
*w
= XWINDOW (window
);
2596 struct buffer
*b
= XBUFFER (buffer
);
2597 int count
= specpdl_ptr
- specpdl
;
2601 if (EQ (window
, selected_window
))
2602 b
->last_selected_window
= window
;
2604 /* Update time stamps of buffer display. */
2605 if (INTEGERP (b
->display_count
))
2606 XSETINT (b
->display_count
, XINT (b
->display_count
) + 1);
2607 b
->display_time
= Fcurrent_time ();
2609 XSETFASTINT (w
->window_end_pos
, 0);
2610 XSETFASTINT (w
->window_end_vpos
, 0);
2611 bzero (&w
->last_cursor
, sizeof w
->last_cursor
);
2612 w
->window_end_valid
= Qnil
;
2613 w
->hscroll
= w
->min_hscroll
= make_number (0);
2615 set_marker_both (w
->pointm
, buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
2616 set_marker_restricted (w
->start
,
2617 make_number (b
->last_window_start
),
2619 w
->start_at_line_beg
= Qnil
;
2620 w
->force_start
= Qnil
;
2621 XSETFASTINT (w
->last_modified
, 0);
2622 XSETFASTINT (w
->last_overlay_modified
, 0);
2623 windows_or_buffers_changed
++;
2625 /* We must select BUFFER for running the window-scroll-functions.
2626 If WINDOW is selected, switch permanently.
2627 Otherwise, switch but go back to the ambient buffer afterward. */
2628 if (EQ (window
, selected_window
))
2629 Fset_buffer (buffer
);
2630 /* We can't check ! NILP (Vwindow_scroll_functions) here
2631 because that might itself be a local variable. */
2632 else if (window_initialized
)
2634 record_unwind_protect (Fset_window_buffer_unwind
, Fcurrent_buffer ());
2635 Fset_buffer (buffer
);
2638 /* Set left and right marginal area width from buffer. */
2639 Fset_window_margins (window
, b
->left_margin_width
, b
->right_margin_width
);
2643 if (! NILP (Vwindow_scroll_functions
))
2644 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2645 Fmarker_position (w
->start
));
2647 if (! NILP (Vwindow_configuration_change_hook
)
2648 && ! NILP (Vrun_hooks
))
2649 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
2652 unbind_to (count
, Qnil
);
2656 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
2657 doc
: /* Make WINDOW display BUFFER as its contents.
2658 BUFFER can be a buffer or buffer name. */)
2660 register Lisp_Object window
, buffer
;
2662 register Lisp_Object tem
;
2663 register struct window
*w
= decode_window (window
);
2665 XSETWINDOW (window
, w
);
2666 buffer
= Fget_buffer (buffer
);
2667 CHECK_BUFFER (buffer
, 1);
2669 if (NILP (XBUFFER (buffer
)->name
))
2670 error ("Attempt to display deleted buffer");
2674 error ("Window is deleted");
2675 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
2676 is first being set up. */
2678 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
2679 error ("Window is dedicated to `%s'",
2680 XSTRING (XBUFFER (tem
)->name
)->data
);
2685 set_window_buffer (window
, buffer
, 1);
2689 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
2690 doc
: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
2691 If WINDOW is not already selected, also make WINDOW's buffer current.
2692 Note that the main editor command loop
2693 selects the buffer of the selected window before each command. */)
2695 register Lisp_Object window
;
2697 return select_window_1 (window
, 1);
2700 /* Note that selected_window can be nil
2701 when this is called from Fset_window_configuration. */
2704 select_window_1 (window
, recordflag
)
2705 register Lisp_Object window
;
2708 register struct window
*w
;
2709 register struct window
*ow
;
2712 CHECK_LIVE_WINDOW (window
, 0);
2714 w
= XWINDOW (window
);
2715 w
->frozen_window_start_p
= 0;
2717 XSETFASTINT (w
->use_time
, ++window_select_count
);
2718 if (EQ (window
, selected_window
))
2721 if (!NILP (selected_window
))
2723 ow
= XWINDOW (selected_window
);
2724 if (! NILP (ow
->buffer
))
2725 set_marker_both (ow
->pointm
, ow
->buffer
,
2726 BUF_PT (XBUFFER (ow
->buffer
)),
2727 BUF_PT_BYTE (XBUFFER (ow
->buffer
)));
2730 selected_window
= window
;
2731 sf
= SELECTED_FRAME ();
2732 if (XFRAME (WINDOW_FRAME (w
)) != sf
)
2734 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
2735 /* Use this rather than Fhandle_switch_frame
2736 so that FRAME_FOCUS_FRAME is moved appropriately as we
2737 move around in the state where a minibuffer in a separate
2739 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
2742 sf
->selected_window
= window
;
2745 record_buffer (w
->buffer
);
2746 Fset_buffer (w
->buffer
);
2748 XBUFFER (w
->buffer
)->last_selected_window
= window
;
2750 /* Go to the point recorded in the window.
2751 This is important when the buffer is in more
2752 than one window. It also matters when
2753 redisplay_window has altered point after scrolling,
2754 because it makes the change only in the window. */
2756 register int new_point
= marker_position (w
->pointm
);
2757 if (new_point
< BEGV
)
2759 else if (new_point
> ZV
)
2765 windows_or_buffers_changed
++;
2769 /* Deiconify the frame containing the window WINDOW,
2770 unless it is the selected frame;
2773 The reason for the exception for the selected frame
2774 is that it seems better not to change the selected frames visibility
2775 merely because of displaying a different buffer in it.
2776 The deiconification is useful when a buffer gets shown in
2777 another frame that you were not using lately. */
2780 display_buffer_1 (window
)
2783 Lisp_Object frame
= XWINDOW (window
)->frame
;
2784 FRAME_PTR f
= XFRAME (frame
);
2786 FRAME_SAMPLE_VISIBILITY (f
);
2788 if (!EQ (frame
, selected_frame
))
2790 if (FRAME_ICONIFIED_P (f
))
2791 Fmake_frame_visible (frame
);
2792 else if (FRAME_VISIBLE_P (f
))
2793 Fraise_frame (frame
);
2799 DEFUN ("special-display-p", Fspecial_display_p
, Sspecial_display_p
, 1, 1, 0,
2800 doc
: /* Returns non-nil if a buffer named BUFFER-NAME would be created specially.
2801 The value is actually t if the frame should be called with default frame
2802 parameters, and a list of frame parameters if they were specified.
2803 See `special-display-buffer-names', and `special-display-regexps'. */)
2805 Lisp_Object buffer_name
;
2809 CHECK_STRING (buffer_name
, 1);
2811 tem
= Fmember (buffer_name
, Vspecial_display_buffer_names
);
2815 tem
= Fassoc (buffer_name
, Vspecial_display_buffer_names
);
2819 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2821 Lisp_Object car
= XCAR (tem
);
2823 && fast_string_match (car
, buffer_name
) >= 0)
2825 else if (CONSP (car
)
2826 && STRINGP (XCAR (car
))
2827 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2833 DEFUN ("same-window-p", Fsame_window_p
, Ssame_window_p
, 1, 1, 0,
2834 doc
: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
2835 See `same-window-buffer-names' and `same-window-regexps'. */)
2837 Lisp_Object buffer_name
;
2841 CHECK_STRING (buffer_name
, 1);
2843 tem
= Fmember (buffer_name
, Vsame_window_buffer_names
);
2847 tem
= Fassoc (buffer_name
, Vsame_window_buffer_names
);
2851 for (tem
= Vsame_window_regexps
; CONSP (tem
); tem
= XCDR (tem
))
2853 Lisp_Object car
= XCAR (tem
);
2855 && fast_string_match (car
, buffer_name
) >= 0)
2857 else if (CONSP (car
)
2858 && STRINGP (XCAR (car
))
2859 && fast_string_match (XCAR (car
), buffer_name
) >= 0)
2865 /* Use B so the default is (other-buffer). */
2866 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 3,
2867 "BDisplay buffer: \nP",
2868 doc
: /* Make BUFFER appear in some window but don't select it.
2869 BUFFER can be a buffer or a buffer name.
2870 If BUFFER is shown already in some window, just use that one,
2871 unless the window is the selected window and the optional second
2872 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
2873 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
2874 Returns the window displaying BUFFER.
2875 If `display-reuse-frames' is non-nil, and another frame is currently
2876 displaying BUFFER, then simply raise that frame.
2878 The variables `special-display-buffer-names', `special-display-regexps',
2879 `same-window-buffer-names', and `same-window-regexps' customize how certain
2880 buffer names are handled.
2882 If optional argument FRAME is `visible', search all visible frames.
2883 If FRAME is 0, search all visible and iconified frames.
2884 If FRAME is t, search all frames.
2885 If FRAME is a frame, search only that frame.
2886 If FRAME is nil, search only the selected frame
2887 (actually the last nonminibuffer frame),
2888 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
2889 which means search visible and iconified frames.
2891 If `even-window-heights' is non-nil, window heights will be evened out
2892 if displaying the buffer causes two vertically adjacent windows to be
2894 (buffer
, not_this_window
, frame
)
2895 register Lisp_Object buffer
, not_this_window
, frame
;
2897 register Lisp_Object window
, tem
, swp
;
2901 buffer
= Fget_buffer (buffer
);
2902 CHECK_BUFFER (buffer
, 0);
2904 if (!NILP (Vdisplay_buffer_function
))
2905 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
2907 if (NILP (not_this_window
)
2908 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
2909 return display_buffer_1 (selected_window
);
2911 /* See if the user has specified this buffer should appear
2912 in the selected window. */
2913 if (NILP (not_this_window
))
2915 swp
= Fsame_window_p (XBUFFER (buffer
)->name
);
2916 if (!NILP (swp
) && !no_switch_window (selected_window
))
2918 Fswitch_to_buffer (buffer
, Qnil
);
2919 return display_buffer_1 (selected_window
);
2923 /* If the user wants pop-up-frames or display-reuse-frames, then
2924 look for a window showing BUFFER on any visible or iconified frame.
2925 Otherwise search only the current frame. */
2928 else if (pop_up_frames
2929 || display_buffer_reuse_frames
2930 || last_nonminibuf_frame
== 0)
2931 XSETFASTINT (tem
, 0);
2933 XSETFRAME (tem
, last_nonminibuf_frame
);
2935 window
= Fget_buffer_window (buffer
, tem
);
2937 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
2938 return display_buffer_1 (window
);
2940 /* Certain buffer names get special handling. */
2941 if (!NILP (Vspecial_display_function
) && NILP (swp
))
2943 tem
= Fspecial_display_p (XBUFFER (buffer
)->name
);
2945 return call1 (Vspecial_display_function
, buffer
);
2947 return call2 (Vspecial_display_function
, buffer
, tem
);
2950 /* If there are no frames open that have more than a minibuffer,
2951 we need to create a new frame. */
2952 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
2954 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
2955 Fset_window_buffer (window
, buffer
);
2956 return display_buffer_1 (window
);
2959 f
= SELECTED_FRAME ();
2961 || FRAME_MINIBUF_ONLY_P (f
)
2962 /* If the current frame is a special display frame,
2963 don't try to reuse its windows. */
2964 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (f
))->dedicated
))
2969 if (FRAME_MINIBUF_ONLY_P (f
))
2970 XSETFRAME (frames
, last_nonminibuf_frame
);
2971 /* Don't try to create a window if would get an error */
2972 if (split_height_threshold
< window_min_height
<< 1)
2973 split_height_threshold
= window_min_height
<< 1;
2975 /* Note that both Fget_largest_window and Fget_lru_window
2976 ignore minibuffers and dedicated windows.
2977 This means they can return nil. */
2979 /* If the frame we would try to split cannot be split,
2980 try other frames. */
2981 if (FRAME_NO_SPLIT_P (NILP (frames
) ? f
: last_nonminibuf_frame
))
2983 /* Try visible frames first. */
2984 window
= Fget_largest_window (Qvisible
);
2985 /* If that didn't work, try iconified frames. */
2987 window
= Fget_largest_window (make_number (0));
2989 window
= Fget_largest_window (Qt
);
2992 window
= Fget_largest_window (frames
);
2994 /* If we got a tall enough full-width window that can be split,
2997 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
2998 && window_height (window
) >= split_height_threshold
2999 && WINDOW_FULL_WIDTH_P (XWINDOW (window
)))
3000 window
= Fsplit_window (window
, Qnil
, Qnil
);
3003 Lisp_Object upper
, lower
, other
;
3005 window
= Fget_lru_window (frames
);
3006 /* If the LRU window is selected, and big enough,
3007 and can be split, split it. */
3009 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
3010 && (EQ (window
, selected_window
)
3011 || EQ (XWINDOW (window
)->parent
, Qnil
))
3012 && window_height (window
) >= window_min_height
<< 1)
3013 window
= Fsplit_window (window
, Qnil
, Qnil
);
3014 /* If Fget_lru_window returned nil, try other approaches. */
3016 /* Try visible frames first. */
3018 window
= Fget_buffer_window (buffer
, Qvisible
);
3020 window
= Fget_largest_window (Qvisible
);
3021 /* If that didn't work, try iconified frames. */
3023 window
= Fget_buffer_window (buffer
, make_number (0));
3025 window
= Fget_largest_window (make_number (0));
3026 /* Try invisible frames. */
3028 window
= Fget_buffer_window (buffer
, Qt
);
3030 window
= Fget_largest_window (Qt
);
3031 /* As a last resort, make a new frame. */
3033 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
3034 /* If window appears above or below another,
3035 even out their heights. */
3036 other
= upper
= lower
= Qnil
;
3037 if (!NILP (XWINDOW (window
)->prev
))
3038 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
3039 if (!NILP (XWINDOW (window
)->next
))
3040 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
3042 && !NILP (Veven_window_heights
)
3043 /* Check that OTHER and WINDOW are vertically arrayed. */
3044 && !EQ (XWINDOW (other
)->top
, XWINDOW (window
)->top
)
3045 && (XFASTINT (XWINDOW (other
)->height
)
3046 > XFASTINT (XWINDOW (window
)->height
)))
3048 int total
= (XFASTINT (XWINDOW (other
)->height
)
3049 + XFASTINT (XWINDOW (window
)->height
));
3050 enlarge_window (upper
,
3051 total
/ 2 - XFASTINT (XWINDOW (upper
)->height
),
3057 window
= Fget_lru_window (Qnil
);
3059 Fset_window_buffer (window
, buffer
);
3060 return display_buffer_1 (window
);
3064 temp_output_buffer_show (buf
)
3065 register Lisp_Object buf
;
3067 register struct buffer
*old
= current_buffer
;
3068 register Lisp_Object window
;
3069 register struct window
*w
;
3071 XBUFFER (buf
)->directory
= current_buffer
->directory
;
3074 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
3078 XBUFFER (buf
)->prevent_redisplay_optimizations_p
= 1;
3079 set_buffer_internal (old
);
3081 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
3082 call1 (Vtemp_buffer_show_function
, buf
);
3085 window
= Fdisplay_buffer (buf
, Qnil
, Qnil
);
3087 if (!EQ (XWINDOW (window
)->frame
, selected_frame
))
3088 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
3089 Vminibuf_scroll_window
= window
;
3090 w
= XWINDOW (window
);
3091 XSETFASTINT (w
->hscroll
, 0);
3092 XSETFASTINT (w
->min_hscroll
, 0);
3093 set_marker_restricted_both (w
->start
, buf
, 1, 1);
3094 set_marker_restricted_both (w
->pointm
, buf
, 1, 1);
3096 /* Run temp-buffer-show-hook, with the chosen window selected
3097 and it sbuffer current. */
3098 if (!NILP (Vrun_hooks
))
3101 tem
= Fboundp (Qtemp_buffer_show_hook
);
3104 tem
= Fsymbol_value (Qtemp_buffer_show_hook
);
3107 int count
= specpdl_ptr
- specpdl
;
3108 Lisp_Object prev_window
;
3109 prev_window
= selected_window
;
3111 /* Select the window that was chosen, for running the hook. */
3112 record_unwind_protect (Fselect_window
, prev_window
);
3113 select_window_1 (window
, 0);
3114 Fset_buffer (w
->buffer
);
3115 call1 (Vrun_hooks
, Qtemp_buffer_show_hook
);
3116 select_window_1 (prev_window
, 0);
3117 unbind_to (count
, Qnil
);
3125 make_dummy_parent (window
)
3129 register struct window
*o
, *p
;
3132 o
= XWINDOW (window
);
3133 p
= allocate_window ();
3134 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
3135 ((struct Lisp_Vector
*) p
)->contents
[i
]
3136 = ((struct Lisp_Vector
*)o
)->contents
[i
];
3137 XSETWINDOW (new, p
);
3139 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
3141 /* Put new into window structure in place of window */
3142 replace_window (window
, new);
3155 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
3156 doc
: /* Split WINDOW, putting SIZE lines in the first of the pair.
3157 WINDOW defaults to selected one and SIZE to half its size.
3158 If optional third arg HORFLAG is non-nil, split side by side
3159 and put SIZE columns in the first of the pair. In that case,
3160 SIZE includes that window's scroll bar, or the divider column to its right. */)
3161 (window
, size
, horflag
)
3162 Lisp_Object window
, size
, horflag
;
3164 register Lisp_Object
new;
3165 register struct window
*o
, *p
;
3167 register int size_int
;
3170 window
= selected_window
;
3172 CHECK_LIVE_WINDOW (window
, 0);
3174 o
= XWINDOW (window
);
3175 fo
= XFRAME (WINDOW_FRAME (o
));
3179 if (!NILP (horflag
))
3180 /* Calculate the size of the left-hand window, by dividing
3181 the usable space in columns by two.
3182 We round up, since the left-hand window may include
3183 a dividing line, while the right-hand may not. */
3184 size_int
= (XFASTINT (o
->width
) + 1) >> 1;
3186 size_int
= XFASTINT (o
->height
) >> 1;
3190 CHECK_NUMBER (size
, 1);
3191 size_int
= XINT (size
);
3194 if (MINI_WINDOW_P (o
))
3195 error ("Attempt to split minibuffer window");
3196 else if (window_fixed_size_p (o
, !NILP (horflag
), 0))
3197 error ("Attempt to split fixed-size window");
3199 check_min_window_sizes ();
3203 if (size_int
< window_min_height
)
3204 error ("Window height %d too small (after splitting)", size_int
);
3205 if (size_int
+ window_min_height
> XFASTINT (o
->height
))
3206 error ("Window height %d too small (after splitting)",
3207 XFASTINT (o
->height
) - size_int
);
3208 if (NILP (o
->parent
)
3209 || NILP (XWINDOW (o
->parent
)->vchild
))
3211 make_dummy_parent (window
);
3213 XWINDOW (new)->vchild
= window
;
3218 if (size_int
< window_min_width
)
3219 error ("Window width %d too small (after splitting)", size_int
);
3221 if (size_int
+ window_min_width
> XFASTINT (o
->width
))
3222 error ("Window width %d too small (after splitting)",
3223 XFASTINT (o
->width
) - size_int
);
3224 if (NILP (o
->parent
)
3225 || NILP (XWINDOW (o
->parent
)->hchild
))
3227 make_dummy_parent (window
);
3229 XWINDOW (new)->hchild
= window
;
3233 /* Now we know that window's parent is a vertical combination
3234 if we are dividing vertically, or a horizontal combination
3235 if we are making side-by-side windows */
3237 windows_or_buffers_changed
++;
3238 FRAME_WINDOW_SIZES_CHANGED (fo
) = 1;
3239 new = make_window ();
3242 p
->frame
= o
->frame
;
3244 if (!NILP (p
->next
))
3245 XWINDOW (p
->next
)->prev
= new;
3248 p
->parent
= o
->parent
;
3250 p
->window_end_valid
= Qnil
;
3251 bzero (&p
->last_cursor
, sizeof p
->last_cursor
);
3253 /* Apportion the available frame space among the two new windows */
3255 if (!NILP (horflag
))
3257 p
->height
= o
->height
;
3259 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size_int
);
3260 XSETFASTINT (o
->width
, size_int
);
3261 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size_int
);
3266 p
->width
= o
->width
;
3267 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size_int
);
3268 XSETFASTINT (o
->height
, size_int
);
3269 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size_int
);
3272 /* Adjust glyph matrices. */
3274 Fset_window_buffer (new, o
->buffer
);
3278 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
3279 doc
: /* Make current window ARG lines bigger.
3280 From program, optional second arg non-nil means grow sideways ARG columns.
3281 Interactively, if an argument is not given, make the window one line bigger. */)
3283 register Lisp_Object arg
, side
;
3285 CHECK_NUMBER (arg
, 0);
3286 enlarge_window (selected_window
, XINT (arg
), !NILP (side
));
3288 if (! NILP (Vwindow_configuration_change_hook
))
3289 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3294 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
3295 doc
: /* Make current window ARG lines smaller.
3296 From program, optional second arg non-nil means shrink sideways arg columns.
3297 Interactively, if an argument is not given, make the window one line smaller. */)
3299 register Lisp_Object arg
, side
;
3301 CHECK_NUMBER (arg
, 0);
3302 enlarge_window (selected_window
, -XINT (arg
), !NILP (side
));
3304 if (! NILP (Vwindow_configuration_change_hook
))
3305 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
3311 window_height (window
)
3314 register struct window
*p
= XWINDOW (window
);
3315 return XFASTINT (p
->height
);
3319 window_width (window
)
3322 register struct window
*p
= XWINDOW (window
);
3323 return XFASTINT (p
->width
);
3328 *(widthflag ? &(XWINDOW (w)->left) : &(XWINDOW (w)->top))
3330 #define CURSIZE(w) \
3331 *(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
3334 /* Enlarge selected_window by DELTA. WIDTHFLAG non-zero means
3335 increase its width. Siblings of the selected window are resized to
3336 fullfil the size request. If they become too small in the process,
3337 they will be deleted. */
3340 enlarge_window (window
, delta
, widthflag
)
3342 int delta
, widthflag
;
3344 Lisp_Object parent
, next
, prev
;
3348 int (*sizefun
) P_ ((Lisp_Object
))
3349 = widthflag
? window_width
: window_height
;
3350 void (*setsizefun
) P_ ((Lisp_Object
, int, int))
3351 = (widthflag
? set_window_width
: set_window_height
);
3353 /* Check values of window_min_width and window_min_height for
3355 check_min_window_sizes ();
3357 /* Give up if this window cannot be resized. */
3358 if (window_fixed_size_p (XWINDOW (window
), widthflag
, 1))
3359 error ("Window is not resizable");
3361 /* Find the parent of the selected window. */
3364 p
= XWINDOW (window
);
3370 error ("No other window to side of this one");
3375 ? !NILP (XWINDOW (parent
)->hchild
)
3376 : !NILP (XWINDOW (parent
)->vchild
))
3382 sizep
= &CURSIZE (window
);
3385 register int maxdelta
;
3387 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - XINT (*sizep
)
3388 : !NILP (p
->next
) ? ((*sizefun
) (p
->next
)
3389 - window_min_size (XWINDOW (p
->next
),
3391 : !NILP (p
->prev
) ? ((*sizefun
) (p
->prev
)
3392 - window_min_size (XWINDOW (p
->prev
),
3394 /* This is a frame with only one window, a minibuffer-only
3395 or a minibufferless frame. */
3398 if (delta
> maxdelta
)
3399 /* This case traps trying to make the minibuffer
3400 the full frame, or make the only window aside from the
3401 minibuffer the full frame. */
3405 if (XINT (*sizep
) + delta
< window_min_size (XWINDOW (window
), widthflag
, 0, 0))
3407 delete_window (window
);
3414 /* Find the total we can get from other siblings. */
3416 for (next
= p
->next
; ! NILP (next
); next
= XWINDOW (next
)->next
)
3417 maximum
+= (*sizefun
) (next
) - window_min_size (XWINDOW (next
),
3419 for (prev
= p
->prev
; ! NILP (prev
); prev
= XWINDOW (prev
)->prev
)
3420 maximum
+= (*sizefun
) (prev
) - window_min_size (XWINDOW (prev
),
3423 /* If we can get it all from them, do so. */
3424 if (delta
<= maximum
)
3426 Lisp_Object first_unaffected
;
3427 Lisp_Object first_affected
;
3432 first_affected
= window
;
3433 /* Look at one sibling at a time,
3434 moving away from this window in both directions alternately,
3435 and take as much as we can get without deleting that sibling. */
3436 while (delta
!= 0 && (!NILP (next
) || !NILP (prev
)))
3440 int this_one
= ((*sizefun
) (next
)
3441 - window_min_size (XWINDOW (next
),
3442 widthflag
, 0, &fixed_p
));
3445 if (this_one
> delta
)
3448 (*setsizefun
) (next
, (*sizefun
) (next
) - this_one
, 0);
3449 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3454 next
= XWINDOW (next
)->next
;
3462 int this_one
= ((*sizefun
) (prev
)
3463 - window_min_size (XWINDOW (prev
),
3464 widthflag
, 0, &fixed_p
));
3467 if (this_one
> delta
)
3470 first_affected
= prev
;
3472 (*setsizefun
) (prev
, (*sizefun
) (prev
) - this_one
, 0);
3473 (*setsizefun
) (window
, XINT (*sizep
) + this_one
, 0);
3478 prev
= XWINDOW (prev
)->prev
;
3482 xassert (delta
== 0);
3484 /* Now recalculate the edge positions of all the windows affected,
3485 based on the new sizes. */
3486 first_unaffected
= next
;
3487 prev
= first_affected
;
3488 for (next
= XWINDOW (prev
)->next
; ! EQ (next
, first_unaffected
);
3489 prev
= next
, next
= XWINDOW (next
)->next
)
3491 XSETINT (CURBEG (next
), XINT (CURBEG (prev
)) + (*sizefun
) (prev
));
3492 /* This does not change size of NEXT,
3493 but it propagates the new top edge to its children */
3494 (*setsizefun
) (next
, (*sizefun
) (next
), 0);
3499 register int delta1
;
3500 register int opht
= (*sizefun
) (parent
);
3502 /* If trying to grow this window to or beyond size of the parent,
3503 make delta1 so big that, on shrinking back down,
3504 all the siblings end up with less than one line and are deleted. */
3505 if (opht
<= XINT (*sizep
) + delta
)
3506 delta1
= opht
* opht
* 2;
3509 /* Otherwise, make delta1 just right so that if we add
3510 delta1 lines to this window and to the parent, and then
3511 shrink the parent back to its original size, the new
3512 proportional size of this window will increase by delta.
3514 The function size_window will compute the new height h'
3515 of the window from delta1 as:
3518 x = delta1 - delta1/n * n for the 1st resizable child
3521 where n is the number of children that can be resized.
3522 We can ignore x by choosing a delta1 that is a multiple of
3523 n. We want the height of this window to come out as
3533 The number of children n rquals the number of resizable
3534 children of this window + 1 because we know window itself
3535 is resizable (otherwise we would have signalled an error. */
3537 struct window
*w
= XWINDOW (window
);
3541 for (s
= w
->next
; !NILP (s
); s
= XWINDOW (s
)->next
)
3542 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
3544 for (s
= w
->prev
; !NILP (s
); s
= XWINDOW (s
)->prev
)
3545 if (!window_fixed_size_p (XWINDOW (s
), widthflag
, 0))
3551 /* Add delta1 lines or columns to this window, and to the parent,
3552 keeping things consistent while not affecting siblings. */
3553 XSETINT (CURSIZE (parent
), opht
+ delta1
);
3554 (*setsizefun
) (window
, XINT (*sizep
) + delta1
, 0);
3556 /* Squeeze out delta1 lines or columns from our parent,
3557 shriking this window and siblings proportionately.
3558 This brings parent back to correct size.
3559 Delta1 was calculated so this makes this window the desired size,
3560 taking it all out of the siblings. */
3561 (*setsizefun
) (parent
, opht
, 0);
3564 XSETFASTINT (p
->last_modified
, 0);
3565 XSETFASTINT (p
->last_overlay_modified
, 0);
3567 /* Adjust glyph matrices. */
3568 adjust_glyphs (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
3576 /***********************************************************************
3577 Resizing Mini-Windows
3578 ***********************************************************************/
3580 static void shrink_window_lowest_first
P_ ((struct window
*, int));
3582 enum save_restore_action
3589 static int save_restore_orig_size
P_ ((struct window
*,
3590 enum save_restore_action
));
3592 /* Shrink windows rooted in window W to HEIGHT. Take the space needed
3593 from lowest windows first. */
3596 shrink_window_lowest_first (w
, height
)
3604 xassert (!MINI_WINDOW_P (w
));
3606 /* Set redisplay hints. */
3607 XSETFASTINT (w
->last_modified
, 0);
3608 XSETFASTINT (w
->last_overlay_modified
, 0);
3609 windows_or_buffers_changed
++;
3610 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w
))) = 1;
3612 old_height
= XFASTINT (w
->height
);
3613 XSETFASTINT (w
->height
, height
);
3615 if (!NILP (w
->hchild
))
3617 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
3619 c
= XWINDOW (child
);
3621 shrink_window_lowest_first (c
, height
);
3624 else if (!NILP (w
->vchild
))
3626 Lisp_Object last_child
;
3627 int delta
= old_height
- height
;
3632 /* Find the last child. We are taking space from lowest windows
3633 first, so we iterate over children from the last child
3635 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
3638 /* Assign new heights. We leave only MIN_SAFE_WINDOW_HEIGHT. */
3639 for (child
= last_child
; delta
&& !NILP (child
); child
= c
->prev
)
3643 c
= XWINDOW (child
);
3644 this_one
= XFASTINT (c
->height
) - MIN_SAFE_WINDOW_HEIGHT
;
3646 if (this_one
> delta
)
3649 shrink_window_lowest_first (c
, XFASTINT (c
->height
) - this_one
);
3653 /* Compute new positions. */
3654 last_top
= XINT (w
->top
);
3655 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
3657 c
= XWINDOW (child
);
3658 c
->top
= make_number (last_top
);
3659 shrink_window_lowest_first (c
, XFASTINT (c
->height
));
3660 last_top
+= XFASTINT (c
->height
);
3666 /* Save, restore, or check positions and sizes in the window tree
3667 rooted at W. ACTION says what to do.
3669 If ACTION is CHECK_ORIG_SIZES, check if orig_top and orig_height
3670 members are valid for all windows in the window tree. Value is
3671 non-zero if they are valid.
3673 If ACTION is SAVE_ORIG_SIZES, save members top and height in
3674 orig_top and orig_height for all windows in the tree.
3676 If ACTION is RESTORE_ORIG_SIZES, restore top and height from
3677 values stored in orig_top and orig_height for all windows. */
3680 save_restore_orig_size (w
, action
)
3682 enum save_restore_action action
;
3688 if (!NILP (w
->hchild
))
3690 if (!save_restore_orig_size (XWINDOW (w
->hchild
), action
))
3693 else if (!NILP (w
->vchild
))
3695 if (!save_restore_orig_size (XWINDOW (w
->vchild
), action
))
3701 case CHECK_ORIG_SIZES
:
3702 if (!INTEGERP (w
->orig_top
) || !INTEGERP (w
->orig_height
))
3706 case SAVE_ORIG_SIZES
:
3707 w
->orig_top
= w
->top
;
3708 w
->orig_height
= w
->height
;
3709 XSETFASTINT (w
->last_modified
, 0);
3710 XSETFASTINT (w
->last_overlay_modified
, 0);
3713 case RESTORE_ORIG_SIZES
:
3714 xassert (INTEGERP (w
->orig_top
) && INTEGERP (w
->orig_height
));
3715 w
->top
= w
->orig_top
;
3716 w
->height
= w
->orig_height
;
3717 w
->orig_height
= w
->orig_top
= Qnil
;
3718 XSETFASTINT (w
->last_modified
, 0);
3719 XSETFASTINT (w
->last_overlay_modified
, 0);
3726 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
3733 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we can
3734 without deleting other windows. */
3737 grow_mini_window (w
, delta
)
3741 struct frame
*f
= XFRAME (w
->frame
);
3742 struct window
*root
;
3744 xassert (MINI_WINDOW_P (w
));
3745 xassert (delta
>= 0);
3747 /* Check values of window_min_width and window_min_height for
3749 check_min_window_sizes ();
3751 /* Compute how much we can enlarge the mini-window without deleting
3753 root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3756 int min_height
= window_min_size (root
, 0, 0, 0);
3757 if (XFASTINT (root
->height
) - delta
< min_height
)
3758 delta
= XFASTINT (root
->height
) - min_height
;
3763 /* Save original window sizes and positions, if not already done. */
3764 if (!save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
3765 save_restore_orig_size (root
, SAVE_ORIG_SIZES
);
3767 /* Shrink other windows. */
3768 shrink_window_lowest_first (root
, XFASTINT (root
->height
) - delta
);
3770 /* Grow the mini-window. */
3771 w
->top
= make_number (XFASTINT (root
->top
) + XFASTINT (root
->height
));
3772 w
->height
= make_number (XFASTINT (w
->height
) + delta
);
3773 XSETFASTINT (w
->last_modified
, 0);
3774 XSETFASTINT (w
->last_overlay_modified
, 0);
3781 /* Shrink mini-window W. If there is recorded info about window sizes
3782 before a call to grow_mini_window, restore recorded window sizes.
3783 Otherwise, if the mini-window is higher than 1 line, resize it to 1
3787 shrink_mini_window (w
)
3790 struct frame
*f
= XFRAME (w
->frame
);
3791 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3793 if (save_restore_orig_size (root
, CHECK_ORIG_SIZES
))
3795 save_restore_orig_size (root
, RESTORE_ORIG_SIZES
);
3797 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
3798 windows_or_buffers_changed
= 1;
3800 else if (XFASTINT (w
->height
) > 1)
3802 /* Distribute the additional lines of the mini-window
3803 among the other windows. */
3805 XSETWINDOW (window
, w
);
3806 enlarge_window (window
, 1 - XFASTINT (w
->height
), 0);
3812 /* Mark window cursors off for all windows in the window tree rooted
3813 at W by setting their phys_cursor_on_p flag to zero. Called from
3814 xterm.c, e.g. when a frame is cleared and thereby all cursors on
3815 the frame are cleared. */
3818 mark_window_cursors_off (w
)
3823 if (!NILP (w
->hchild
))
3824 mark_window_cursors_off (XWINDOW (w
->hchild
));
3825 else if (!NILP (w
->vchild
))
3826 mark_window_cursors_off (XWINDOW (w
->vchild
));
3828 w
->phys_cursor_on_p
= 0;
3830 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3835 /* Return number of lines of text (not counting mode lines) in W. */
3838 window_internal_height (w
)
3841 int ht
= XFASTINT (w
->height
);
3843 if (!MINI_WINDOW_P (w
))
3845 if (!NILP (w
->parent
)
3846 || !NILP (w
->vchild
)
3847 || !NILP (w
->hchild
)
3850 || WINDOW_WANTS_MODELINE_P (w
))
3853 if (WINDOW_WANTS_HEADER_LINE_P (w
))
3861 /* Return the number of columns in W.
3862 Don't count columns occupied by scroll bars or the vertical bar
3863 separating W from the sibling to its right. */
3866 window_internal_width (w
)
3869 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3870 int width
= XINT (w
->width
);
3872 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3873 /* Scroll bars occupy a few columns. */
3874 width
-= FRAME_SCROLL_BAR_COLS (f
);
3875 else if (!WINDOW_RIGHTMOST_P (w
) && !WINDOW_FULL_WIDTH_P (w
))
3876 /* The column of `|' characters separating side-by-side windows
3877 occupies one column only. */
3880 /* On window-systems, areas to the left and right of the window
3881 are used to display bitmaps there. */
3882 if (FRAME_WINDOW_P (f
))
3883 width
-= FRAME_FLAGS_AREA_COLS (f
);
3889 /************************************************************************
3891 ***********************************************************************/
3893 /* Scroll contents of window WINDOW up. If WHOLE is non-zero, scroll
3894 N screen-fulls, which is defined as the height of the window minus
3895 next_screen_context_lines. If WHOLE is zero, scroll up N lines
3896 instead. Negative values of N mean scroll down. NOERROR non-zero
3897 means don't signal an error if we try to move over BEGV or ZV,
3901 window_scroll (window
, n
, whole
, noerror
)
3907 /* If we must, use the pixel-based version which is much slower than
3908 the line-based one but can handle varying line heights. */
3909 if (FRAME_WINDOW_P (XFRAME (XWINDOW (window
)->frame
)))
3910 window_scroll_pixel_based (window
, n
, whole
, noerror
);
3912 window_scroll_line_based (window
, n
, whole
, noerror
);
3916 /* Implementation of window_scroll that works based on pixel line
3917 heights. See the comment of window_scroll for parameter
3921 window_scroll_pixel_based (window
, n
, whole
, noerror
)
3928 struct window
*w
= XWINDOW (window
);
3929 struct text_pos start
;
3931 int this_scroll_margin
;
3933 /* True if we fiddled the window vscroll field without really scrolling. */
3936 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
3938 /* If PT is not visible in WINDOW, move back one half of
3939 the screen. Allow PT to be partially visible, otherwise
3940 something like (scroll-down 1) with PT in the line before
3941 the partially visible one would recenter. */
3942 tem
= Fpos_visible_in_window_p (make_number (PT
), window
, Qt
);
3945 /* Move backward half the height of the window. Performance note:
3946 vmotion used here is about 10% faster, but would give wrong
3947 results for variable height lines. */
3948 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
3949 it
.current_y
= it
.last_visible_y
;
3950 move_it_vertically (&it
, - window_box_height (w
) / 2);
3952 /* The function move_iterator_vertically may move over more than
3953 the specified y-distance. If it->w is small, e.g. a
3954 mini-buffer window, we may end up in front of the window's
3955 display area. This is the case when Start displaying at the
3956 start of the line containing PT in this case. */
3957 if (it
.current_y
<= 0)
3959 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
3960 move_it_vertically (&it
, 0);
3964 start
= it
.current
.pos
;
3967 /* If scroll_preserve_screen_position is non-zero, we try to set
3968 point in the same window line as it is now, so get that line. */
3969 if (!NILP (Vscroll_preserve_screen_position
))
3971 start_display (&it
, w
, start
);
3972 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
3973 preserve_y
= it
.current_y
;
3978 /* Move iterator it from start the specified distance forward or
3979 backward. The result is the new window start. */
3980 start_display (&it
, w
, start
);
3983 int screen_full
= (window_box_height (w
)
3984 - next_screen_context_lines
* CANON_Y_UNIT (it
.f
));
3985 int dy
= n
* screen_full
;
3987 /* Note that move_it_vertically always moves the iterator to the
3988 start of a line. So, if the last line doesn't have a newline,
3989 we would end up at the start of the line ending at ZV. */
3991 move_it_vertically_backward (&it
, -dy
);
3993 move_it_to (&it
, ZV
, -1, it
.current_y
+ dy
, -1,
3994 MOVE_TO_POS
| MOVE_TO_Y
);
3997 move_it_by_lines (&it
, n
, 1);
3999 /* End if we end up at ZV or BEGV. */
4000 if ((n
> 0 && IT_CHARPOS (it
) == ZV
)
4001 || (n
< 0 && IT_CHARPOS (it
) == CHARPOS (start
)))
4003 if (IT_CHARPOS (it
) == ZV
)
4005 if (it
.current_y
+ it
.max_ascent
+ it
.max_descent
4006 > it
.last_visible_y
)
4008 /* The last line was only partially visible, make it fully
4010 w
->vscroll
= (it
.last_visible_y
4011 - it
.current_y
+ it
.max_ascent
+ it
.max_descent
);
4012 adjust_glyphs (it
.f
);
4017 Fsignal (Qend_of_buffer
, Qnil
);
4021 if (w
->vscroll
!= 0)
4022 /* The first line was only partially visible, make it fully
4028 Fsignal (Qbeginning_of_buffer
, Qnil
);
4031 /* If control gets here, then we vscrolled. */
4033 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
4035 /* Don't try to change the window start below. */
4041 /* Set the window start, and set up the window for redisplay. */
4042 set_marker_restricted (w
->start
, make_number (IT_CHARPOS (it
)),
4044 w
->start_at_line_beg
= Fbolp ();
4045 w
->update_mode_line
= Qt
;
4046 XSETFASTINT (w
->last_modified
, 0);
4047 XSETFASTINT (w
->last_overlay_modified
, 0);
4048 /* Set force_start so that redisplay_window will run the
4049 window-scroll-functions. */
4050 w
->force_start
= Qt
;
4053 it
.current_y
= it
.vpos
= 0;
4055 /* Preserve the screen position if we must. */
4056 if (preserve_y
>= 0)
4058 move_it_to (&it
, -1, -1, preserve_y
, -1, MOVE_TO_Y
);
4059 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4063 /* Move PT out of scroll margins. */
4064 this_scroll_margin
= max (0, scroll_margin
);
4065 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->height
) / 4);
4066 this_scroll_margin
*= CANON_Y_UNIT (it
.f
);
4070 /* We moved the window start towards ZV, so PT may be now
4071 in the scroll margin at the top. */
4072 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
4073 while (it
.current_y
< this_scroll_margin
)
4074 move_it_by_lines (&it
, 1, 1);
4075 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4079 int charpos
, bytepos
;
4081 /* We moved the window start towards BEGV, so PT may be now
4082 in the scroll margin at the bottom. */
4083 move_it_to (&it
, PT
, -1,
4084 it
.last_visible_y
- this_scroll_margin
- 1, -1,
4085 MOVE_TO_POS
| MOVE_TO_Y
);
4087 /* Save our position, in case it's correct. */
4088 charpos
= IT_CHARPOS (it
);
4089 bytepos
= IT_BYTEPOS (it
);
4091 /* See if point is on a partially visible line at the end. */
4092 move_it_by_lines (&it
, 1, 1);
4093 if (it
.current_y
> it
.last_visible_y
)
4094 /* The last line was only partially visible, so back up two
4095 lines to make sure we're on a fully visible line. */
4097 move_it_by_lines (&it
, -2, 0);
4098 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
4101 /* No, the position we saved is OK, so use it. */
4102 SET_PT_BOTH (charpos
, bytepos
);
4108 /* Implementation of window_scroll that works based on screen lines.
4109 See the comment of window_scroll for parameter descriptions. */
4112 window_scroll_line_based (window
, n
, whole
, noerror
)
4118 register struct window
*w
= XWINDOW (window
);
4119 register int opoint
= PT
, opoint_byte
= PT_BYTE
;
4120 register int pos
, pos_byte
;
4121 register int ht
= window_internal_height (w
);
4122 register Lisp_Object tem
;
4126 struct position posit
;
4129 /* If scrolling screen-fulls, compute the number of lines to
4130 scroll from the window's height. */
4132 n
*= max (1, ht
- next_screen_context_lines
);
4134 startpos
= marker_position (w
->start
);
4136 posit
= *compute_motion (startpos
, 0, 0, 0,
4138 window_internal_width (w
), XINT (w
->hscroll
),
4140 original_vpos
= posit
.vpos
;
4142 XSETFASTINT (tem
, PT
);
4143 tem
= Fpos_visible_in_window_p (tem
, window
, Qnil
);
4147 Fvertical_motion (make_number (- (ht
/ 2)), window
);
4152 lose
= n
< 0 && PT
== BEGV
;
4153 Fvertical_motion (make_number (n
), window
);
4157 SET_PT_BOTH (opoint
, opoint_byte
);
4164 Fsignal (Qbeginning_of_buffer
, Qnil
);
4169 int this_scroll_margin
= scroll_margin
;
4171 /* Don't use a scroll margin that is negative or too large. */
4172 if (this_scroll_margin
< 0)
4173 this_scroll_margin
= 0;
4175 if (XINT (w
->height
) < 4 * scroll_margin
)
4176 this_scroll_margin
= XINT (w
->height
) / 4;
4178 set_marker_restricted_both (w
->start
, w
->buffer
, pos
, pos_byte
);
4179 w
->start_at_line_beg
= bolp
;
4180 w
->update_mode_line
= Qt
;
4181 XSETFASTINT (w
->last_modified
, 0);
4182 XSETFASTINT (w
->last_overlay_modified
, 0);
4183 /* Set force_start so that redisplay_window will run
4184 the window-scroll-functions. */
4185 w
->force_start
= Qt
;
4187 if (whole
&& !NILP (Vscroll_preserve_screen_position
))
4189 SET_PT_BOTH (pos
, pos_byte
);
4190 Fvertical_motion (make_number (original_vpos
), window
);
4192 /* If we scrolled forward, put point enough lines down
4193 that it is outside the scroll margin. */
4198 if (this_scroll_margin
> 0)
4200 SET_PT_BOTH (pos
, pos_byte
);
4201 Fvertical_motion (make_number (this_scroll_margin
), window
);
4207 if (top_margin
<= opoint
)
4208 SET_PT_BOTH (opoint
, opoint_byte
);
4209 else if (!NILP (Vscroll_preserve_screen_position
))
4211 SET_PT_BOTH (pos
, pos_byte
);
4212 Fvertical_motion (make_number (original_vpos
), window
);
4215 SET_PT (top_margin
);
4221 /* If we scrolled backward, put point near the end of the window
4222 but not within the scroll margin. */
4223 SET_PT_BOTH (pos
, pos_byte
);
4224 tem
= Fvertical_motion (make_number (ht
- this_scroll_margin
), window
);
4225 if (XFASTINT (tem
) == ht
- this_scroll_margin
)
4228 bottom_margin
= PT
+ 1;
4230 if (bottom_margin
> opoint
)
4231 SET_PT_BOTH (opoint
, opoint_byte
);
4234 if (!NILP (Vscroll_preserve_screen_position
))
4236 SET_PT_BOTH (pos
, pos_byte
);
4237 Fvertical_motion (make_number (original_vpos
), window
);
4240 Fvertical_motion (make_number (-1), window
);
4249 Fsignal (Qend_of_buffer
, Qnil
);
4254 /* Scroll selected_window up or down. If N is nil, scroll a
4255 screen-full which is defined as the height of the window minus
4256 next_screen_context_lines. If N is the symbol `-', scroll.
4257 DIRECTION may be 1 meaning to scroll down, or -1 meaning to scroll
4258 up. This is the guts of Fscroll_up and Fscroll_down. */
4261 scroll_command (n
, direction
)
4265 int count
= BINDING_STACK_SIZE ();
4267 xassert (abs (direction
) == 1);
4269 /* If selected window's buffer isn't current, make it current for
4270 the moment. But don't screw up if window_scroll gets an error. */
4271 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
4273 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4274 Fset_buffer (XWINDOW (selected_window
)->buffer
);
4276 /* Make redisplay consider other windows than just selected_window. */
4277 ++windows_or_buffers_changed
;
4281 window_scroll (selected_window
, direction
, 1, 0);
4282 else if (EQ (n
, Qminus
))
4283 window_scroll (selected_window
, -direction
, 1, 0);
4286 n
= Fprefix_numeric_value (n
);
4287 window_scroll (selected_window
, XINT (n
) * direction
, 0, 0);
4290 unbind_to (count
, Qnil
);
4293 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
4294 doc
: /* Scroll text of current window upward ARG lines; or near full screen if no ARG.
4295 A near full screen is `next-screen-context-lines' less than a full screen.
4296 Negative ARG means scroll downward.
4297 If ARG is the atom `-', scroll downward by nearly full screen.
4298 When calling from a program, supply as argument a number, nil, or `-'. */)
4302 scroll_command (arg
, 1);
4306 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
4307 doc
: /* Scroll text of current window down ARG lines; or near full screen if no ARG.
4308 A near full screen is `next-screen-context-lines' less than a full screen.
4309 Negative ARG means scroll upward.
4310 If ARG is the atom `-', scroll upward by nearly full screen.
4311 When calling from a program, supply as argument a number, nil, or `-'. */)
4315 scroll_command (arg
, -1);
4319 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
4320 doc
: /* Return the other window for \"other window scroll\" commands.
4321 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4322 specifies the window.
4323 If `other-window-scroll-buffer' is non-nil, a window
4324 showing that buffer is used. */)
4329 if (MINI_WINDOW_P (XWINDOW (selected_window
))
4330 && !NILP (Vminibuf_scroll_window
))
4331 window
= Vminibuf_scroll_window
;
4332 /* If buffer is specified, scroll that buffer. */
4333 else if (!NILP (Vother_window_scroll_buffer
))
4335 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
4337 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
, Qnil
);
4341 /* Nothing specified; look for a neighboring window on the same
4343 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
4345 if (EQ (window
, selected_window
))
4346 /* That didn't get us anywhere; look for a window on another
4349 window
= Fnext_window (window
, Qnil
, Qt
);
4350 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
4351 && ! EQ (window
, selected_window
));
4354 CHECK_LIVE_WINDOW (window
, 0);
4356 if (EQ (window
, selected_window
))
4357 error ("There is no other window");
4362 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
4363 doc
: /* Scroll next window upward ARG lines; or near full screen if no ARG.
4364 A near full screen is `next-screen-context-lines' less than a full screen.
4365 The next window is the one below the current one; or the one at the top
4366 if the current one is at the bottom. Negative ARG means scroll downward.
4367 If ARG is the atom `-', scroll downward by nearly full screen.
4368 When calling from a program, supply as argument a number, nil, or `-'.
4370 If in the minibuffer, `minibuffer-scroll-window' if non-nil
4371 specifies the window to scroll.
4372 If `other-window-scroll-buffer' is non-nil, scroll the window
4373 showing that buffer, popping the buffer up if necessary. */)
4379 int count
= BINDING_STACK_SIZE ();
4381 window
= Fother_window_for_scrolling ();
4382 w
= XWINDOW (window
);
4384 /* Don't screw up if window_scroll gets an error. */
4385 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
4386 ++windows_or_buffers_changed
;
4388 Fset_buffer (w
->buffer
);
4389 SET_PT (marker_position (w
->pointm
));
4392 window_scroll (window
, 1, 1, 1);
4393 else if (EQ (arg
, Qminus
))
4394 window_scroll (window
, -1, 1, 1);
4399 CHECK_NUMBER (arg
, 0);
4400 window_scroll (window
, XINT (arg
), 0, 1);
4403 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
4404 unbind_to (count
, Qnil
);
4409 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
4410 doc
: /* Scroll selected window display ARG columns left.
4411 Default for ARG is window width minus 2. */)
4413 register Lisp_Object arg
;
4417 struct window
*w
= XWINDOW (selected_window
);
4420 XSETFASTINT (arg
, window_internal_width (w
) - 2);
4422 arg
= Fprefix_numeric_value (arg
);
4424 hscroll
= XINT (w
->hscroll
) + XINT (arg
);
4425 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4427 if (interactive_p (0))
4428 w
->min_hscroll
= w
->hscroll
;
4433 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
4434 doc
: /* Scroll selected window display ARG columns right.
4435 Default for ARG is window width minus 2. */)
4437 register Lisp_Object arg
;
4441 struct window
*w
= XWINDOW (selected_window
);
4444 XSETFASTINT (arg
, window_internal_width (w
) - 2);
4446 arg
= Fprefix_numeric_value (arg
);
4448 hscroll
= XINT (w
->hscroll
) - XINT (arg
);
4449 result
= Fset_window_hscroll (selected_window
, make_number (hscroll
));
4451 if (interactive_p (0))
4452 w
->min_hscroll
= w
->hscroll
;
4457 /* Value is the number of lines actually displayed in window W,
4458 as opposed to its height. */
4461 displayed_window_lines (w
)
4465 struct text_pos start
;
4466 int height
= window_box_height (w
);
4467 struct buffer
*old_buffer
;
4470 if (XBUFFER (w
->buffer
) != current_buffer
)
4472 old_buffer
= current_buffer
;
4473 set_buffer_internal (XBUFFER (w
->buffer
));
4478 /* In case W->start is out of the accessible range, do something
4479 reasonable. This happens in Info mode when Info-scroll-down
4480 calls (recenter -1) while W->start is 1. */
4481 if (XMARKER (w
->start
)->charpos
< BEGV
)
4482 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
4483 else if (XMARKER (w
->start
)->charpos
> ZV
)
4484 SET_TEXT_POS (start
, ZV
, ZV_BYTE
);
4486 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
4488 start_display (&it
, w
, start
);
4489 move_it_vertically (&it
, height
);
4490 bottom_y
= line_bottom_y (&it
);
4492 /* Add in empty lines at the bottom of the window. */
4493 if (bottom_y
< height
)
4495 int uy
= CANON_Y_UNIT (it
.f
);
4496 it
.vpos
+= (height
- bottom_y
+ uy
- 1) / uy
;
4500 set_buffer_internal (old_buffer
);
4506 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
4507 doc
: /* Center point in window and redisplay frame.
4508 With prefix argument ARG, recenter putting point on screen line ARG
4509 relative to the current window. If ARG is negative, it counts up from the
4510 bottom of the window. (ARG should be less than the height of the window.)
4512 If ARG is omitted or nil, erase the entire frame and then
4513 redraw with point in the center of the current window.
4514 Just C-u as prefix means put point in the center of the window
4515 and redisplay normally--don't erase and redraw the frame. */)
4517 register Lisp_Object arg
;
4519 struct window
*w
= XWINDOW (selected_window
);
4520 struct buffer
*buf
= XBUFFER (w
->buffer
);
4521 struct buffer
*obuf
= current_buffer
;
4523 int charpos
, bytepos
;
4529 /* Invalidate pixel data calculated for all compositions. */
4530 for (i
= 0; i
< n_compositions
; i
++)
4531 composition_table
[i
]->font
= NULL
;
4533 Fredraw_frame (w
->frame
);
4534 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
4537 else if (CONSP (arg
)) /* Just C-u. */
4541 arg
= Fprefix_numeric_value (arg
);
4542 CHECK_NUMBER (arg
, 0);
4545 set_buffer_internal (buf
);
4547 /* Handle centering on a graphical frame specially. Such frames can
4548 have variable-height lines and centering point on the basis of
4549 line counts would lead to strange effects. */
4550 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
4557 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
4558 start_display (&it
, w
, pt
);
4559 move_it_vertically (&it
, - window_box_height (w
) / 2);
4560 charpos
= IT_CHARPOS (it
);
4561 bytepos
= IT_BYTEPOS (it
);
4563 else if (XINT (arg
) < 0)
4567 int y0
, y1
, h
, nlines
;
4569 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
4570 start_display (&it
, w
, pt
);
4573 /* The amount of pixels we have to move back is the window
4574 height minus what's displayed in the line containing PT,
4575 and the lines below. */
4576 nlines
= - XINT (arg
) - 1;
4577 move_it_by_lines (&it
, nlines
, 1);
4579 y1
= it
.current_y
- y0
;
4580 h
= line_bottom_y (&it
) - y1
;
4582 /* If we can't move down NLINES lines because we hit
4583 the end of the buffer, count in some empty lines. */
4584 if (it
.vpos
< nlines
)
4585 y1
+= (nlines
- it
.vpos
) * CANON_Y_UNIT (it
.f
);
4587 y0
= it
.last_visible_y
- y1
- h
;
4589 start_display (&it
, w
, pt
);
4590 move_it_vertically (&it
, - y0
);
4591 charpos
= IT_CHARPOS (it
);
4592 bytepos
= IT_BYTEPOS (it
);
4596 struct position pos
;
4597 pos
= *vmotion (PT
, - XINT (arg
), w
);
4598 charpos
= pos
.bufpos
;
4599 bytepos
= pos
.bytepos
;
4604 struct position pos
;
4605 int ht
= window_internal_height (w
);
4608 arg
= make_number (ht
/ 2);
4609 else if (XINT (arg
) < 0)
4610 arg
= make_number (XINT (arg
) + ht
);
4612 pos
= *vmotion (PT
, - XINT (arg
), w
);
4613 charpos
= pos
.bufpos
;
4614 bytepos
= pos
.bytepos
;
4617 /* Set the new window start. */
4618 set_marker_both (w
->start
, w
->buffer
, charpos
, bytepos
);
4619 w
->window_end_valid
= Qnil
;
4620 w
->force_start
= Qt
;
4621 if (bytepos
== BEGV_BYTE
|| FETCH_BYTE (bytepos
- 1) == '\n')
4622 w
->start_at_line_beg
= Qt
;
4624 w
->start_at_line_beg
= Qnil
;
4626 set_buffer_internal (obuf
);
4631 DEFUN ("window-text-height", Fwindow_text_height
, Swindow_text_height
,
4633 doc
: /* Return the height in lines of the text display area of WINDOW.
4634 This doesn't include the mode-line (or header-line if any) or any
4635 partial-height lines in the text display area. */)
4639 struct window
*w
= decode_window (window
);
4640 int pixel_height
= window_box_height (w
);
4641 int line_height
= pixel_height
/ CANON_Y_UNIT (XFRAME (w
->frame
));
4642 return make_number (line_height
);
4647 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
4649 doc
: /* Position point relative to window.
4650 With no argument, position point at center of window.
4651 An argument specifies vertical position within the window;
4652 zero means top of window, negative means relative to bottom of window. */)
4656 struct window
*w
= XWINDOW (selected_window
);
4660 window
= selected_window
;
4661 start
= marker_position (w
->start
);
4662 if (start
< BEGV
|| start
> ZV
)
4664 int height
= window_internal_height (w
);
4665 Fvertical_motion (make_number (- (height
/ 2)), window
);
4666 set_marker_both (w
->start
, w
->buffer
, PT
, PT_BYTE
);
4667 w
->start_at_line_beg
= Fbolp ();
4668 w
->force_start
= Qt
;
4671 Fgoto_char (w
->start
);
4673 lines
= displayed_window_lines (w
);
4675 XSETFASTINT (arg
, lines
/ 2);
4678 arg
= Fprefix_numeric_value (arg
);
4680 XSETINT (arg
, XINT (arg
) + lines
);
4683 /* Skip past a partially visible first line. */
4685 XSETINT (arg
, XINT (arg
) + 1);
4687 return Fvertical_motion (arg
, window
);
4692 /***********************************************************************
4693 Window Configuration
4694 ***********************************************************************/
4696 struct save_window_data
4698 EMACS_INT size_from_Lisp_Vector_struct
;
4699 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
4700 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
4701 Lisp_Object frame_tool_bar_lines
;
4702 Lisp_Object selected_frame
;
4703 Lisp_Object current_window
;
4704 Lisp_Object current_buffer
;
4705 Lisp_Object minibuf_scroll_window
;
4706 Lisp_Object root_window
;
4707 Lisp_Object focus_frame
;
4708 /* Record the values of window-min-width and window-min-height
4709 so that window sizes remain consistent with them. */
4710 Lisp_Object min_width
, min_height
;
4711 /* A vector, each of whose elements is a struct saved_window
4713 Lisp_Object saved_windows
;
4716 /* This is saved as a Lisp_Vector */
4719 /* these first two must agree with struct Lisp_Vector in lisp.h */
4720 EMACS_INT size_from_Lisp_Vector_struct
;
4721 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
4724 Lisp_Object buffer
, start
, pointm
, mark
;
4725 Lisp_Object left
, top
, width
, height
, hscroll
, min_hscroll
;
4726 Lisp_Object parent
, prev
;
4727 Lisp_Object start_at_line_beg
;
4728 Lisp_Object display_table
;
4729 Lisp_Object orig_top
, orig_height
;
4732 #define SAVED_WINDOW_VECTOR_SIZE 17 /* Arg to Fmake_vector */
4734 #define SAVED_WINDOW_N(swv,n) \
4735 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
4737 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
4738 doc
: /* Return t if OBJECT is a window-configuration object. */)
4742 if (WINDOW_CONFIGURATIONP (object
))
4747 DEFUN ("window-configuration-frame", Fwindow_configuration_frame
, Swindow_configuration_frame
, 1, 1, 0,
4748 doc
: /* Return the frame that CONFIG, a window-configuration object, is about. */)
4752 register struct save_window_data
*data
;
4753 struct Lisp_Vector
*saved_windows
;
4755 if (! WINDOW_CONFIGURATIONP (config
))
4756 wrong_type_argument (Qwindow_configuration_p
, config
);
4758 data
= (struct save_window_data
*) XVECTOR (config
);
4759 saved_windows
= XVECTOR (data
->saved_windows
);
4760 return XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
4763 DEFUN ("set-window-configuration", Fset_window_configuration
,
4764 Sset_window_configuration
, 1, 1, 0,
4765 doc
: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
4766 CONFIGURATION must be a value previously returned
4767 by `current-window-configuration' (which see).
4768 If CONFIGURATION was made from a frame that is now deleted,
4769 only frame-independent values can be restored. In this case,
4770 the return value is nil. Otherwise the value is t. */)
4772 Lisp_Object configuration
;
4774 register struct save_window_data
*data
;
4775 struct Lisp_Vector
*saved_windows
;
4776 Lisp_Object new_current_buffer
;
4781 while (!WINDOW_CONFIGURATIONP (configuration
))
4782 wrong_type_argument (Qwindow_configuration_p
, configuration
);
4784 data
= (struct save_window_data
*) XVECTOR (configuration
);
4785 saved_windows
= XVECTOR (data
->saved_windows
);
4787 new_current_buffer
= data
->current_buffer
;
4788 if (NILP (XBUFFER (new_current_buffer
)->name
))
4789 new_current_buffer
= Qnil
;
4792 if (XBUFFER (new_current_buffer
) == current_buffer
)
4796 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
4799 /* If f is a dead frame, don't bother rebuilding its window tree.
4800 However, there is other stuff we should still try to do below. */
4801 if (FRAME_LIVE_P (f
))
4803 register struct window
*w
;
4804 register struct saved_window
*p
;
4805 struct window
*root_window
;
4806 struct window
**leaf_windows
;
4810 /* If the frame has been resized since this window configuration was
4811 made, we change the frame to the size specified in the
4812 configuration, restore the configuration, and then resize it
4813 back. We keep track of the prevailing height in these variables. */
4814 int previous_frame_height
= FRAME_HEIGHT (f
);
4815 int previous_frame_width
= FRAME_WIDTH (f
);
4816 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
4817 int previous_frame_tool_bar_lines
= FRAME_TOOL_BAR_LINES (f
);
4819 /* The mouse highlighting code could get screwed up
4820 if it runs during this. */
4823 if (XFASTINT (data
->frame_height
) != previous_frame_height
4824 || XFASTINT (data
->frame_width
) != previous_frame_width
)
4825 change_frame_size (f
, XFASTINT (data
->frame_height
),
4826 XFASTINT (data
->frame_width
), 0, 0, 0);
4827 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
4828 if (XFASTINT (data
->frame_menu_bar_lines
)
4829 != previous_frame_menu_bar_lines
)
4830 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, make_number (0));
4831 #ifdef HAVE_WINDOW_SYSTEM
4832 if (XFASTINT (data
->frame_tool_bar_lines
)
4833 != previous_frame_tool_bar_lines
)
4834 x_set_tool_bar_lines (f
, data
->frame_tool_bar_lines
, make_number (0));
4838 /* "Swap out" point from the selected window
4839 into its buffer. We do this now, before
4840 restoring the window contents, and prevent it from
4841 being done later on when we select a new window. */
4842 if (! NILP (XWINDOW (selected_window
)->buffer
))
4844 w
= XWINDOW (selected_window
);
4845 set_marker_both (w
->pointm
,
4847 BUF_PT (XBUFFER (w
->buffer
)),
4848 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
4851 windows_or_buffers_changed
++;
4852 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
4854 /* Problem: Freeing all matrices and later allocating them again
4855 is a serious redisplay flickering problem. What we would
4856 really like to do is to free only those matrices not reused
4858 root_window
= XWINDOW (FRAME_ROOT_WINDOW (f
));
4860 = (struct window
**) alloca (count_windows (root_window
)
4861 * sizeof (struct window
*));
4862 n_leaf_windows
= get_leaf_windows (root_window
, leaf_windows
, 0);
4864 /* Temporarily avoid any problems with windows that are smaller
4865 than they are supposed to be. */
4866 window_min_height
= 1;
4867 window_min_width
= 1;
4870 Mark all windows now on frame as "deleted".
4871 Restoring the new configuration "undeletes" any that are in it.
4873 Save their current buffers in their height fields, since we may
4874 need it later, if a buffer saved in the configuration is now
4876 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
4878 for (k
= 0; k
< saved_windows
->size
; k
++)
4880 p
= SAVED_WINDOW_N (saved_windows
, k
);
4881 w
= XWINDOW (p
->window
);
4884 if (!NILP (p
->parent
))
4885 w
->parent
= SAVED_WINDOW_N (saved_windows
,
4886 XFASTINT (p
->parent
))->window
;
4890 if (!NILP (p
->prev
))
4892 w
->prev
= SAVED_WINDOW_N (saved_windows
,
4893 XFASTINT (p
->prev
))->window
;
4894 XWINDOW (w
->prev
)->next
= p
->window
;
4899 if (!NILP (w
->parent
))
4901 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
4903 XWINDOW (w
->parent
)->vchild
= p
->window
;
4904 XWINDOW (w
->parent
)->hchild
= Qnil
;
4908 XWINDOW (w
->parent
)->hchild
= p
->window
;
4909 XWINDOW (w
->parent
)->vchild
= Qnil
;
4914 /* If we squirreled away the buffer in the window's height,
4916 if (BUFFERP (w
->height
))
4917 w
->buffer
= w
->height
;
4920 w
->width
= p
->width
;
4921 w
->height
= p
->height
;
4922 w
->hscroll
= p
->hscroll
;
4923 w
->min_hscroll
= p
->min_hscroll
;
4924 w
->display_table
= p
->display_table
;
4925 w
->orig_top
= p
->orig_top
;
4926 w
->orig_height
= p
->orig_height
;
4927 XSETFASTINT (w
->last_modified
, 0);
4928 XSETFASTINT (w
->last_overlay_modified
, 0);
4930 /* Reinstall the saved buffer and pointers into it. */
4931 if (NILP (p
->buffer
))
4932 w
->buffer
= p
->buffer
;
4935 if (!NILP (XBUFFER (p
->buffer
)->name
))
4936 /* If saved buffer is alive, install it. */
4938 w
->buffer
= p
->buffer
;
4939 w
->start_at_line_beg
= p
->start_at_line_beg
;
4940 set_marker_restricted (w
->start
, p
->start
, w
->buffer
);
4941 set_marker_restricted (w
->pointm
, p
->pointm
, w
->buffer
);
4942 Fset_marker (XBUFFER (w
->buffer
)->mark
,
4943 p
->mark
, w
->buffer
);
4945 /* As documented in Fcurrent_window_configuration, don't
4946 save the location of point in the buffer which was current
4947 when the window configuration was recorded. */
4948 if (!EQ (p
->buffer
, new_current_buffer
)
4949 && XBUFFER (p
->buffer
) == current_buffer
)
4950 Fgoto_char (w
->pointm
);
4952 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
4953 /* Else unless window has a live buffer, get one. */
4955 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
4956 /* This will set the markers to beginning of visible
4958 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
4959 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
4960 w
->start_at_line_beg
= Qt
;
4963 /* Keeping window's old buffer; make sure the markers
4966 /* Set window markers at start of visible range. */
4967 if (XMARKER (w
->start
)->buffer
== 0)
4968 set_marker_restricted (w
->start
, make_number (0),
4970 if (XMARKER (w
->pointm
)->buffer
== 0)
4971 set_marker_restricted_both (w
->pointm
, w
->buffer
,
4972 BUF_PT (XBUFFER (w
->buffer
)),
4973 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
4974 w
->start_at_line_beg
= Qt
;
4979 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
4980 /* Prevent "swapping out point" in the old selected window
4981 using the buffer that has been restored into it.
4982 That swapping out has already been done,
4983 near the beginning of this function. */
4984 selected_window
= Qnil
;
4985 Fselect_window (data
->current_window
);
4986 XBUFFER (XWINDOW (selected_window
)->buffer
)->last_selected_window
4989 if (NILP (data
->focus_frame
)
4990 || (FRAMEP (data
->focus_frame
)
4991 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
4992 Fredirect_frame_focus (frame
, data
->focus_frame
);
4994 #if 0 /* I don't understand why this is needed, and it causes problems
4995 when the frame's old selected window has been deleted. */
4996 if (f
!= selected_frame
&& FRAME_WINDOW_P (f
))
4997 do_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)),
5001 /* Set the screen height to the value it had before this function. */
5002 if (previous_frame_height
!= FRAME_HEIGHT (f
)
5003 || previous_frame_width
!= FRAME_WIDTH (f
))
5004 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
5006 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
5007 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
5008 x_set_menu_bar_lines (f
, make_number (previous_frame_menu_bar_lines
),
5010 #ifdef HAVE_WINDOW_SYSTEM
5011 if (previous_frame_tool_bar_lines
!= FRAME_TOOL_BAR_LINES (f
))
5012 x_set_tool_bar_lines (f
, make_number (previous_frame_tool_bar_lines
),
5017 /* Now, free glyph matrices in windows that were not reused. */
5018 for (i
= n
= 0; i
< n_leaf_windows
; ++i
)
5020 if (NILP (leaf_windows
[i
]->buffer
))
5022 /* Assert it's not reused as a combination. */
5023 xassert (NILP (leaf_windows
[i
]->hchild
)
5024 && NILP (leaf_windows
[i
]->vchild
));
5025 free_window_matrices (leaf_windows
[i
]);
5027 else if (EQ (leaf_windows
[i
]->buffer
, new_current_buffer
))
5031 /* If more than one window shows the new and old current buffer,
5032 don't try to preserve point in that buffer. */
5033 if (old_point
> 0 && n
> 1)
5040 /* Fselect_window will have made f the selected frame, so we
5041 reselect the proper frame here. Fhandle_switch_frame will change the
5042 selected window too, but that doesn't make the call to
5043 Fselect_window above totally superfluous; it still sets f's
5045 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
5046 do_switch_frame (data
->selected_frame
, 0, 0);
5048 if (! NILP (Vwindow_configuration_change_hook
)
5049 && ! NILP (Vrun_hooks
))
5050 call1 (Vrun_hooks
, Qwindow_configuration_change_hook
);
5053 if (!NILP (new_current_buffer
))
5055 Fset_buffer (new_current_buffer
);
5057 /* If the buffer that is current now is the same
5058 that was current before setting the window configuration,
5059 don't alter its PT. */
5064 /* Restore the minimum heights recorded in the configuration. */
5065 window_min_height
= XINT (data
->min_height
);
5066 window_min_width
= XINT (data
->min_width
);
5068 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
5070 return (FRAME_LIVE_P (f
) ? Qt
: Qnil
);
5073 /* Mark all windows now on frame as deleted
5074 by setting their buffers to nil. */
5077 delete_all_subwindows (w
)
5078 register struct window
*w
;
5080 if (!NILP (w
->next
))
5081 delete_all_subwindows (XWINDOW (w
->next
));
5082 if (!NILP (w
->vchild
))
5083 delete_all_subwindows (XWINDOW (w
->vchild
));
5084 if (!NILP (w
->hchild
))
5085 delete_all_subwindows (XWINDOW (w
->hchild
));
5087 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
5089 if (!NILP (w
->buffer
))
5092 /* We set all three of these fields to nil, to make sure that we can
5093 distinguish this dead window from any live window. Live leaf
5094 windows will have buffer set, and combination windows will have
5095 vchild or hchild set. */
5100 Vwindow_list
= Qnil
;
5104 count_windows (window
)
5105 register struct window
*window
;
5107 register int count
= 1;
5108 if (!NILP (window
->next
))
5109 count
+= count_windows (XWINDOW (window
->next
));
5110 if (!NILP (window
->vchild
))
5111 count
+= count_windows (XWINDOW (window
->vchild
));
5112 if (!NILP (window
->hchild
))
5113 count
+= count_windows (XWINDOW (window
->hchild
));
5118 /* Fill vector FLAT with leaf windows under W, starting at index I.
5119 Value is last index + 1. */
5122 get_leaf_windows (w
, flat
, i
)
5124 struct window
**flat
;
5129 if (!NILP (w
->hchild
))
5130 i
= get_leaf_windows (XWINDOW (w
->hchild
), flat
, i
);
5131 else if (!NILP (w
->vchild
))
5132 i
= get_leaf_windows (XWINDOW (w
->vchild
), flat
, i
);
5136 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5143 /* Return a pointer to the glyph W's physical cursor is on. Value is
5144 null if W's current matrix is invalid, so that no meaningfull glyph
5148 get_phys_cursor_glyph (w
)
5151 struct glyph_row
*row
;
5152 struct glyph
*glyph
;
5154 if (w
->phys_cursor
.vpos
>= 0
5155 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
5156 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
5158 && row
->used
[TEXT_AREA
] > w
->phys_cursor
.hpos
)
5159 glyph
= row
->glyphs
[TEXT_AREA
] + w
->phys_cursor
.hpos
;
5168 save_window_save (window
, vector
, i
)
5170 struct Lisp_Vector
*vector
;
5173 register struct saved_window
*p
;
5174 register struct window
*w
;
5175 register Lisp_Object tem
;
5177 for (;!NILP (window
); window
= w
->next
)
5179 p
= SAVED_WINDOW_N (vector
, i
);
5180 w
= XWINDOW (window
);
5182 XSETFASTINT (w
->temslot
, i
++);
5184 p
->buffer
= w
->buffer
;
5187 p
->width
= w
->width
;
5188 p
->height
= w
->height
;
5189 p
->hscroll
= w
->hscroll
;
5190 p
->min_hscroll
= w
->min_hscroll
;
5191 p
->display_table
= w
->display_table
;
5192 p
->orig_top
= w
->orig_top
;
5193 p
->orig_height
= w
->orig_height
;
5194 if (!NILP (w
->buffer
))
5196 /* Save w's value of point in the window configuration.
5197 If w is the selected window, then get the value of point
5198 from the buffer; pointm is garbage in the selected window. */
5199 if (EQ (window
, selected_window
))
5201 p
->pointm
= Fmake_marker ();
5202 set_marker_both (p
->pointm
, w
->buffer
,
5203 BUF_PT (XBUFFER (w
->buffer
)),
5204 BUF_PT_BYTE (XBUFFER (w
->buffer
)));
5207 p
->pointm
= Fcopy_marker (w
->pointm
, Qnil
);
5209 p
->start
= Fcopy_marker (w
->start
, Qnil
);
5210 p
->start_at_line_beg
= w
->start_at_line_beg
;
5212 tem
= XBUFFER (w
->buffer
)->mark
;
5213 p
->mark
= Fcopy_marker (tem
, Qnil
);
5220 p
->start_at_line_beg
= Qnil
;
5223 if (NILP (w
->parent
))
5226 p
->parent
= XWINDOW (w
->parent
)->temslot
;
5231 p
->prev
= XWINDOW (w
->prev
)->temslot
;
5233 if (!NILP (w
->vchild
))
5234 i
= save_window_save (w
->vchild
, vector
, i
);
5235 if (!NILP (w
->hchild
))
5236 i
= save_window_save (w
->hchild
, vector
, i
);
5242 DEFUN ("current-window-configuration", Fcurrent_window_configuration
,
5243 Scurrent_window_configuration
, 0, 1, 0,
5244 doc
: /* Return an object representing the current window configuration of FRAME.
5245 If FRAME is nil or omitted, use the selected frame.
5246 This describes the number of windows, their sizes and current buffers,
5247 and for each displayed buffer, where display starts, and the positions of
5248 point and mark. An exception is made for point in the current buffer:
5249 its value is -not- saved.
5250 This also records the currently selected frame, and FRAME's focus
5251 redirection (see `redirect-frame-focus'). */)
5255 register Lisp_Object tem
;
5256 register int n_windows
;
5257 register struct save_window_data
*data
;
5258 register struct Lisp_Vector
*vec
;
5263 frame
= selected_frame
;
5264 CHECK_LIVE_FRAME (frame
, 0);
5267 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5268 vec
= allocate_other_vector (VECSIZE (struct save_window_data
));
5269 data
= (struct save_window_data
*)vec
;
5271 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
5272 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
5273 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
5274 XSETFASTINT (data
->frame_tool_bar_lines
, FRAME_TOOL_BAR_LINES (f
));
5275 data
->selected_frame
= selected_frame
;
5276 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
5277 XSETBUFFER (data
->current_buffer
, current_buffer
);
5278 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
5279 data
->root_window
= FRAME_ROOT_WINDOW (f
);
5280 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
5281 XSETINT (data
->min_height
, window_min_height
);
5282 XSETINT (data
->min_width
, window_min_width
);
5283 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
5284 data
->saved_windows
= tem
;
5285 for (i
= 0; i
< n_windows
; i
++)
5286 XVECTOR (tem
)->contents
[i
]
5287 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
5288 save_window_save (FRAME_ROOT_WINDOW (f
), XVECTOR (tem
), 0);
5289 XSETWINDOW_CONFIGURATION (tem
, data
);
5293 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
5295 doc
: /* Execute body, preserving window sizes and contents.
5296 Restore which buffer appears in which window, where display starts,
5297 and the value of point and mark for each window.
5298 Also restore the choice of selected window.
5299 Also restore which buffer is current.
5300 Does not restore the value of point in current buffer.
5301 usage: (save-window-excursion BODY ...) */)
5305 register Lisp_Object val
;
5306 register int count
= specpdl_ptr
- specpdl
;
5308 record_unwind_protect (Fset_window_configuration
,
5309 Fcurrent_window_configuration (Qnil
));
5310 val
= Fprogn (args
);
5311 return unbind_to (count
, val
);
5315 /***********************************************************************
5317 ***********************************************************************/
5319 DEFUN ("set-window-margins", Fset_window_margins
, Sset_window_margins
,
5321 doc
: /* Set width of marginal areas of window WINDOW.
5322 If window is nil, set margins of the currently selected window.
5323 First parameter LEFT-WIDTH specifies the number of character
5324 cells to reserve for the left marginal area. Second parameter
5325 RIGHT-WIDTH does the same for the right marginal area.
5326 A nil width parameter means no margin. */)
5327 (window
, left
, right
)
5328 Lisp_Object window
, left
, right
;
5330 struct window
*w
= decode_window (window
);
5333 CHECK_NUMBER_OR_FLOAT (left
, 1);
5335 CHECK_NUMBER_OR_FLOAT (right
, 2);
5337 /* Check widths < 0 and translate a zero width to nil.
5338 Margins that are too wide have to be checked elsewhere. */
5339 if ((INTEGERP (left
) && XINT (left
) < 0)
5340 || (FLOATP (left
) && XFLOAT_DATA (left
) <= 0))
5341 XSETFASTINT (left
, 0);
5342 if (INTEGERP (left
) && XFASTINT (left
) == 0)
5345 if ((INTEGERP (right
) && XINT (right
) < 0)
5346 || (FLOATP (right
) && XFLOAT_DATA (right
) <= 0))
5347 XSETFASTINT (right
, 0);
5348 if (INTEGERP (right
) && XFASTINT (right
) == 0)
5351 w
->left_margin_width
= left
;
5352 w
->right_margin_width
= right
;
5354 ++windows_or_buffers_changed
;
5355 adjust_glyphs (XFRAME (WINDOW_FRAME (w
)));
5360 DEFUN ("window-margins", Fwindow_margins
, Swindow_margins
,
5362 doc
: /* Get width of marginal areas of window WINDOW.
5363 If WINDOW is omitted or nil, use the currently selected window.
5364 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
5365 If a marginal area does not exist, its width will be returned
5370 struct window
*w
= decode_window (window
);
5371 return Fcons (w
->left_margin_width
, w
->right_margin_width
);
5376 /***********************************************************************
5378 ***********************************************************************/
5380 DEFUN ("window-vscroll", Fwindow_vscroll
, Swindow_vscroll
, 0, 1, 0,
5381 doc
: /* Return the amount by which WINDOW is scrolled vertically.
5382 Use the selected window if WINDOW is nil or omitted.
5383 Value is a multiple of the canonical character height of WINDOW. */)
5392 window
= selected_window
;
5394 CHECK_WINDOW (window
, 0);
5395 w
= XWINDOW (window
);
5396 f
= XFRAME (w
->frame
);
5398 if (FRAME_WINDOW_P (f
))
5399 result
= CANON_Y_FROM_PIXEL_Y (f
, -w
->vscroll
);
5401 result
= make_number (0);
5406 DEFUN ("set-window-vscroll", Fset_window_vscroll
, Sset_window_vscroll
,
5408 doc
: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
5409 WINDOW nil or omitted means use the selected window. VSCROLL is a
5410 non-negative multiple of the canonical character height of WINDOW. */)
5412 Lisp_Object window
, vscroll
;
5418 window
= selected_window
;
5420 CHECK_WINDOW (window
, 0);
5421 CHECK_NUMBER_OR_FLOAT (vscroll
, 1);
5423 w
= XWINDOW (window
);
5424 f
= XFRAME (w
->frame
);
5426 if (FRAME_WINDOW_P (f
))
5428 int old_dy
= w
->vscroll
;
5430 w
->vscroll
= - CANON_Y_UNIT (f
) * XFLOATINT (vscroll
);
5431 w
->vscroll
= min (w
->vscroll
, 0);
5433 /* Adjust glyph matrix of the frame if the virtual display
5434 area becomes larger than before. */
5435 if (w
->vscroll
< 0 && w
->vscroll
< old_dy
)
5438 /* Prevent redisplay shortcuts. */
5439 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
5442 return Fwindow_vscroll (window
);
5446 /* Call FN for all leaf windows on frame F. FN is called with the
5447 first argument being a pointer to the leaf window, and with
5448 additional argument USER_DATA. Stops when FN returns 0. */
5451 foreach_window (f
, fn
, user_data
)
5453 int (* fn
) P_ ((struct window
*, void *));
5456 foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f
)), fn
, user_data
);
5460 /* Helper function for foreach_window. Call FN for all leaf windows
5461 reachable from W. FN is called with the first argument being a
5462 pointer to the leaf window, and with additional argument USER_DATA.
5463 Stop when FN returns 0. Value is 0 if stopped by FN. */
5466 foreach_window_1 (w
, fn
, user_data
)
5468 int (* fn
) P_ ((struct window
*, void *));
5473 for (cont
= 1; w
&& cont
;)
5475 if (!NILP (w
->hchild
))
5476 cont
= foreach_window_1 (XWINDOW (w
->hchild
), fn
, user_data
);
5477 else if (!NILP (w
->vchild
))
5478 cont
= foreach_window_1 (XWINDOW (w
->vchild
), fn
, user_data
);
5480 cont
= fn (w
, user_data
);
5482 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5489 /* Freeze or unfreeze the window start of W unless it is a
5490 mini-window or the selected window. FREEZE_P non-null means freeze
5491 the window start. */
5494 freeze_window_start (w
, freeze_p
)
5498 if (w
== XWINDOW (selected_window
)
5499 || MINI_WINDOW_P (w
)
5500 || (MINI_WINDOW_P (XWINDOW (selected_window
))
5501 && ! NILP (Vminibuf_scroll_window
)
5502 && w
== XWINDOW (Vminibuf_scroll_window
)))
5505 w
->frozen_window_start_p
= freeze_p
!= NULL
;
5510 /* Freeze or unfreeze the window starts of all leaf windows on frame
5511 F, except the selected window and a mini-window. FREEZE_P non-zero
5512 means freeze the window start. */
5515 freeze_window_starts (f
, freeze_p
)
5519 foreach_window (f
, freeze_window_start
, (void *) (freeze_p
? f
: 0));
5523 /***********************************************************************
5525 ***********************************************************************/
5527 /* Return 1 if window configurations C1 and C2
5528 describe the same state of affairs. This is used by Fequal. */
5531 compare_window_configurations (c1
, c2
, ignore_positions
)
5533 int ignore_positions
;
5535 register struct save_window_data
*d1
, *d2
;
5536 struct Lisp_Vector
*sw1
, *sw2
;
5539 if (!WINDOW_CONFIGURATIONP (c1
))
5540 wrong_type_argument (Qwindow_configuration_p
, c1
);
5541 if (!WINDOW_CONFIGURATIONP (c2
))
5542 wrong_type_argument (Qwindow_configuration_p
, c2
);
5544 d1
= (struct save_window_data
*) XVECTOR (c1
);
5545 d2
= (struct save_window_data
*) XVECTOR (c2
);
5546 sw1
= XVECTOR (d1
->saved_windows
);
5547 sw2
= XVECTOR (d2
->saved_windows
);
5549 if (! EQ (d1
->frame_width
, d2
->frame_width
))
5551 if (! EQ (d1
->frame_height
, d2
->frame_height
))
5553 if (! EQ (d1
->frame_menu_bar_lines
, d2
->frame_menu_bar_lines
))
5555 if (! EQ (d1
->selected_frame
, d2
->selected_frame
))
5557 /* Don't compare the current_window field directly.
5558 Instead see w1_is_current and w2_is_current, below. */
5559 if (! EQ (d1
->current_buffer
, d2
->current_buffer
))
5561 if (! ignore_positions
)
5562 if (! EQ (d1
->minibuf_scroll_window
, d2
->minibuf_scroll_window
))
5564 /* Don't compare the root_window field.
5565 We don't require the two configurations
5566 to use the same window object,
5567 and the two root windows must be equivalent
5568 if everything else compares equal. */
5569 if (! EQ (d1
->focus_frame
, d2
->focus_frame
))
5571 if (! EQ (d1
->min_width
, d2
->min_width
))
5573 if (! EQ (d1
->min_height
, d2
->min_height
))
5576 /* Verify that the two confis have the same number of windows. */
5577 if (sw1
->size
!= sw2
->size
)
5580 for (i
= 0; i
< sw1
->size
; i
++)
5582 struct saved_window
*p1
, *p2
;
5583 int w1_is_current
, w2_is_current
;
5585 p1
= SAVED_WINDOW_N (sw1
, i
);
5586 p2
= SAVED_WINDOW_N (sw2
, i
);
5588 /* Verify that the current windows in the two
5589 configurations correspond to each other. */
5590 w1_is_current
= EQ (d1
->current_window
, p1
->window
);
5591 w2_is_current
= EQ (d2
->current_window
, p2
->window
);
5593 if (w1_is_current
!= w2_is_current
)
5596 /* Verify that the corresponding windows do match. */
5597 if (! EQ (p1
->buffer
, p2
->buffer
))
5599 if (! EQ (p1
->left
, p2
->left
))
5601 if (! EQ (p1
->top
, p2
->top
))
5603 if (! EQ (p1
->width
, p2
->width
))
5605 if (! EQ (p1
->height
, p2
->height
))
5607 if (! EQ (p1
->display_table
, p2
->display_table
))
5609 if (! EQ (p1
->parent
, p2
->parent
))
5611 if (! EQ (p1
->prev
, p2
->prev
))
5613 if (! ignore_positions
)
5615 if (! EQ (p1
->hscroll
, p2
->hscroll
))
5617 if (!EQ (p1
->min_hscroll
, p2
->min_hscroll
))
5619 if (! EQ (p1
->start_at_line_beg
, p2
->start_at_line_beg
))
5621 if (NILP (Fequal (p1
->start
, p2
->start
)))
5623 if (NILP (Fequal (p1
->pointm
, p2
->pointm
)))
5625 if (NILP (Fequal (p1
->mark
, p2
->mark
)))
5633 DEFUN ("compare-window-configurations", Fcompare_window_configurations
,
5634 Scompare_window_configurations
, 2, 2, 0,
5635 doc
: /* Compare two window configurations as regards the structure of windows.
5636 This function ignores details such as the values of point and mark
5637 and scrolling positions. */)
5641 if (compare_window_configurations (x
, y
, 1))
5649 struct frame
*f
= make_terminal_frame ();
5650 XSETFRAME (selected_frame
, f
);
5651 Vterminal_frame
= selected_frame
;
5652 minibuf_window
= f
->minibuffer_window
;
5653 selected_window
= f
->selected_window
;
5654 last_nonminibuf_frame
= f
;
5656 window_initialized
= 1;
5662 Vwindow_list
= Qnil
;
5668 Qleft_fringe
= intern ("left-fringe");
5669 staticpro (&Qleft_fringe
);
5670 Qright_fringe
= intern ("right-fringe");
5671 staticpro (&Qright_fringe
);
5673 Qwindow_size_fixed
= intern ("window-size-fixed");
5674 staticpro (&Qwindow_size_fixed
);
5676 staticpro (&Qwindow_configuration_change_hook
);
5677 Qwindow_configuration_change_hook
5678 = intern ("window-configuration-change-hook");
5680 Qwindowp
= intern ("windowp");
5681 staticpro (&Qwindowp
);
5683 Qwindow_configuration_p
= intern ("window-configuration-p");
5684 staticpro (&Qwindow_configuration_p
);
5686 Qwindow_live_p
= intern ("window-live-p");
5687 staticpro (&Qwindow_live_p
);
5689 Qtemp_buffer_show_hook
= intern ("temp-buffer-show-hook");
5690 staticpro (&Qtemp_buffer_show_hook
);
5692 staticpro (&Vwindow_list
);
5694 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
5695 doc
: /* Non-nil means call as function to display a help buffer.
5696 The function is called with one argument, the buffer to be displayed.
5697 Used by `with-output-to-temp-buffer'.
5698 If this function is used, then it must do the entire job of showing
5699 the buffer; `temp-buffer-show-hook' is not run unless this function runs it. */);
5700 Vtemp_buffer_show_function
= Qnil
;
5702 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
5703 doc
: /* If non-nil, function to call to handle `display-buffer'.
5704 It will receive two args, the buffer and a flag which if non-nil means
5705 that the currently selected window is not acceptable.
5706 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
5707 work using this function. */);
5708 Vdisplay_buffer_function
= Qnil
;
5710 DEFVAR_LISP ("even-window-heights", &Veven_window_heights
,
5711 doc
: /* *If non-nil, `display-buffer' should even the window heights.
5712 If nil, `display-buffer' will leave the window configuration alone. */);
5713 Veven_window_heights
= Qt
;
5715 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
5716 doc
: /* Non-nil means it is the window that C-M-v in minibuffer should scroll. */);
5717 Vminibuf_scroll_window
= Qnil
;
5719 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
5720 doc
: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window. */);
5721 Vother_window_scroll_buffer
= Qnil
;
5723 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
5724 doc
: /* *Non-nil means `display-buffer' should make a separate frame. */);
5727 DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames
,
5728 doc
: /* *Non-nil means `display-buffer' should reuse frames.
5729 If the buffer in question is already displayed in a frame, raise that frame. */);
5730 display_buffer_reuse_frames
= 0;
5732 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
5733 doc
: /* Function to call to handle automatic new frame creation.
5734 It is called with no arguments and should return a newly created frame.
5736 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
5737 where `pop-up-frame-alist' would hold the default frame parameters. */);
5738 Vpop_up_frame_function
= Qnil
;
5740 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
5741 doc
: /* *List of buffer names that should have their own special frames.
5742 Displaying a buffer whose name is in this list makes a special frame for it
5743 using `special-display-function'. See also `special-display-regexps'.
5745 An element of the list can be a list instead of just a string.
5746 There are two ways to use a list as an element:
5747 (BUFFER FRAME-PARAMETERS...) (BUFFER FUNCTION OTHER-ARGS...)
5748 In the first case, FRAME-PARAMETERS are used to create the frame.
5749 In the latter case, FUNCTION is called with BUFFER as the first argument,
5750 followed by OTHER-ARGS--it can display BUFFER in any way it likes.
5751 All this is done by the function found in `special-display-function'.
5753 If this variable appears \"not to work\", because you add a name to it
5754 but that buffer still appears in the selected window, look at the
5755 values of `same-window-buffer-names' and `same-window-regexps'.
5756 Those variables take precedence over this one. */);
5757 Vspecial_display_buffer_names
= Qnil
;
5759 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
5760 doc
: /* *List of regexps saying which buffers should have their own special frames.
5761 If a buffer name matches one of these regexps, it gets its own frame.
5762 Displaying a buffer whose name is in this list makes a special frame for it
5763 using `special-display-function'.
5765 An element of the list can be a list instead of just a string.
5766 There are two ways to use a list as an element:
5767 (REGEXP FRAME-PARAMETERS...) (REGEXP FUNCTION OTHER-ARGS...)
5768 In the first case, FRAME-PARAMETERS are used to create the frame.
5769 In the latter case, FUNCTION is called with the buffer as first argument,
5770 followed by OTHER-ARGS--it can display the buffer in any way it likes.
5771 All this is done by the function found in `special-display-function'.
5773 If this variable appears \"not to work\", because you add a regexp to it
5774 but the matching buffers still appear in the selected window, look at the
5775 values of `same-window-buffer-names' and `same-window-regexps'.
5776 Those variables take precedence over this one. */);
5777 Vspecial_display_regexps
= Qnil
;
5779 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
5780 doc
: /* Function to call to make a new frame for a special buffer.
5781 It is called with two arguments, the buffer and optional buffer specific
5782 data, and should return a window displaying that buffer.
5783 The default value makes a separate frame for the buffer,
5784 using `special-display-frame-alist' to specify the frame parameters.
5786 A buffer is special if its is listed in `special-display-buffer-names'
5787 or matches a regexp in `special-display-regexps'. */);
5788 Vspecial_display_function
= Qnil
;
5790 DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names
,
5791 doc
: /* *List of buffer names that should appear in the selected window.
5792 Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
5793 switches to it in the selected window, rather than making it appear
5794 in some other window.
5796 An element of the list can be a cons cell instead of just a string.
5797 Then the car must be a string, which specifies the buffer name.
5798 This is for compatibility with `special-display-buffer-names';
5799 the cdr of the cons cell is ignored.
5801 See also `same-window-regexps'. */);
5802 Vsame_window_buffer_names
= Qnil
;
5804 DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps
,
5805 doc
: /* *List of regexps saying which buffers should appear in the selected window.
5806 If a buffer name matches one of these regexps, then displaying it
5807 using `display-buffer' or `pop-to-buffer' switches to it
5808 in the selected window, rather than making it appear in some other window.
5810 An element of the list can be a cons cell instead of just a string.
5811 Then the car must be a string, which specifies the buffer name.
5812 This is for compatibility with `special-display-buffer-names';
5813 the cdr of the cons cell is ignored.
5815 See also `same-window-buffer-names'. */);
5816 Vsame_window_regexps
= Qnil
;
5818 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
5819 doc
: /* *Non-nil means display-buffer should make new windows. */);
5822 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
5823 doc
: /* *Number of lines of continuity when scrolling by screenfuls. */);
5824 next_screen_context_lines
= 2;
5826 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
5827 doc
: /* *display-buffer would prefer to split the largest window if this large.
5828 If there is only one window, it is split regardless of this value. */);
5829 split_height_threshold
= 500;
5831 DEFVAR_INT ("window-min-height", &window_min_height
,
5832 doc
: /* *Delete any window less than this tall (including its mode line). */);
5833 window_min_height
= 4;
5835 DEFVAR_INT ("window-min-width", &window_min_width
,
5836 doc
: /* *Delete any window less than this wide. */);
5837 window_min_width
= 10;
5839 DEFVAR_LISP ("scroll-preserve-screen-position",
5840 &Vscroll_preserve_screen_position
,
5841 doc
: /* *Non-nil means scroll commands move point to keep its screen line unchanged. */);
5842 Vscroll_preserve_screen_position
= Qnil
;
5844 DEFVAR_LISP ("window-configuration-change-hook",
5845 &Vwindow_configuration_change_hook
,
5846 doc
: /* Functions to call when window configuration changes.
5847 The selected frame is the one whose configuration has changed. */);
5848 Vwindow_configuration_change_hook
= Qnil
;
5850 DEFVAR_BOOL ("window-size-fixed", &window_size_fixed
,
5851 doc
: /* Non-nil in a buffer means windows displaying the buffer are fixed-size.
5852 Emacs won't change the size of any window displaying that buffer,
5853 unless you explicitly change the size, or Emacs has no other choice.
5854 This variable automatically becomes buffer-local when set. */);
5855 Fmake_variable_buffer_local (Qwindow_size_fixed
);
5856 window_size_fixed
= 0;
5858 defsubr (&Sselected_window
);
5859 defsubr (&Sminibuffer_window
);
5860 defsubr (&Swindow_minibuffer_p
);
5861 defsubr (&Swindowp
);
5862 defsubr (&Swindow_live_p
);
5863 defsubr (&Spos_visible_in_window_p
);
5864 defsubr (&Swindow_buffer
);
5865 defsubr (&Swindow_height
);
5866 defsubr (&Swindow_width
);
5867 defsubr (&Swindow_hscroll
);
5868 defsubr (&Sset_window_hscroll
);
5869 defsubr (&Swindow_redisplay_end_trigger
);
5870 defsubr (&Sset_window_redisplay_end_trigger
);
5871 defsubr (&Swindow_edges
);
5872 defsubr (&Scoordinates_in_window_p
);
5873 defsubr (&Swindow_at
);
5874 defsubr (&Swindow_point
);
5875 defsubr (&Swindow_start
);
5876 defsubr (&Swindow_end
);
5877 defsubr (&Sset_window_point
);
5878 defsubr (&Sset_window_start
);
5879 defsubr (&Swindow_dedicated_p
);
5880 defsubr (&Sset_window_dedicated_p
);
5881 defsubr (&Swindow_display_table
);
5882 defsubr (&Sset_window_display_table
);
5883 defsubr (&Snext_window
);
5884 defsubr (&Sprevious_window
);
5885 defsubr (&Sother_window
);
5886 defsubr (&Sget_lru_window
);
5887 defsubr (&Sget_largest_window
);
5888 defsubr (&Sget_buffer_window
);
5889 defsubr (&Sdelete_other_windows
);
5890 defsubr (&Sdelete_windows_on
);
5891 defsubr (&Sreplace_buffer_in_windows
);
5892 defsubr (&Sdelete_window
);
5893 defsubr (&Sset_window_buffer
);
5894 defsubr (&Sselect_window
);
5895 defsubr (&Sspecial_display_p
);
5896 defsubr (&Ssame_window_p
);
5897 defsubr (&Sdisplay_buffer
);
5898 defsubr (&Ssplit_window
);
5899 defsubr (&Senlarge_window
);
5900 defsubr (&Sshrink_window
);
5901 defsubr (&Sscroll_up
);
5902 defsubr (&Sscroll_down
);
5903 defsubr (&Sscroll_left
);
5904 defsubr (&Sscroll_right
);
5905 defsubr (&Sother_window_for_scrolling
);
5906 defsubr (&Sscroll_other_window
);
5907 defsubr (&Srecenter
);
5908 defsubr (&Swindow_text_height
);
5909 defsubr (&Smove_to_window_line
);
5910 defsubr (&Swindow_configuration_p
);
5911 defsubr (&Swindow_configuration_frame
);
5912 defsubr (&Sset_window_configuration
);
5913 defsubr (&Scurrent_window_configuration
);
5914 defsubr (&Ssave_window_excursion
);
5915 defsubr (&Sset_window_margins
);
5916 defsubr (&Swindow_margins
);
5917 defsubr (&Swindow_vscroll
);
5918 defsubr (&Sset_window_vscroll
);
5919 defsubr (&Scompare_window_configurations
);
5920 defsubr (&Swindow_list
);
5926 initial_define_key (control_x_map
, '1', "delete-other-windows");
5927 initial_define_key (control_x_map
, '2', "split-window");
5928 initial_define_key (control_x_map
, '0', "delete-window");
5929 initial_define_key (control_x_map
, 'o', "other-window");
5930 initial_define_key (control_x_map
, '^', "enlarge-window");
5931 initial_define_key (control_x_map
, '<', "scroll-left");
5932 initial_define_key (control_x_map
, '>', "scroll-right");
5934 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
5935 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
5936 initial_define_key (meta_map
, 'v', "scroll-down");
5938 initial_define_key (global_map
, Ctl('L'), "recenter");
5939 initial_define_key (meta_map
, 'r', "move-to-window-line");