1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 Lisp_Object Qwindowp
, Qwindow_live_p
;
34 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
35 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
37 void delete_all_subwindows ();
38 static struct window
*decode_window();
40 /* This is the window in which the terminal's cursor should
41 be left when nothing is being done with it. This must
42 always be a leaf window, and its buffer is selected by
43 the top level editing loop at the end of each command.
45 This value is always the same as
46 FRAME_SELECTED_WINDOW (selected_frame). */
48 Lisp_Object selected_window
;
50 /* The minibuffer window of the selected frame.
51 Note that you cannot test for minibufferness of an arbitrary window
52 by comparing against this; but you can test for minibufferness of
53 the selected window. */
54 Lisp_Object minibuf_window
;
56 /* Non-nil means it is the window for C-M-v to scroll
57 when the minibuffer is selected. */
58 Lisp_Object Vminibuf_scroll_window
;
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
61 Lisp_Object Vother_window_scroll_buffer
;
63 /* Non-nil means it's function to call to display temp buffers. */
64 Lisp_Object Vtemp_buffer_show_function
;
66 /* If a window gets smaller than either of these, it is removed. */
67 int window_min_height
;
70 /* Nonzero implies Fdisplay_buffer should create windows. */
73 /* Nonzero implies make new frames for Fdisplay_buffer. */
76 /* Non-nil means use this function instead of default */
77 Lisp_Object Vpop_up_frame_function
;
79 /* Function to call to handle Fdisplay_buffer. */
80 Lisp_Object Vdisplay_buffer_function
;
82 /* List of buffer *names* for buffers that should have their own frames. */
83 Lisp_Object Vspecial_display_buffer_names
;
85 /* List of regexps for buffer names that should have their own frames. */
86 Lisp_Object Vspecial_display_regexps
;
88 /* Function to pop up a special frame. */
89 Lisp_Object Vspecial_display_function
;
91 /* Fdisplay_buffer always splits the largest window
92 if that window is more than this high. */
93 int split_height_threshold
;
95 /* Number of lines of continuity in scrolling by screenfuls. */
96 int next_screen_context_lines
;
98 /* Incremented for each window created. */
99 static int sequence_number
;
101 #define min(a, b) ((a) < (b) ? (a) : (b))
103 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
104 "Returns t if OBJ is a window.")
108 return WINDOWP (obj
) ? Qt
: Qnil
;
111 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
112 "Returns t if OBJ is a window which is currently visible.")
116 return (WINDOWP (obj
) && ! NILP (XWINDOW (obj
)->buffer
) ? Qt
: Qnil
);
123 register struct window
*p
;
124 register struct Lisp_Vector
*vec
;
127 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct window
));
128 for (i
= 0; i
< VECSIZE (struct window
); i
++)
129 vec
->contents
[i
] = Qnil
;
130 vec
->size
= VECSIZE (struct window
);
131 p
= (struct window
*)vec
;
132 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
133 XSETFASTINT (p
->left
, 0);
134 XSETFASTINT (p
->top
, 0);
135 XSETFASTINT (p
->height
, 0);
136 XSETFASTINT (p
->width
, 0);
137 XSETFASTINT (p
->hscroll
, 0);
138 XSETFASTINT (p
->last_point_x
, 0);
139 XSETFASTINT (p
->last_point_y
, 0);
140 p
->start
= Fmake_marker ();
141 p
->pointm
= Fmake_marker ();
142 XSETFASTINT (p
->use_time
, 0);
144 p
->display_table
= Qnil
;
150 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
151 "Return the window that the cursor now appears in and commands apply to.")
154 return selected_window
;
157 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
158 "Return the window used now for minibuffers.\n\
159 If the optional argument FRAME is specified, return the minibuffer window\n\
160 used by that frame.")
166 XSETFRAME (frame
, selected_frame
);
168 CHECK_LIVE_FRAME (frame
, 0);
171 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
174 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
175 "Returns non-nil if WINDOW is a minibuffer window.")
179 struct window
*w
= decode_window (window
);
180 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
183 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
184 Spos_visible_in_window_p
, 0, 2, 0,
185 "Return t if position POS is currently on the frame in WINDOW.\n\
186 Returns nil if that position is scrolled vertically out of view.\n\
187 POS defaults to point; WINDOW, to the selected window.")
189 Lisp_Object pos
, window
;
191 register struct window
*w
;
195 register struct buffer
*buf
;
196 struct position posval
;
203 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
207 w
= decode_window (window
);
208 top
= marker_position (w
->start
);
209 hscroll
= XINT (w
->hscroll
);
214 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
216 buf
= XBUFFER (w
->buffer
);
217 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
219 /* If frame is up to date,
220 use the info recorded about how much text fit on it. */
221 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
222 || (XFASTINT (w
->window_end_vpos
) < height
))
228 if (posint
> BUF_ZV (buf
))
231 /* w->start can be out of range. If it is, do something reasonable. */
232 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
235 /* If that info is not correct, calculate afresh */
236 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
238 window_internal_width (w
) - 1,
241 return posval
.vpos
< height
? Qt
: Qnil
;
245 static struct window
*
246 decode_window (window
)
247 register Lisp_Object window
;
250 return XWINDOW (selected_window
);
252 CHECK_LIVE_WINDOW (window
, 0);
253 return XWINDOW (window
);
256 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
257 "Return the buffer that WINDOW is displaying.")
261 return decode_window (window
)->buffer
;
264 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
265 "Return the number of lines in WINDOW (including its mode line).")
269 return decode_window (window
)->height
;
272 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
273 "Return the number of display columns in WINDOW.\n\
274 This is the width that is usable columns available for text in WINDOW.\n\
275 If you want to find out how many columns WINDOW takes up,\n\
276 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
280 return make_number (window_internal_width (decode_window (window
)));
283 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
284 "Return the number of columns by which WINDOW is scrolled from left margin.")
288 return decode_window (window
)->hscroll
;
291 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
292 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
293 NCOL should be zero or positive.")
295 register Lisp_Object window
, ncol
;
297 register struct window
*w
;
299 CHECK_NUMBER (ncol
, 1);
300 if (XINT (ncol
) < 0) XSETFASTINT (ncol
, 0);
301 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
302 args_out_of_range (ncol
, Qnil
);
303 w
= decode_window (window
);
304 if (XINT (w
->hscroll
) != XINT (ncol
))
305 clip_changed
= 1; /* Prevent redisplay shortcuts */
310 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
311 "Return a list of the edge coordinates of WINDOW.\n\
312 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
313 RIGHT is one more than the rightmost column used by WINDOW,\n\
314 and BOTTOM is one more than the bottommost row used by WINDOW\n\
319 register struct window
*w
= decode_window (window
);
321 return Fcons (w
->left
, Fcons (w
->top
,
322 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
323 Fcons (make_number (XFASTINT (w
->top
)
324 + XFASTINT (w
->height
)),
328 /* Test if the character at column *x, row *y is within window *w.
329 If it is not, return 0;
330 if it is in the window's text area,
331 set *x and *y to its location relative to the upper left corner
334 if it is on the window's modeline, return 2;
335 if it is on the border between the window and its right sibling,
338 coordinates_in_window (w
, x
, y
)
339 register struct window
*w
;
342 register int left
= XINT (w
->left
);
343 register int width
= XINT (w
->width
);
344 register int window_height
= XINT (w
->height
);
345 register int top
= XFASTINT (w
->top
);
347 if ( *x
< left
|| *x
>= left
+ width
348 || *y
< top
|| *y
>= top
+ window_height
)
351 /* Is the character is the mode line? */
352 if (*y
== top
+ window_height
- 1
353 && ! MINI_WINDOW_P (w
))
356 /* Is the character in the right border? */
357 if (*x
== left
+ width
- 1
358 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
366 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
367 Scoordinates_in_window_p
, 2, 2, 0,
368 "Return non-nil if COORDINATES are in WINDOW.\n\
369 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
370 measured in characters from the upper-left corner of the frame.\n\
371 (0 . 0) denotes the character in the upper left corner of the\n\
373 If COORDINATES are in the text portion of WINDOW,\n\
374 the coordinates relative to the window are returned.\n\
375 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
376 If they are on the border between WINDOW and its right sibling,\n\
377 `vertical-line' is returned.")
378 (coordinates
, window
)
379 register Lisp_Object coordinates
, window
;
383 CHECK_LIVE_WINDOW (window
, 0);
384 CHECK_CONS (coordinates
, 1);
385 x
= XINT (Fcar (coordinates
));
386 y
= XINT (Fcdr (coordinates
));
388 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
390 case 0: /* NOT in window at all. */
393 case 1: /* In text part of window. */
396 case 2: /* In mode line of window. */
399 case 3: /* On right border of window. */
400 return Qvertical_line
;
407 /* Find the window containing column x, row y, and return it as a
408 Lisp_Object. If x, y is on the window's modeline, set *part
409 to 1; if it is on the separating line between the window and its
410 right sibling, set it to 2; otherwise set it to 0. If there is no
411 window under x, y return nil and leave *part unmodified. */
413 window_from_coordinates (frame
, x
, y
, part
)
418 register Lisp_Object tem
, first
;
420 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
424 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
432 tem
= Fnext_window (tem
, Qt
, Qlambda
);
434 while (! EQ (tem
, first
));
439 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
440 "Return window containing coordinates X and Y on FRAME.\n\
441 If omitted, FRAME defaults to the currently selected frame.\n\
442 The top left corner of the frame is considered to be row 0,\n\
445 Lisp_Object x
, y
, frame
;
451 XSETFRAME (frame
, selected_frame
);
453 CHECK_LIVE_FRAME (frame
, 2);
458 return window_from_coordinates (XFRAME (frame
),
463 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
464 "Return current value of point in WINDOW.\n\
465 For a nonselected window, this is the value point would have\n\
466 if that window were selected.\n\
468 Note that, when WINDOW is the selected window and its buffer\n\
469 is also currently selected, the value returned is the same as (point).\n\
470 It would be more strictly correct to return the `top-level' value\n\
471 of point, outside of any save-excursion forms.\n\
472 But that is hard to define.")
476 register struct window
*w
= decode_window (window
);
478 if (w
== XWINDOW (selected_window
)
479 && current_buffer
== XBUFFER (w
->buffer
))
481 return Fmarker_position (w
->pointm
);
484 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
485 "Return position at which display currently starts in WINDOW.")
489 return Fmarker_position (decode_window (window
)->start
);
492 /* This is text temporarily removed from the doc string below.
494 This function returns nil if the position is not currently known.\n\
495 That happens when redisplay is preempted and doesn't finish.\n\
496 If in that case you want to compute where the end of the window would\n\
497 have been if redisplay had finished, do this:\n\
499 (goto-char (window-start window))\n\
500 (vertical-motion (1- (window-height window)) window)\n\
503 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
504 "Return position at which display currently ends in WINDOW.\n\
505 This is updated by redisplay, when it runs to completion.\n\
506 Simply changing the buffer text or setting `window-start'\n\
507 does not update this value.")
512 struct window
*w
= decode_window (window
);
516 CHECK_BUFFER (buf
, 0);
518 #if 0 /* This change broke some things. We should make it later. */
519 /* If we don't know the end position, return nil.
520 The user can compute it with vertical-motion if he wants to.
521 It would be nicer to do it automatically,
522 but that's so slow that it would probably bother people. */
523 if (NILP (w
->window_end_valid
))
528 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
533 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
534 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
536 Lisp_Object window
, pos
;
538 register struct window
*w
= decode_window (window
);
540 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
541 if (w
== XWINDOW (selected_window
))
544 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
549 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
550 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
551 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
552 from overriding motion of point in order to display at this exact start.")
553 (window
, pos
, noforce
)
554 Lisp_Object window
, pos
, noforce
;
556 register struct window
*w
= decode_window (window
);
558 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
559 set_marker_restricted (w
->start
, pos
, w
->buffer
);
560 /* this is not right, but much easier than doing what is right. */
561 w
->start_at_line_beg
= Qnil
;
564 w
->update_mode_line
= Qt
;
565 XSETFASTINT (w
->last_modified
, 0);
566 if (!EQ (window
, selected_window
))
567 windows_or_buffers_changed
++;
571 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
573 "Return WINDOW's dedicated object, usually t or nil.\n\
574 See also `set-window-dedicated-p'.")
578 return decode_window (window
)->dedicated
;
581 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
582 Sset_window_dedicated_p
, 2, 2, 0,
583 "Control whether WINDOW is dedicated to the buffer it displays.\n\
584 If it is dedicated, Emacs will not automatically change\n\
585 which buffer appears in it.\n\
586 The second argument is the new value for the dedication flag;\n\
589 Lisp_Object window
, arg
;
591 register struct window
*w
= decode_window (window
);
601 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
603 "Return the display-table that WINDOW is using.")
607 return decode_window (window
)->display_table
;
610 /* Get the display table for use currently on window W.
611 This is either W's display table or W's buffer's display table.
612 Ignore the specified tables if they are not valid;
613 if no valid table is specified, return 0. */
616 window_display_table (w
)
620 tem
= w
->display_table
;
621 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
622 return XVECTOR (tem
);
623 tem
= XBUFFER (w
->buffer
)->display_table
;
624 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
625 return XVECTOR (tem
);
626 tem
= Vstandard_display_table
;
627 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
628 return XVECTOR (tem
);
632 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
633 "Set WINDOW's display-table to TABLE.")
635 register Lisp_Object window
, table
;
637 register struct window
*w
;
638 register Lisp_Object z
; /* Return value. */
640 w
= decode_window (window
);
641 w
->display_table
= table
;
645 /* Record info on buffer window w is displaying
646 when it is about to cease to display that buffer. */
649 register struct window
*w
;
654 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
658 if (w
== XWINDOW (selected_window
)
659 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
660 /* Do this except when the selected window's buffer
661 is being removed from some other window. */
663 /* last_window_start records the start position that this buffer
664 had in the last window to be disconnected from it.
665 Now that this statement is unconditional,
666 it is possible for the buffer to be displayed in the
667 selected window, while last_window_start reflects another
668 window which was recently showing the same buffer.
669 Some people might say that might be a good thing. Let's see. */
670 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
672 /* Point in the selected window's buffer
673 is actually stored in that buffer, and the window's pointm isn't used.
674 So don't clobber point in that buffer. */
675 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
676 BUF_PT (XBUFFER (buf
))
677 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
678 marker_position (w
->pointm
),
679 BUF_ZV (XBUFFER (buf
)));
682 /* Put replacement into the window structure in place of old. */
684 replace_window (old
, replacement
)
685 Lisp_Object old
, replacement
;
687 register Lisp_Object tem
;
688 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
690 /* If OLD is its frame's root_window, then replacement is the new
691 root_window for that frame. */
693 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
694 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
699 p
->height
= o
->height
;
701 p
->next
= tem
= o
->next
;
703 XWINDOW (tem
)->prev
= replacement
;
705 p
->prev
= tem
= o
->prev
;
707 XWINDOW (tem
)->next
= replacement
;
709 p
->parent
= tem
= o
->parent
;
712 if (EQ (XWINDOW (tem
)->vchild
, old
))
713 XWINDOW (tem
)->vchild
= replacement
;
714 if (EQ (XWINDOW (tem
)->hchild
, old
))
715 XWINDOW (tem
)->hchild
= replacement
;
718 /*** Here, if replacement is a vertical combination
719 and so is its new parent, we should make replacement's
720 children be children of that parent instead. ***/
723 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
724 "Remove WINDOW from the display. Default is selected window.")
726 register Lisp_Object window
;
728 register Lisp_Object tem
, parent
, sib
;
729 register struct window
*p
;
730 register struct window
*par
;
732 /* Because this function is called by other C code on non-leaf
733 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
734 so we can't decode_window here. */
736 window
= selected_window
;
738 CHECK_WINDOW (window
, 0);
739 p
= XWINDOW (window
);
741 /* It's okay to delete an already-deleted window. */
749 error ("Attempt to delete minibuffer or sole ordinary window");
750 par
= XWINDOW (parent
);
752 windows_or_buffers_changed
++;
754 /* Are we trying to delete any frame's selected window? */
756 Lisp_Object frame
, pwindow
;
758 /* See if the frame's selected window is either WINDOW
759 or any subwindow of it, by finding all that window's parents
760 and comparing each one with WINDOW. */
761 frame
= WINDOW_FRAME (XWINDOW (window
));
762 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
764 while (!NILP (pwindow
))
766 if (EQ (window
, pwindow
))
768 pwindow
= XWINDOW (pwindow
)->parent
;
771 if (EQ (window
, pwindow
))
773 Lisp_Object alternative
;
774 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
776 /* If we're about to delete the selected window on the
777 selected frame, then we should use Fselect_window to select
778 the new window. On the other hand, if we're about to
779 delete the selected window on any other frame, we shouldn't do
780 anything but set the frame's selected_window slot. */
781 if (EQ (window
, selected_window
))
782 Fselect_window (alternative
);
784 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
789 /* tem is null for dummy parent windows
790 (which have inferiors but not any contents themselves) */
794 unchain_marker (p
->pointm
);
795 unchain_marker (p
->start
);
800 XWINDOW (tem
)->prev
= p
->prev
;
804 XWINDOW (tem
)->next
= p
->next
;
806 if (EQ (window
, par
->hchild
))
807 par
->hchild
= p
->next
;
808 if (EQ (window
, par
->vchild
))
809 par
->vchild
= p
->next
;
811 /* Find one of our siblings to give our space to. */
815 /* If p gives its space to its next sibling, that sibling needs
816 to have its top/left side pulled back to where p's is.
817 set_window_{height,width} will re-position the sibling's
820 XWINDOW (sib
)->top
= p
->top
;
821 XWINDOW (sib
)->left
= p
->left
;
824 /* Stretch that sibling. */
825 if (!NILP (par
->vchild
))
826 set_window_height (sib
,
827 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
829 if (!NILP (par
->hchild
))
830 set_window_width (sib
,
831 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
834 /* If parent now has only one child,
835 put the child into the parent's place. */
839 if (NILP (XWINDOW (tem
)->next
))
840 replace_window (parent
, tem
);
842 /* Since we may be deleting combination windows, we must make sure that
843 not only p but all its children have been marked as deleted. */
844 if (! NILP (p
->hchild
))
845 delete_all_subwindows (XWINDOW (p
->hchild
));
846 else if (! NILP (p
->vchild
))
847 delete_all_subwindows (XWINDOW (p
->vchild
));
849 /* Mark this window as deleted. */
850 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
856 extern Lisp_Object
next_frame (), prev_frame ();
858 /* This comment supplies the doc string for `next-window',
859 for make-docfile to see. We cannot put this in the real DEFUN
860 due to limits in the Unix cpp.
862 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
863 "Return next window after WINDOW in canonical ordering of windows.\n\
864 If omitted, WINDOW defaults to the selected window.\n\
866 Optional second arg MINIBUF t means count the minibuffer window even\n\
867 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
868 it is active. MINIBUF neither t nor nil means not to count the\n\
869 minibuffer even if it is active.\n\
871 Several frames may share a single minibuffer; if the minibuffer\n\
872 counts, all windows on all frames that share that minibuffer count\n\
873 too. Therefore, `next-window' can be used to iterate through the\n\
874 set of windows even when the minibuffer is on another frame. If the\n\
875 minibuffer does not count, only windows from WINDOW's frame count.\n\
877 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
878 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
879 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
880 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
881 Anything else means restrict to WINDOW's frame.\n\
883 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
884 `next-window' to iterate through the entire cycle of acceptable\n\
885 windows, eventually ending up back at the window you started with.\n\
886 `previous-window' traverses the same cycle, in the reverse order.")
887 (window, minibuf, all_frames) */
889 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
891 (window
, minibuf
, all_frames
)
892 register Lisp_Object window
, minibuf
, all_frames
;
894 register Lisp_Object tem
;
895 Lisp_Object start_window
;
898 window
= selected_window
;
900 CHECK_LIVE_WINDOW (window
, 0);
902 start_window
= window
;
904 /* minibuf == nil may or may not include minibuffers.
905 Decide if it does. */
907 minibuf
= (minibuf_level
? Qt
: Qlambda
);
910 /* all_frames == nil doesn't specify which frames to include. */
911 if (NILP (all_frames
))
912 all_frames
= (EQ (minibuf
, Qt
)
913 ? (FRAME_MINIBUF_WINDOW
916 (XWINDOW (window
)))))
918 else if (EQ (all_frames
, Qvisible
))
920 else if (XFASTINT (all_frames
) == 0)
922 else if (! EQ (all_frames
, Qt
))
924 /* Now all_frames is t meaning search all frames,
925 nil meaning search just current frame,
926 visible meaning search just visible frames,
927 0 meaning search visible and iconified frames,
928 or a window, meaning search the frame that window belongs to. */
931 /* Do this loop at least once, to get the next window, and perhaps
932 again, if we hit the minibuffer and that is not acceptable. */
935 /* Find a window that actually has a next one. This loop
936 climbs up the tree. */
937 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
938 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
942 /* We've reached the end of this frame.
943 Which other frames are acceptable? */
944 tem
= WINDOW_FRAME (XWINDOW (window
));
946 if (! NILP (all_frames
))
951 tem
= next_frame (tem
, all_frames
);
952 /* In the case where the minibuffer is active,
953 and we include its frame as well as the selected one,
954 next_frame may get stuck in that frame.
955 If that happens, go back to the selected frame
956 so we can complete the cycle. */
958 XSETFRAME (tem
, selected_frame
);
961 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
968 /* If we're in a combination window, find its first child and
969 recurse on that. Otherwise, we've found the window we want. */
972 if (!NILP (XWINDOW (window
)->hchild
))
973 window
= XWINDOW (window
)->hchild
;
974 else if (!NILP (XWINDOW (window
)->vchild
))
975 window
= XWINDOW (window
)->vchild
;
979 /* Which windows are acceptible?
980 Exit the loop and accept this window if
981 this isn't a minibuffer window, or
982 we're accepting minibuffer windows, or
983 we've come all the way around and we're back at the original window. */
984 while (MINI_WINDOW_P (XWINDOW (window
))
985 && ! EQ (minibuf
, Qt
)
986 && ! EQ (window
, start_window
));
991 /* This comment supplies the doc string for `previous-window',
992 for make-docfile to see. We cannot put this in the real DEFUN
993 due to limits in the Unix cpp.
995 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
996 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
997 If omitted, WINDOW defaults to the selected window.\n\
999 Optional second arg MINIBUF t means count the minibuffer window even\n\
1000 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1001 it is active. MINIBUF neither t nor nil means not to count the\n\
1002 minibuffer even if it is active.\n\
1004 Several frames may share a single minibuffer; if the minibuffer\n\
1005 counts, all windows on all frames that share that minibuffer count\n\
1006 too. Therefore, `previous-window' can be used to iterate through\n\
1007 the set of windows even when the minibuffer is on another frame. If\n\
1008 the minibuffer does not count, only windows from WINDOW's frame count\n\
1010 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1011 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1012 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1013 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1014 Anything else means restrict to WINDOW's frame.\n\
1016 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1017 `previous-window' to iterate through the entire cycle of acceptable\n\
1018 windows, eventually ending up back at the window you started with.\n\
1019 `next-window' traverses the same cycle, in the reverse order.")
1020 (window, minibuf, all_frames) */
1023 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1025 (window
, minibuf
, all_frames
)
1026 register Lisp_Object window
, minibuf
, all_frames
;
1028 register Lisp_Object tem
;
1029 Lisp_Object start_window
;
1032 window
= selected_window
;
1034 CHECK_LIVE_WINDOW (window
, 0);
1036 start_window
= window
;
1038 /* minibuf == nil may or may not include minibuffers.
1039 Decide if it does. */
1041 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1044 /* all_frames == nil doesn't specify which frames to include.
1045 Decide which frames it includes. */
1046 if (NILP (all_frames
))
1047 all_frames
= (EQ (minibuf
, Qt
)
1048 ? (FRAME_MINIBUF_WINDOW
1051 (XWINDOW (window
)))))
1053 else if (EQ (all_frames
, Qvisible
))
1055 else if (XFASTINT (all_frames
) == 0)
1057 else if (! EQ (all_frames
, Qt
))
1059 /* Now all_frames is t meaning search all frames,
1060 nil meaning search just current frame,
1061 visible meaning search just visible frames,
1062 0 meaning search visible and iconified frames,
1063 or a window, meaning search the frame that window belongs to. */
1066 /* Do this loop at least once, to get the previous window, and perhaps
1067 again, if we hit the minibuffer and that is not acceptable. */
1070 /* Find a window that actually has a previous one. This loop
1071 climbs up the tree. */
1072 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1073 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1077 /* We have found the top window on the frame.
1078 Which frames are acceptable? */
1079 tem
= WINDOW_FRAME (XWINDOW (window
));
1081 if (! NILP (all_frames
))
1082 /* It's actually important that we use prev_frame here,
1083 rather than next_frame. All the windows acceptable
1084 according to the given parameters should form a ring;
1085 Fnext_window and Fprevious_window should go back and
1086 forth around the ring. If we use next_frame here,
1087 then Fnext_window and Fprevious_window take different
1088 paths through the set of acceptable windows.
1089 window_loop assumes that these `ring' requirement are
1095 tem
= prev_frame (tem
, all_frames
);
1096 /* In the case where the minibuffer is active,
1097 and we include its frame as well as the selected one,
1098 next_frame may get stuck in that frame.
1099 If that happens, go back to the selected frame
1100 so we can complete the cycle. */
1102 XSETFRAME (tem
, selected_frame
);
1105 /* If this frame has a minibuffer, find that window first,
1106 because it is conceptually the last window in that frame. */
1107 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1108 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1110 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1116 /* If we're in a combination window, find its last child and
1117 recurse on that. Otherwise, we've found the window we want. */
1120 if (!NILP (XWINDOW (window
)->hchild
))
1121 window
= XWINDOW (window
)->hchild
;
1122 else if (!NILP (XWINDOW (window
)->vchild
))
1123 window
= XWINDOW (window
)->vchild
;
1125 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1129 /* Which windows are acceptable?
1130 Exit the loop and accept this window if
1131 this isn't a minibuffer window, or
1132 we're accepting minibuffer windows, or
1133 we've come all the way around and we're back at the original window. */
1134 while (MINI_WINDOW_P (XWINDOW (window
))
1135 && !EQ (minibuf
, Qt
)
1136 && !EQ (window
, start_window
));
1141 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1142 "Select the ARG'th different window on this frame.\n\
1143 All windows on current frame are arranged in a cyclic order.\n\
1144 This command selects the window ARG steps away in that order.\n\
1145 A negative ARG moves in the opposite order. If the optional second\n\
1146 argument ALL_FRAMES is non-nil, cycle through all frames.")
1148 register Lisp_Object n
, all_frames
;
1151 register Lisp_Object w
;
1153 CHECK_NUMBER (n
, 0);
1154 w
= selected_window
;
1159 w
= Fnext_window (w
, Qnil
, all_frames
);
1164 w
= Fprevious_window (w
, Qnil
, all_frames
);
1171 /* Look at all windows, performing an operation specified by TYPE
1173 If FRAMES is Qt, look at all frames;
1174 Qnil, look at just the selected frame;
1175 Qvisible, look at visible frames;
1176 a frame, just look at windows on that frame.
1177 If MINI is non-zero, perform the operation on minibuffer windows too.
1183 GET_BUFFER_WINDOW
, /* Arg is buffer */
1184 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1185 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1186 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1188 UNSHOW_BUFFER
/* Arg is buffer */
1192 window_loop (type
, obj
, mini
, frames
)
1193 enum window_loop type
;
1194 register Lisp_Object obj
, frames
;
1197 register Lisp_Object w
;
1198 register Lisp_Object best_window
;
1199 register Lisp_Object next_window
;
1200 register Lisp_Object last_window
;
1202 Lisp_Object frame_arg
;
1206 /* If we're only looping through windows on a particular frame,
1207 frame points to that frame. If we're looping through windows
1208 on all frames, frame is 0. */
1209 if (FRAMEP (frames
))
1210 frame
= XFRAME (frames
);
1211 else if (NILP (frames
))
1212 frame
= selected_frame
;
1216 frame_arg
= Qlambda
;
1217 else if (XFASTINT (frames
) == 0)
1219 else if (EQ (frames
, Qvisible
))
1225 /* frame_arg is Qlambda to stick to one frame,
1226 Qvisible to consider all visible frames,
1229 /* Pick a window to start with. */
1233 w
= FRAME_SELECTED_WINDOW (frame
);
1235 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1237 /* Figure out the last window we're going to mess with. Since
1238 Fnext_window, given the same options, is guaranteed to go in a
1239 ring, we can just use Fprevious_window to find the last one.
1241 We can't just wait until we hit the first window again, because
1242 it might be deleted. */
1244 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1249 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1251 /* Pick the next window now, since some operations will delete
1252 the current window. */
1253 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1255 /* Note that we do not pay attention here to whether
1256 the frame is visible, since Fnext_window skips non-visible frames
1257 if that is desired, under the control of frame_arg. */
1258 if (! MINI_WINDOW_P (XWINDOW (w
))
1259 || (mini
&& minibuf_level
> 0))
1262 case GET_BUFFER_WINDOW
:
1263 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1267 case GET_LRU_WINDOW
:
1268 /* t as arg means consider only full-width windows */
1269 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1270 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1272 /* Ignore dedicated windows and minibuffers. */
1273 if (MINI_WINDOW_P (XWINDOW (w
))
1274 || !NILP (XWINDOW (w
)->dedicated
))
1276 if (NILP (best_window
)
1277 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1278 > XFASTINT (XWINDOW (w
)->use_time
)))
1282 case DELETE_OTHER_WINDOWS
:
1283 if (XWINDOW (w
) != XWINDOW (obj
))
1287 case DELETE_BUFFER_WINDOWS
:
1288 if (EQ (XWINDOW (w
)->buffer
, obj
))
1290 /* If we're deleting the buffer displayed in the only window
1291 on the frame, find a new buffer to display there. */
1292 if (NILP (XWINDOW (w
)->parent
))
1294 Lisp_Object new_buffer
;
1295 new_buffer
= Fother_buffer (obj
, Qnil
);
1296 if (NILP (new_buffer
))
1298 = Fget_buffer_create (build_string ("*scratch*"));
1299 Fset_window_buffer (w
, new_buffer
);
1300 if (EQ (w
, selected_window
))
1301 Fset_buffer (XWINDOW (w
)->buffer
);
1308 case GET_LARGEST_WINDOW
:
1309 /* Ignore dedicated windows and minibuffers. */
1310 if (MINI_WINDOW_P (XWINDOW (w
))
1311 || !NILP (XWINDOW (w
)->dedicated
))
1314 struct window
*best_window_ptr
= XWINDOW (best_window
);
1315 struct window
*w_ptr
= XWINDOW (w
);
1316 if (NILP (best_window
)
1317 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1318 > (XFASTINT (best_window_ptr
->height
)
1319 * XFASTINT (best_window_ptr
->width
))))
1325 if (EQ (XWINDOW (w
)->buffer
, obj
))
1327 /* Find another buffer to show in this window. */
1328 Lisp_Object another_buffer
;
1329 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1330 another_buffer
= Fother_buffer (obj
, Qnil
);
1331 if (NILP (another_buffer
))
1333 = Fget_buffer_create (build_string ("*scratch*"));
1335 /* If this window is dedicated, and in a frame of its own,
1337 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1338 && !NILP (XWINDOW (w
)->dedicated
)
1339 && other_visible_frames (f
))
1341 /* Skip the other windows on this frame.
1342 There might be one, the minibuffer! */
1343 if (! EQ (w
, last_window
))
1344 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1346 /* As we go, check for the end of the loop.
1347 We mustn't start going around a second time. */
1348 if (EQ (next_window
, last_window
))
1353 next_window
= Fnext_window (next_window
,
1357 /* Now we can safely delete the frame. */
1358 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1363 /* Otherwise show a different buffer in the window. */
1364 XWINDOW (w
)->dedicated
= Qnil
;
1365 Fset_window_buffer (w
, another_buffer
);
1366 if (EQ (w
, selected_window
))
1367 Fset_buffer (XWINDOW (w
)->buffer
);
1373 if (EQ (w
, last_window
))
1382 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1383 "Return the window least recently selected or used for display.\n\
1384 If optional argument FRAME is `visible', search all visible frames.\n\
1385 If FRAME is 0, search all visible and iconified frames.\n\
1386 If FRAME is t, search all frames.\n\
1387 If FRAME is nil, search only the selected frame.\n\
1388 If FRAME is a frame, search only that frame.")
1392 register Lisp_Object w
;
1393 /* First try for a window that is full-width */
1394 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1395 if (!NILP (w
) && !EQ (w
, selected_window
))
1397 /* If none of them, try the rest */
1398 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1401 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1402 "Return the largest window in area.\n\
1403 If optional argument FRAME is `visible', search all visible frames.\n\
1404 If FRAME is 0, search all visible and iconified frames.\n\
1405 If FRAME is t, search all frames.\n\
1406 If FRAME is nil, search only the selected frame.\n\
1407 If FRAME is a frame, search only that frame.")
1411 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1415 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1416 "Return a window currently displaying BUFFER, or nil if none.\n\
1417 If optional argument FRAME is `visible', search all visible frames.\n\
1418 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1419 If FRAME is t, search all frames.\n\
1420 If FRAME is nil, search only the selected frame.\n\
1421 If FRAME is a frame, search only that frame.")
1423 Lisp_Object buffer
, frame
;
1425 buffer
= Fget_buffer (buffer
);
1426 if (BUFFERP (buffer
))
1427 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1432 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1434 "Make WINDOW (or the selected window) fill its frame.\n\
1435 Only the frame WINDOW is on is affected.\n\
1436 This function tries to reduce display jumps\n\
1437 by keeping the text previously visible in WINDOW\n\
1438 in the same place on the frame. Doing this depends on\n\
1439 the value of (window-start WINDOW), so if calling this function\n\
1440 in a program gives strange scrolling, make sure the window-start\n\
1441 value is reasonable when this function is called.")
1450 window
= selected_window
;
1452 CHECK_LIVE_WINDOW (window
, 0);
1454 w
= XWINDOW (window
);
1456 startpos
= marker_position (w
->start
);
1457 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1459 if (MINI_WINDOW_P (w
) && top
> 0)
1460 error ("Can't expand minibuffer to full frame");
1462 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1464 /* Try to minimize scrolling, by setting the window start to the point
1465 will cause the text at the old window start to be at the same place
1466 on the frame. But don't try to do this if the window start is
1467 outside the visible portion (as might happen when the display is
1468 not current, due to typeahead). */
1469 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1470 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1472 struct position pos
;
1473 struct buffer
*obuf
= current_buffer
;
1475 Fset_buffer (w
->buffer
);
1476 /* This computation used to temporarily move point, but that can
1477 have unwanted side effects due to text properties. */
1478 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1479 XINT (w
->hscroll
), window
);
1480 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1481 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1482 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1485 set_buffer_internal (obuf
);
1490 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1491 1, 2, "bDelete windows on (buffer): ",
1492 "Delete all windows showing BUFFER.\n\
1493 Optional second argument FRAME controls which frames are affected.\n\
1494 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1495 If t, delete only windows showing BUFFER in the selected frame.\n\
1496 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1497 If a frame, delete only windows showing BUFFER in that frame.")
1499 Lisp_Object buffer
, frame
;
1502 /* FRAME uses t and nil to mean the opposite of what window_loop
1504 if (! FRAMEP (frame
))
1505 frame
= NILP (frame
) ? Qt
: Qnil
;
1512 buffer
= Fget_buffer (buffer
);
1513 CHECK_BUFFER (buffer
, 0);
1514 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1519 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1520 Sreplace_buffer_in_windows
,
1521 1, 1, "bReplace buffer in windows: ",
1522 "Replace BUFFER with some other buffer in all windows showing it.")
1528 buffer
= Fget_buffer (buffer
);
1529 CHECK_BUFFER (buffer
, 0);
1530 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1535 /* Set the height of WINDOW and all its inferiors. */
1537 /* The smallest acceptable dimensions for a window. Anything smaller
1538 might crash Emacs. */
1539 #define MIN_SAFE_WINDOW_WIDTH (2)
1540 #define MIN_SAFE_WINDOW_HEIGHT (2)
1542 /* Make sure that window_min_height and window_min_width are
1543 not too small; if they are, set them to safe minima. */
1546 check_min_window_sizes ()
1548 /* Smaller values might permit a crash. */
1549 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1550 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1551 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1552 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1555 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1556 minimum allowable size. */
1558 check_frame_size (frame
, rows
, cols
)
1562 /* For height, we have to see:
1563 whether the frame has a minibuffer,
1564 whether it wants a mode line, and
1565 whether it has a menu bar. */
1567 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1568 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1569 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1570 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1571 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1573 if (*rows
< min_height
)
1575 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1576 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1579 /* Normally the window is deleted if it gets too small.
1580 nodelete nonzero means do not do this.
1581 (The caller should check later and do so if appropriate) */
1583 set_window_height (window
, height
, nodelete
)
1588 register struct window
*w
= XWINDOW (window
);
1589 register struct window
*c
;
1590 int oheight
= XFASTINT (w
->height
);
1591 int top
, pos
, lastbot
, opos
, lastobot
;
1594 check_min_window_sizes ();
1597 && ! NILP (w
->parent
)
1598 && height
< window_min_height
)
1600 Fdelete_window (window
);
1604 XSETFASTINT (w
->last_modified
, 0);
1605 windows_or_buffers_changed
++;
1606 XSETFASTINT (w
->height
, height
);
1607 if (!NILP (w
->hchild
))
1609 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1611 XWINDOW (child
)->top
= w
->top
;
1612 set_window_height (child
, height
, nodelete
);
1615 else if (!NILP (w
->vchild
))
1617 lastbot
= top
= XFASTINT (w
->top
);
1619 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1621 c
= XWINDOW (child
);
1623 opos
= lastobot
+ XFASTINT (c
->height
);
1625 XSETFASTINT (c
->top
, lastbot
);
1627 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1629 /* Avoid confusion: inhibit deletion of child if becomes too small */
1630 set_window_height (child
, pos
+ top
- lastbot
, 1);
1632 /* Now advance child to next window,
1633 and set lastbot if child was not just deleted. */
1634 lastbot
= pos
+ top
;
1637 /* Now delete any children that became too small. */
1639 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1641 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1646 /* Recursively set width of WINDOW and its inferiors. */
1648 set_window_width (window
, width
, nodelete
)
1653 register struct window
*w
= XWINDOW (window
);
1654 register struct window
*c
;
1655 int owidth
= XFASTINT (w
->width
);
1656 int left
, pos
, lastright
, opos
, lastoright
;
1659 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1661 Fdelete_window (window
);
1665 XSETFASTINT (w
->last_modified
, 0);
1666 windows_or_buffers_changed
++;
1667 XSETFASTINT (w
->width
, width
);
1668 if (!NILP (w
->vchild
))
1670 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1672 XWINDOW (child
)->left
= w
->left
;
1673 set_window_width (child
, width
, nodelete
);
1676 else if (!NILP (w
->hchild
))
1678 lastright
= left
= XFASTINT (w
->left
);
1680 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1682 c
= XWINDOW (child
);
1684 opos
= lastoright
+ XFASTINT (c
->width
);
1686 XSETFASTINT (c
->left
, lastright
);
1688 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1690 /* Inhibit deletion for becoming too small */
1691 set_window_width (child
, pos
+ left
- lastright
, 1);
1693 /* Now advance child to next window,
1694 and set lastright if child was not just deleted. */
1695 lastright
= pos
+ left
, lastoright
= opos
;
1697 /* Delete children that became too small */
1699 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1701 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1706 int window_select_count
;
1708 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1709 "Make WINDOW display BUFFER as its contents.\n\
1710 BUFFER can be a buffer or buffer name.")
1712 register Lisp_Object window
, buffer
;
1714 register Lisp_Object tem
;
1715 register struct window
*w
= decode_window (window
);
1717 buffer
= Fget_buffer (buffer
);
1718 CHECK_BUFFER (buffer
, 1);
1720 if (NILP (XBUFFER (buffer
)->name
))
1721 error ("Attempt to display deleted buffer");
1725 error ("Window is deleted");
1726 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1727 is first being set up. */
1729 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1730 error ("Window is dedicated to `%s'",
1731 XSTRING (XBUFFER (tem
)->name
)->data
);
1737 XSETFASTINT (w
->window_end_pos
, 0);
1738 w
->window_end_valid
= Qnil
;
1739 XSETFASTINT(w
->hscroll
, 0);
1740 Fset_marker (w
->pointm
,
1741 make_number (BUF_PT (XBUFFER (buffer
))),
1743 set_marker_restricted (w
->start
,
1744 make_number (XBUFFER (buffer
)->last_window_start
),
1746 w
->start_at_line_beg
= Qnil
;
1747 w
->force_start
= Qnil
;
1748 XSETFASTINT (w
->last_modified
, 0);
1749 windows_or_buffers_changed
++;
1750 if (EQ (window
, selected_window
))
1751 Fset_buffer (buffer
);
1756 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1757 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1758 The main editor command loop selects the buffer of the selected window\n\
1759 before each command.")
1761 register Lisp_Object window
;
1763 register struct window
*w
;
1764 register struct window
*ow
= XWINDOW (selected_window
);
1766 CHECK_LIVE_WINDOW (window
, 0);
1768 w
= XWINDOW (window
);
1770 if (NILP (w
->buffer
))
1771 error ("Trying to select deleted window or non-leaf window");
1773 XSETFASTINT (w
->use_time
, ++window_select_count
);
1774 if (EQ (window
, selected_window
))
1777 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1780 selected_window
= window
;
1782 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1784 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1785 /* Use this rather than Fhandle_switch_frame
1786 so that FRAME_FOCUS_FRAME is moved appropriately as we
1787 move around in the state where a minibuffer in a separate
1789 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1792 selected_frame
->selected_window
= window
;
1795 record_buffer (w
->buffer
);
1796 Fset_buffer (w
->buffer
);
1798 /* Go to the point recorded in the window.
1799 This is important when the buffer is in more
1800 than one window. It also matters when
1801 redisplay_window has altered point after scrolling,
1802 because it makes the change only in the window. */
1804 register int new_point
= marker_position (w
->pointm
);
1805 if (new_point
< BEGV
)
1807 else if (new_point
> ZV
)
1813 windows_or_buffers_changed
++;
1817 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1818 "bDisplay buffer: \nP",
1819 "Make BUFFER appear in some window but don't select it.\n\
1820 BUFFER can be a buffer or a buffer name.\n\
1821 If BUFFER is shown already in some window, just use that one,\n\
1822 unless the window is the selected window and the optional second\n\
1823 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1824 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1825 Returns the window displaying BUFFER.")
1826 (buffer
, not_this_window
)
1827 register Lisp_Object buffer
, not_this_window
;
1829 register Lisp_Object window
, tem
;
1831 buffer
= Fget_buffer (buffer
);
1832 CHECK_BUFFER (buffer
, 0);
1834 if (!NILP (Vdisplay_buffer_function
))
1835 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1837 if (NILP (not_this_window
)
1838 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1839 return selected_window
;
1842 /* If pop_up_frames,
1843 look for a window showing BUFFER on any visible or iconified frame. */
1844 window
= Fget_buffer_window (buffer
, pop_up_frames
? make_number (0) : Qnil
);
1846 window
= Fget_buffer_window (buffer
, Qnil
);
1849 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1852 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1853 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1858 /* Certain buffer names get special handling. */
1859 if (! NILP (Vspecial_display_function
))
1861 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1863 return call1 (Vspecial_display_function
, buffer
);
1865 tem
= Fassoc (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1867 return call2 (Vspecial_display_function
, buffer
, XCONS (tem
)->cdr
);
1869 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1871 Lisp_Object car
= XCONS (tem
)->car
;
1873 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1874 return call1 (Vspecial_display_function
, buffer
);
1875 else if (CONSP (car
)
1876 && STRINGP (XCONS (car
)->car
)
1877 && fast_string_match (XCONS (car
)->car
,
1878 XBUFFER (buffer
)->name
) >= 0)
1879 return call2 (Vspecial_display_function
,
1886 /* If there are no frames open that have more than a minibuffer,
1887 we need to create a new frame. */
1888 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1890 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1891 Fset_window_buffer (window
, buffer
);
1894 #endif /* MULTI_FRAME */
1898 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1899 /* If the current frame is a special display frame,
1900 don't try to reuse its windows. */
1901 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
1909 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1910 XSETFRAME (frames
, last_nonminibuf_frame
);
1912 /* Don't try to create a window if would get an error */
1913 if (split_height_threshold
< window_min_height
<< 1)
1914 split_height_threshold
= window_min_height
<< 1;
1916 /* Note that both Fget_largest_window and Fget_lru_window
1917 ignore minibuffers and dedicated windows.
1918 This means they can return nil. */
1921 /* If the frame we would try to split cannot be split,
1922 try other frames. */
1923 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
1924 : last_nonminibuf_frame
))
1926 /* Try visible frames first. */
1927 window
= Fget_largest_window (Qvisible
);
1928 /* If that didn't work, try iconified frames. */
1930 window
= Fget_largest_window (make_number (0));
1932 window
= Fget_largest_window (Qt
);
1936 window
= Fget_largest_window (frames
);
1938 /* If we got a tall enough full-width window that can be split,
1941 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
1942 && window_height (window
) >= split_height_threshold
1943 && (XFASTINT (XWINDOW (window
)->width
)
1944 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1945 window
= Fsplit_window (window
, Qnil
, Qnil
);
1948 Lisp_Object upper
, lower
, other
;
1950 window
= Fget_lru_window (frames
);
1951 /* If the LRU window is selected, and big enough,
1952 and can be split, split it. */
1954 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
1955 && (EQ (window
, selected_window
)
1956 || EQ (XWINDOW (window
)->parent
, Qnil
))
1957 && window_height (window
) >= window_min_height
<< 1)
1958 window
= Fsplit_window (window
, Qnil
, Qnil
);
1960 /* If Fget_lru_window returned nil, try other approaches. */
1961 /* Try visible frames first. */
1963 window
= Fget_largest_window (Qvisible
);
1964 /* If that didn't work, try iconified frames. */
1966 window
= Fget_largest_window (make_number (0));
1967 /* Try invisible frames. */
1969 window
= Fget_largest_window (Qt
);
1970 /* As a last resort, make a new frame. */
1972 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1974 /* As a last resort, use a non minibuffer window. */
1976 window
= Fframe_first_window (Fselected_frame ());
1978 /* If window appears above or below another,
1979 even out their heights. */
1980 if (!NILP (XWINDOW (window
)->prev
))
1981 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
1982 if (!NILP (XWINDOW (window
)->next
))
1983 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
1985 /* Check that OTHER and WINDOW are vertically arrayed. */
1986 && XWINDOW (other
)->top
!= XWINDOW (window
)->top
1987 && XWINDOW (other
)->height
> XWINDOW (window
)->height
)
1989 int total
= XWINDOW (other
)->height
+ XWINDOW (window
)->height
;
1990 Lisp_Object old_selected_window
;
1991 old_selected_window
= selected_window
;
1993 selected_window
= upper
;
1994 change_window_height (total
/ 2 - XWINDOW (upper
)->height
, 0);
1995 selected_window
= old_selected_window
;
2000 window
= Fget_lru_window (Qnil
);
2002 Fset_window_buffer (window
, buffer
);
2007 temp_output_buffer_show (buf
)
2008 register Lisp_Object buf
;
2010 register struct buffer
*old
= current_buffer
;
2011 register Lisp_Object window
;
2012 register struct window
*w
;
2015 BUF_SAVE_MODIFF (XBUFFER (buf
)) = MODIFF
;
2020 set_buffer_internal (old
);
2022 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
2023 call1 (Vtemp_buffer_show_function
, buf
);
2026 window
= Fdisplay_buffer (buf
, Qnil
);
2029 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2030 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2031 #endif /* MULTI_FRAME */
2032 Vminibuf_scroll_window
= window
;
2033 w
= XWINDOW (window
);
2034 XSETFASTINT (w
->hscroll
, 0);
2035 set_marker_restricted (w
->start
, make_number (1), buf
);
2036 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2041 make_dummy_parent (window
)
2045 register struct window
*o
, *p
;
2046 register struct Lisp_Vector
*vec
;
2049 o
= XWINDOW (window
);
2050 vec
= allocate_vectorlike ((EMACS_INT
)VECSIZE (struct window
));
2051 for (i
= 0; i
< VECSIZE (struct window
); ++i
)
2052 vec
->contents
[i
] = ((struct Lisp_Vector
*)o
)->contents
[i
];
2053 vec
->size
= VECSIZE (struct window
);
2054 p
= (struct window
*)vec
;
2055 XSETWINDOW (new, p
);
2057 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
2059 /* Put new into window structure in place of window */
2060 replace_window (window
, new);
2073 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2074 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2075 WINDOW defaults to selected one and SIZE to half its size.\n\
2076 If optional third arg HOR-FLAG is non-nil, split side by side\n\
2077 and put SIZE columns in the first of the pair.")
2078 (window
, chsize
, horflag
)
2079 Lisp_Object window
, chsize
, horflag
;
2081 register Lisp_Object
new;
2082 register struct window
*o
, *p
;
2086 window
= selected_window
;
2088 CHECK_LIVE_WINDOW (window
, 0);
2090 o
= XWINDOW (window
);
2094 if (!NILP (horflag
))
2095 /* Round odd size up, since this is for the left-hand window,
2096 and it will lose a column for the separators. */
2097 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
2099 size
= XFASTINT (o
->height
) >> 1;
2103 CHECK_NUMBER (chsize
, 1);
2104 size
= XINT (chsize
);
2107 if (MINI_WINDOW_P (o
))
2108 error ("Attempt to split minibuffer window");
2109 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
2110 error ("Attempt to split unsplittable frame");
2112 check_min_window_sizes ();
2116 if (size
< window_min_height
2117 || size
+ window_min_height
> XFASTINT (o
->height
))
2118 args_out_of_range_3 (window
, chsize
, horflag
);
2119 if (NILP (o
->parent
)
2120 || NILP (XWINDOW (o
->parent
)->vchild
))
2122 make_dummy_parent (window
);
2124 XWINDOW (new)->vchild
= window
;
2129 if (size
< window_min_width
2130 || size
+ window_min_width
> XFASTINT (o
->width
))
2131 args_out_of_range_3 (window
, chsize
, horflag
);
2132 if (NILP (o
->parent
)
2133 || NILP (XWINDOW (o
->parent
)->hchild
))
2135 make_dummy_parent (window
);
2137 XWINDOW (new)->hchild
= window
;
2141 /* Now we know that window's parent is a vertical combination
2142 if we are dividing vertically, or a horizontal combination
2143 if we are making side-by-side windows */
2145 windows_or_buffers_changed
++;
2146 new = make_window ();
2149 p
->frame
= o
->frame
;
2151 if (!NILP (p
->next
))
2152 XWINDOW (p
->next
)->prev
= new;
2155 p
->parent
= o
->parent
;
2158 Fset_window_buffer (new, o
->buffer
);
2160 /* Apportion the available frame space among the two new windows */
2162 if (!NILP (horflag
))
2164 p
->height
= o
->height
;
2166 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size
);
2167 XSETFASTINT (o
->width
, size
);
2168 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size
);
2173 p
->width
= o
->width
;
2174 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size
);
2175 XSETFASTINT (o
->height
, size
);
2176 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size
);
2182 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2183 "Make current window ARG lines bigger.\n\
2184 From program, optional second arg non-nil means grow sideways ARG columns.")
2186 register Lisp_Object n
, side
;
2188 CHECK_NUMBER (n
, 0);
2189 change_window_height (XINT (n
), !NILP (side
));
2193 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2194 "Make current window ARG lines smaller.\n\
2195 From program, optional second arg non-nil means shrink sideways ARG columns.")
2197 register Lisp_Object n
, side
;
2199 CHECK_NUMBER (n
, 0);
2200 change_window_height (-XINT (n
), !NILP (side
));
2205 window_height (window
)
2208 register struct window
*p
= XWINDOW (window
);
2209 return XFASTINT (p
->height
);
2213 window_width (window
)
2216 register struct window
*p
= XWINDOW (window
);
2217 return XFASTINT (p
->width
);
2220 #define MINSIZE(w) \
2222 ? window_min_width \
2223 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2226 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2228 #define CURSIZE(w) \
2229 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2231 /* Unlike set_window_height, this function
2232 also changes the heights of the siblings so as to
2233 keep everything consistent. */
2235 change_window_height (delta
, widthflag
)
2239 register Lisp_Object parent
;
2241 register struct window
*p
;
2243 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2244 register int (*setsizefun
) () = (widthflag
2246 : set_window_height
);
2248 check_min_window_sizes ();
2250 window
= selected_window
;
2253 p
= XWINDOW (window
);
2258 error ("No other window to side of this one");
2261 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2262 : !NILP (XWINDOW (parent
)->vchild
))
2267 sizep
= &CURSIZE (window
);
2270 register int maxdelta
;
2272 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2273 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2274 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2275 /* This is a frame with only one window, a minibuffer-only
2276 or a minibufferless frame. */
2279 if (delta
> maxdelta
)
2280 /* This case traps trying to make the minibuffer
2281 the full frame, or make the only window aside from the
2282 minibuffer the full frame. */
2286 if (*sizep
+ delta
< MINSIZE (window
))
2288 Fdelete_window (window
);
2296 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2298 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2299 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2300 CURBEG (p
->next
) += delta
;
2301 /* This does not change size of p->next,
2302 but it propagates the new top edge to its children */
2303 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2305 else if (!NILP (p
->prev
)
2306 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2308 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2309 CURBEG (window
) -= delta
;
2310 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2314 register int delta1
;
2315 register int opht
= (*sizefun
) (parent
);
2317 /* If trying to grow this window to or beyond size of the parent,
2318 make delta1 so big that, on shrinking back down,
2319 all the siblings end up with less than one line and are deleted. */
2320 if (opht
<= *sizep
+ delta
)
2321 delta1
= opht
* opht
* 2;
2322 /* Otherwise, make delta1 just right so that if we add delta1
2323 lines to this window and to the parent, and then shrink
2324 the parent back to its original size, the new proportional
2325 size of this window will increase by delta. */
2327 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2329 /* Add delta1 lines or columns to this window, and to the parent,
2330 keeping things consistent while not affecting siblings. */
2331 CURSIZE (parent
) = opht
+ delta1
;
2332 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2334 /* Squeeze out delta1 lines or columns from our parent,
2335 shriking this window and siblings proportionately.
2336 This brings parent back to correct size.
2337 Delta1 was calculated so this makes this window the desired size,
2338 taking it all out of the siblings. */
2339 (*setsizefun
) (parent
, opht
, 0);
2342 XSETFASTINT (p
->last_modified
, 0);
2349 /* Return number of lines of text (not counting mode line) in W. */
2352 window_internal_height (w
)
2355 int ht
= XFASTINT (w
->height
);
2357 if (MINI_WINDOW_P (w
))
2360 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2361 || !NILP (w
->next
) || !NILP (w
->prev
)
2362 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2369 /* Return the number of columns in W.
2370 Don't count columns occupied by scroll bars or the vertical bar
2371 separating W from the sibling to its right. */
2373 window_internal_width (w
)
2376 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2377 int left
= XINT (w
->left
);
2378 int width
= XINT (w
->width
);
2380 /* If this window is flush against the right edge of the frame, its
2381 internal width is its full width. */
2382 if (left
+ width
>= FRAME_WIDTH (f
))
2385 /* If we are not flush right, then our rightmost columns are
2386 occupied by some sort of separator. */
2388 /* Scroll bars occupy a few columns. */
2389 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2390 return width
- FRAME_SCROLL_BAR_COLS (f
);
2392 /* The column of `|' characters separating side-by-side windows
2393 occupies one column only. */
2398 /* Scroll contents of window WINDOW up N lines. */
2401 window_scroll (window
, n
, noerror
)
2406 register struct window
*w
= XWINDOW (window
);
2407 register int opoint
= PT
;
2409 register int ht
= window_internal_height (w
);
2410 register Lisp_Object tem
;
2412 Lisp_Object bolp
, nmoved
;
2414 XSETFASTINT (tem
, PT
);
2415 tem
= Fpos_visible_in_window_p (tem
, window
);
2419 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2420 XSETFASTINT (tem
, PT
);
2421 Fset_marker (w
->start
, tem
, w
->buffer
);
2422 w
->force_start
= Qt
;
2425 SET_PT (marker_position (w
->start
));
2426 lose
= n
< 0 && PT
== BEGV
;
2427 Fvertical_motion (make_number (n
), window
);
2437 Fsignal (Qbeginning_of_buffer
, Qnil
);
2442 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2443 w
->start_at_line_beg
= bolp
;
2444 w
->update_mode_line
= Qt
;
2445 XSETFASTINT (w
->last_modified
, 0);
2451 tem
= Fvertical_motion (make_number (ht
), window
);
2452 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2455 Fvertical_motion (make_number (-1), window
);
2463 Fsignal (Qend_of_buffer
, Qnil
);
2467 /* This is the guts of Fscroll_up and Fscroll_down. */
2470 scroll_command (n
, direction
)
2471 register Lisp_Object n
;
2474 register int defalt
;
2475 int count
= specpdl_ptr
- specpdl
;
2477 /* If selected window's buffer isn't current, make it current for the moment.
2478 But don't screw up if window_scroll gets an error. */
2479 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2481 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2482 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2485 defalt
= (window_internal_height (XWINDOW (selected_window
))
2486 - next_screen_context_lines
);
2487 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2490 window_scroll (selected_window
, defalt
, 0);
2491 else if (EQ (n
, Qminus
))
2492 window_scroll (selected_window
, - defalt
, 0);
2495 n
= Fprefix_numeric_value (n
);
2496 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2499 unbind_to (count
, Qnil
);
2502 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2503 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2504 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2505 Negative ARG means scroll downward.\n\
2506 When calling from a program, supply a number as argument or nil.")
2510 scroll_command (n
, 1);
2514 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2515 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2516 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2517 Negative ARG means scroll upward.\n\
2518 When calling from a program, supply a number as argument or nil.")
2522 scroll_command (n
, -1);
2526 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2527 "Return the other window for \"other window scroll\" commands.\n\
2528 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2529 specifies the window.\n\
2530 If `other-window-scroll-buffer' is non-nil, a window\n\
2531 showing that buffer is used.")
2536 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2537 && !NILP (Vminibuf_scroll_window
))
2538 window
= Vminibuf_scroll_window
;
2539 /* If buffer is specified, scroll that buffer. */
2540 else if (!NILP (Vother_window_scroll_buffer
))
2542 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2544 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2548 /* Nothing specified; look for a neighboring window on the same
2550 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2552 if (EQ (window
, selected_window
))
2553 /* That didn't get us anywhere; look for a window on another
2556 window
= Fnext_window (window
, Qnil
, Qt
);
2557 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2558 && ! EQ (window
, selected_window
));
2561 CHECK_LIVE_WINDOW (window
, 0);
2563 if (EQ (window
, selected_window
))
2564 error ("There is no other window");
2569 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2570 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2571 The next window is the one below the current one; or the one at the top\n\
2572 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2573 When calling from a program, supply a number as argument or nil.\n\
2575 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2576 specifies the window to scroll.\n\
2577 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2578 showing that buffer, popping the buffer up if necessary.")
2580 register Lisp_Object n
;
2582 register Lisp_Object window
;
2583 register int defalt
;
2584 register struct window
*w
;
2585 register int count
= specpdl_ptr
- specpdl
;
2587 window
= Fother_window_for_scrolling ();
2589 w
= XWINDOW (window
);
2590 defalt
= window_internal_height (w
) - next_screen_context_lines
;
2591 if (defalt
< 1) defalt
= 1;
2593 /* Don't screw up if window_scroll gets an error. */
2594 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2596 Fset_buffer (w
->buffer
);
2597 SET_PT (marker_position (w
->pointm
));
2600 window_scroll (window
, defalt
, 1);
2601 else if (EQ (n
, Qminus
))
2602 window_scroll (window
, -defalt
, 1);
2607 CHECK_NUMBER (n
, 0);
2608 window_scroll (window
, XINT (n
), 1);
2611 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2612 unbind_to (count
, Qnil
);
2617 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2618 "Scroll selected window display ARG columns left.\n\
2619 Default for ARG is window width minus 2.")
2621 register Lisp_Object arg
;
2625 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2627 arg
= Fprefix_numeric_value (arg
);
2630 Fset_window_hscroll (selected_window
,
2631 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2635 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2636 "Scroll selected window display ARG columns right.\n\
2637 Default for ARG is window width minus 2.")
2639 register Lisp_Object arg
;
2642 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2644 arg
= Fprefix_numeric_value (arg
);
2647 Fset_window_hscroll (selected_window
,
2648 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2652 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2653 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2654 The desired position of point is always relative to the current window.\n\
2655 Just C-u as prefix means put point in the center of the window.\n\
2656 No arg (i.e., it is nil) erases the entire frame and then\n\
2657 redraws with point in the center of the current window.")
2659 register Lisp_Object n
;
2661 register struct window
*w
= XWINDOW (selected_window
);
2662 register int ht
= window_internal_height (w
);
2663 struct position pos
;
2668 extern int frame_garbaged
;
2670 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2671 XSETFASTINT (n
, ht
/ 2);
2673 else if (CONSP (n
)) /* Just C-u. */
2675 XSETFASTINT (n
, ht
/ 2);
2679 n
= Fprefix_numeric_value (n
);
2680 CHECK_NUMBER (n
, 0);
2684 XSETINT (n
, XINT (n
) + ht
);
2686 XSETWINDOW (window
, w
);
2687 pos
= *vmotion (point
, - XINT (n
), window_internal_width (w
) - 1,
2688 XINT (w
->hscroll
), window
);
2690 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
2691 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
2692 || FETCH_CHAR (pos
.bufpos
- 1) == '\n')
2694 w
->force_start
= Qt
;
2699 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2701 "Position point relative to window.\n\
2702 With no argument, position point at center of window.\n\
2703 An argument specifies frame line; zero means top of window,\n\
2704 negative means relative to bottom of window.")
2706 register Lisp_Object arg
;
2708 register struct window
*w
= XWINDOW (selected_window
);
2709 register int height
= window_internal_height (w
);
2714 XSETFASTINT (arg
, height
/ 2);
2717 arg
= Fprefix_numeric_value (arg
);
2719 XSETINT (arg
, XINT (arg
) + height
);
2722 start
= marker_position (w
->start
);
2723 XSETWINDOW (window
, w
);
2724 if (start
< BEGV
|| start
> ZV
)
2726 Fvertical_motion (make_number (- (height
/ 2)), window
);
2727 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2728 w
->start_at_line_beg
= Fbolp ();
2729 w
->force_start
= Qt
;
2734 return Fvertical_motion (arg
, window
);
2737 struct save_window_data
2739 int size_from_Lisp_Vector_struct
;
2740 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2741 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2742 Lisp_Object selected_frame
;
2743 Lisp_Object current_window
;
2744 Lisp_Object current_buffer
;
2745 Lisp_Object minibuf_scroll_window
;
2746 Lisp_Object root_window
;
2747 Lisp_Object focus_frame
;
2748 /* Record the values of window-min-width and window-min-height
2749 so that window sizes remain consistent with them. */
2750 Lisp_Object min_width
, min_height
;
2751 /* A vector, interpreted as a struct saved_window */
2752 Lisp_Object saved_windows
;
2755 /* This is saved as a Lisp_Vector */
2758 /* these first two must agree with struct Lisp_Vector in lisp.h */
2759 int size_from_Lisp_Vector_struct
;
2760 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2763 Lisp_Object buffer
, start
, pointm
, mark
;
2764 Lisp_Object left
, top
, width
, height
, hscroll
;
2765 Lisp_Object parent
, prev
;
2766 Lisp_Object start_at_line_beg
;
2767 Lisp_Object display_table
;
2769 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2771 #define SAVED_WINDOW_N(swv,n) \
2772 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2774 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2775 "T if OBJECT is a window-configration object.")
2779 if (WINDOW_CONFIGURATIONP (obj
))
2785 DEFUN ("set-window-configuration", Fset_window_configuration
,
2786 Sset_window_configuration
, 1, 1, 0,
2787 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2788 CONFIGURATION must be a value previously returned\n\
2789 by `current-window-configuration' (which see).")
2791 Lisp_Object configuration
;
2793 register struct save_window_data
*data
;
2794 struct Lisp_Vector
*saved_windows
;
2795 Lisp_Object new_current_buffer
;
2799 while (!WINDOW_CONFIGURATIONP (configuration
))
2801 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2805 data
= (struct save_window_data
*) XVECTOR (configuration
);
2806 saved_windows
= XVECTOR (data
->saved_windows
);
2808 new_current_buffer
= data
->current_buffer
;
2809 if (NILP (XBUFFER (new_current_buffer
)->name
))
2810 new_current_buffer
= Qnil
;
2812 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2815 /* If f is a dead frame, don't bother rebuilding its window tree.
2816 However, there is other stuff we should still try to do below. */
2817 if (FRAME_LIVE_P (f
))
2819 register struct window
*w
;
2820 register struct saved_window
*p
;
2823 /* If the frame has been resized since this window configuration was
2824 made, we change the frame to the size specified in the
2825 configuration, restore the configuration, and then resize it
2826 back. We keep track of the prevailing height in these variables. */
2827 int previous_frame_height
= FRAME_HEIGHT (f
);
2828 int previous_frame_width
= FRAME_WIDTH (f
);
2829 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2831 if (XFASTINT (data
->frame_height
) != previous_frame_height
2832 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2833 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2834 #ifdef HAVE_X_WINDOWS
2835 if (XFASTINT (data
->frame_menu_bar_lines
)
2836 != previous_frame_menu_bar_lines
)
2837 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2840 windows_or_buffers_changed
++;
2842 /* Temporarily avoid any problems with windows that are smaller
2843 than they are supposed to be. */
2844 window_min_height
= 1;
2845 window_min_width
= 1;
2848 Mark all windows now on frame as "deleted".
2849 Restoring the new configuration "undeletes" any that are in it.
2851 Save their current buffers in their height fields, since we may
2852 need it later, if a buffer saved in the configuration is now
2854 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2856 for (k
= 0; k
< saved_windows
->size
; k
++)
2858 p
= SAVED_WINDOW_N (saved_windows
, k
);
2859 w
= XWINDOW (p
->window
);
2862 if (!NILP (p
->parent
))
2863 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2864 XFASTINT (p
->parent
))->window
;
2868 if (!NILP (p
->prev
))
2870 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2871 XFASTINT (p
->prev
))->window
;
2872 XWINDOW (w
->prev
)->next
= p
->window
;
2877 if (!NILP (w
->parent
))
2879 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2881 XWINDOW (w
->parent
)->vchild
= p
->window
;
2882 XWINDOW (w
->parent
)->hchild
= Qnil
;
2886 XWINDOW (w
->parent
)->hchild
= p
->window
;
2887 XWINDOW (w
->parent
)->vchild
= Qnil
;
2892 /* If we squirreled away the buffer in the window's height,
2894 if (BUFFERP (w
->height
))
2895 w
->buffer
= w
->height
;
2898 w
->width
= p
->width
;
2899 w
->height
= p
->height
;
2900 w
->hscroll
= p
->hscroll
;
2901 w
->display_table
= p
->display_table
;
2902 XSETFASTINT (w
->last_modified
, 0);
2904 /* Reinstall the saved buffer and pointers into it. */
2905 if (NILP (p
->buffer
))
2906 w
->buffer
= p
->buffer
;
2909 if (!NILP (XBUFFER (p
->buffer
)->name
))
2910 /* If saved buffer is alive, install it. */
2912 w
->buffer
= p
->buffer
;
2913 w
->start_at_line_beg
= p
->start_at_line_beg
;
2914 set_marker_restricted (w
->start
,
2915 Fmarker_position (p
->start
),
2917 set_marker_restricted (w
->pointm
,
2918 Fmarker_position (p
->pointm
),
2920 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2921 Fmarker_position (p
->mark
), w
->buffer
);
2923 /* As documented in Fcurrent_window_configuration, don't
2924 save the location of point in the buffer which was current
2925 when the window configuration was recorded. */
2926 if (!EQ (p
->buffer
, new_current_buffer
)
2927 && XBUFFER (p
->buffer
) == current_buffer
)
2928 Fgoto_char (w
->pointm
);
2930 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2931 /* Else unless window has a live buffer, get one. */
2933 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2934 /* This will set the markers to beginning of visible
2936 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2937 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2938 w
->start_at_line_beg
= Qt
;
2941 /* Keeping window's old buffer; make sure the markers
2944 /* Set window markers at start of visible range. */
2945 if (XMARKER (w
->start
)->buffer
== 0)
2946 set_marker_restricted (w
->start
, make_number (0),
2948 if (XMARKER (w
->pointm
)->buffer
== 0)
2949 set_marker_restricted (w
->pointm
,
2951 (BUF_PT (XBUFFER (w
->buffer
)))),
2953 w
->start_at_line_beg
= Qt
;
2958 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2959 Fselect_window (data
->current_window
);
2962 if (NILP (data
->focus_frame
)
2963 || (FRAMEP (data
->focus_frame
)
2964 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2965 Fredirect_frame_focus (frame
, data
->focus_frame
);
2968 #if 0 /* I don't understand why this is needed, and it causes problems
2969 when the frame's old selected window has been deleted. */
2971 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2972 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2976 /* Set the screen height to the value it had before this function. */
2977 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2978 || previous_frame_width
!= FRAME_WIDTH (f
))
2979 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2981 #ifdef HAVE_X_WINDOWS
2982 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2983 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2987 /* Restore the minimum heights recorded in the configuration. */
2988 window_min_height
= XINT (data
->min_height
);
2989 window_min_width
= XINT (data
->min_width
);
2992 /* Fselect_window will have made f the selected frame, so we
2993 reselect the proper frame here. Fhandle_switch_frame will change the
2994 selected window too, but that doesn't make the call to
2995 Fselect_window above totally superfluous; it still sets f's
2997 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2998 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
3001 if (!NILP (new_current_buffer
))
3002 Fset_buffer (new_current_buffer
);
3004 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
3008 /* Mark all windows now on frame as deleted
3009 by setting their buffers to nil. */
3012 delete_all_subwindows (w
)
3013 register struct window
*w
;
3015 if (!NILP (w
->next
))
3016 delete_all_subwindows (XWINDOW (w
->next
));
3017 if (!NILP (w
->vchild
))
3018 delete_all_subwindows (XWINDOW (w
->vchild
));
3019 if (!NILP (w
->hchild
))
3020 delete_all_subwindows (XWINDOW (w
->hchild
));
3022 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3024 /* We set all three of these fields to nil, to make sure that we can
3025 distinguish this dead window from any live window. Live leaf
3026 windows will have buffer set, and combination windows will have
3027 vchild or hchild set. */
3034 count_windows (window
)
3035 register struct window
*window
;
3037 register int count
= 1;
3038 if (!NILP (window
->next
))
3039 count
+= count_windows (XWINDOW (window
->next
));
3040 if (!NILP (window
->vchild
))
3041 count
+= count_windows (XWINDOW (window
->vchild
));
3042 if (!NILP (window
->hchild
))
3043 count
+= count_windows (XWINDOW (window
->hchild
));
3048 save_window_save (window
, vector
, i
)
3050 struct Lisp_Vector
*vector
;
3053 register struct saved_window
*p
;
3054 register struct window
*w
;
3055 register Lisp_Object tem
;
3057 for (;!NILP (window
); window
= w
->next
)
3059 p
= SAVED_WINDOW_N (vector
, i
);
3060 w
= XWINDOW (window
);
3062 XSETFASTINT (w
->temslot
, i
++);
3064 p
->buffer
= w
->buffer
;
3067 p
->width
= w
->width
;
3068 p
->height
= w
->height
;
3069 p
->hscroll
= w
->hscroll
;
3070 p
->display_table
= w
->display_table
;
3071 if (!NILP (w
->buffer
))
3073 /* Save w's value of point in the window configuration.
3074 If w is the selected window, then get the value of point
3075 from the buffer; pointm is garbage in the selected window. */
3076 if (EQ (window
, selected_window
))
3078 p
->pointm
= Fmake_marker ();
3079 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
3083 p
->pointm
= Fcopy_marker (w
->pointm
);
3085 p
->start
= Fcopy_marker (w
->start
);
3086 p
->start_at_line_beg
= w
->start_at_line_beg
;
3088 tem
= XBUFFER (w
->buffer
)->mark
;
3089 p
->mark
= Fcopy_marker (tem
);
3096 p
->start_at_line_beg
= Qnil
;
3099 if (NILP (w
->parent
))
3102 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3107 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3109 if (!NILP (w
->vchild
))
3110 i
= save_window_save (w
->vchild
, vector
, i
);
3111 if (!NILP (w
->hchild
))
3112 i
= save_window_save (w
->hchild
, vector
, i
);
3118 DEFUN ("current-window-configuration",
3119 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3120 "Return an object representing the current window configuration of FRAME.\n\
3121 If FRAME is nil or omitted, use the selected frame.\n\
3122 This describes the number of windows, their sizes and current buffers,\n\
3123 and for each displayed buffer, where display starts, and the positions of\n\
3124 point and mark. An exception is made for point in the current buffer:\n\
3125 its value is -not- saved.\n\
3126 This also records the currently selected frame, and FRAME's focus\n\
3127 redirection (see `redirect-frame-focus').")
3131 register Lisp_Object tem
;
3132 register int n_windows
;
3133 register struct save_window_data
*data
;
3134 register struct Lisp_Vector
*vec
;
3142 CHECK_LIVE_FRAME (frame
, 0);
3146 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3147 vec
= allocate_vectorlike (VECSIZE (struct save_window_data
));
3148 for (i
= 0; i
< VECSIZE (struct save_window_data
); i
++)
3149 vec
->contents
[i
] = Qnil
;
3150 vec
->size
= VECSIZE (struct save_window_data
);
3151 data
= (struct save_window_data
*)vec
;
3153 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
3154 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
3155 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
3157 XSETFRAME (data
->selected_frame
, selected_frame
);
3159 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3160 XSETBUFFER (data
->current_buffer
, current_buffer
);
3161 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3162 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3163 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3164 XSETINT (data
->min_height
, window_min_height
);
3165 XSETINT (data
->min_width
, window_min_width
);
3166 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3167 data
->saved_windows
= tem
;
3168 for (i
= 0; i
< n_windows
; i
++)
3169 XVECTOR (tem
)->contents
[i
]
3170 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3171 save_window_save (FRAME_ROOT_WINDOW (f
),
3173 XSETWINDOW_CONFIGURATION (tem
, data
);
3177 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3179 "Execute body, preserving window sizes and contents.\n\
3180 Restore which buffer appears in which window, where display starts,\n\
3181 and the value of point and mark for each window.\n\
3182 Also restore which buffer is current.\n\
3183 But do not preserve point in the current buffer.\n\
3184 Does not restore the value of point in current buffer.")
3188 register Lisp_Object val
;
3189 register int count
= specpdl_ptr
- specpdl
;
3191 record_unwind_protect (Fset_window_configuration
,
3192 Fcurrent_window_configuration (Qnil
));
3193 val
= Fprogn (args
);
3194 return unbind_to (count
, val
);
3200 selected_frame
= make_terminal_frame ();
3201 minibuf_window
= selected_frame
->minibuffer_window
;
3202 selected_window
= selected_frame
->selected_window
;
3203 last_nonminibuf_frame
= selected_frame
;
3204 #else /* not MULTI_FRAME */
3205 extern Lisp_Object
get_minibuffer ();
3207 selected_frame
= last_nonminibuf_frame
= &the_only_frame
;
3209 minibuf_window
= make_window ();
3210 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3212 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3213 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3214 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3216 /* These values 9 and 10 are arbitrary,
3217 just so that there is "something there."
3218 Correct values are put in in init_xdisp */
3220 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
, 10);
3221 XSETFASTINT (XWINDOW (minibuf_window
)->width
, 10);
3223 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
, 9);
3224 XSETFASTINT (XWINDOW (minibuf_window
)->top
, 9);
3225 XSETFASTINT (XWINDOW (minibuf_window
)->height
, 1);
3227 /* Prevent error in Fset_window_buffer. */
3228 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3229 XWINDOW (minibuf_window
)->buffer
= Qt
;
3231 /* Now set them up for real. */
3232 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3233 Fcurrent_buffer ());
3234 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3236 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3237 /* Make sure this window seems more recently used than
3238 a newly-created, never-selected window. Increment
3239 window_select_count so the first selection ever will get
3240 something newer than this. */
3241 XSETFASTINT (XWINDOW (selected_window
)->use_time
, ++window_select_count
);
3242 #endif /* not MULTI_FRAME */
3247 Qwindowp
= intern ("windowp");
3248 staticpro (&Qwindowp
);
3250 Qwindow_live_p
= intern ("window-live-p");
3251 staticpro (&Qwindow_live_p
);
3254 /* Make sure all windows get marked */
3255 staticpro (&minibuf_window
);
3258 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3259 "Non-nil means call as function to display a help buffer.\n\
3260 The function is called with one argument, the buffer to be displayed.\n\
3261 Used by `with-output-to-temp-buffer'.");
3262 Vtemp_buffer_show_function
= Qnil
;
3264 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3265 "If non-nil, function to call to handle `display-buffer'.\n\
3266 It will receive two args, the buffer and a flag which if non-nil means\n\
3267 that the currently selected window is not acceptable.\n\
3268 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3269 work using this function.");
3270 Vdisplay_buffer_function
= Qnil
;
3272 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3273 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3274 Vminibuf_scroll_window
= Qnil
;
3276 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3277 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3278 Vother_window_scroll_buffer
= Qnil
;
3280 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3281 "*Non-nil means `display-buffer' should make a separate frame.");
3284 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3285 "Function to call to handle automatic new frame creation.\n\
3286 It is called with no arguments and should return a newly created frame.\n\
3288 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3289 where `pop-up-frame-alist' would hold the default frame parameters.");
3290 Vpop_up_frame_function
= Qnil
;
3292 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3293 "*List of buffer names that should have their own special frames.\n\
3294 Displaying a buffer whose name is in this list makes a special frame for it\n\
3295 using `special-display-function'.\n\
3296 Instead of a buffer name, the list entries can be cons cells. In that\n\
3297 case the car should be a buffer name, and the cdr data to be passed as a\n\
3298 second argument to `special-display-function'.\n\
3299 See also `special-display-regexps'.");
3300 Vspecial_display_buffer_names
= Qnil
;
3302 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3303 "*List of regexps saying which buffers should have their own special frames.\n\
3304 If a buffer name matches one of these regexps, it gets its own frame.\n\
3305 Displaying a buffer whose name is in this list makes a special frame for it\n\
3306 using `special-display-function'.\n\
3307 Instead of a buffer name, the list entries can be cons cells. In that\n\
3308 case the car should be the regexp, and the cdr data to be passed as a\n\
3309 second argument to `special-display-function'.\n\
3310 See also `special-display-buffer-names'.");
3311 Vspecial_display_regexps
= Qnil
;
3313 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3314 "Function to call to make a new frame for a special buffer.\n\
3315 It is called with two arguments, the buffer and optional buffer specific\n\
3316 data, and should return a window displaying that buffer.\n\
3317 The default value makes a separate frame for the buffer,\n\
3318 using `special-display-frame-alist' to specify the frame parameters.\n\
3320 A buffer is special if its is listed in `special-display-buffer-names'\n\
3321 or matches a regexp in `special-display-regexps'.");
3322 Vspecial_display_function
= Qnil
;
3324 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3325 "*Non-nil means display-buffer should make new windows.");
3328 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3329 "*Number of lines of continuity when scrolling by screenfuls.");
3330 next_screen_context_lines
= 2;
3332 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3333 "*display-buffer would prefer to split the largest window if this large.\n\
3334 If there is only one window, it is split regardless of this value.");
3335 split_height_threshold
= 500;
3337 DEFVAR_INT ("window-min-height", &window_min_height
,
3338 "*Delete any window less than this tall (including its mode line).");
3339 window_min_height
= 4;
3341 DEFVAR_INT ("window-min-width", &window_min_width
,
3342 "*Delete any window less than this wide.");
3343 window_min_width
= 10;
3345 defsubr (&Sselected_window
);
3346 defsubr (&Sminibuffer_window
);
3347 defsubr (&Swindow_minibuffer_p
);
3348 defsubr (&Swindowp
);
3349 defsubr (&Swindow_live_p
);
3350 defsubr (&Spos_visible_in_window_p
);
3351 defsubr (&Swindow_buffer
);
3352 defsubr (&Swindow_height
);
3353 defsubr (&Swindow_width
);
3354 defsubr (&Swindow_hscroll
);
3355 defsubr (&Sset_window_hscroll
);
3356 defsubr (&Swindow_edges
);
3357 defsubr (&Scoordinates_in_window_p
);
3358 defsubr (&Swindow_at
);
3359 defsubr (&Swindow_point
);
3360 defsubr (&Swindow_start
);
3361 defsubr (&Swindow_end
);
3362 defsubr (&Sset_window_point
);
3363 defsubr (&Sset_window_start
);
3364 defsubr (&Swindow_dedicated_p
);
3365 defsubr (&Sset_window_dedicated_p
);
3366 defsubr (&Swindow_display_table
);
3367 defsubr (&Sset_window_display_table
);
3368 defsubr (&Snext_window
);
3369 defsubr (&Sprevious_window
);
3370 defsubr (&Sother_window
);
3371 defsubr (&Sget_lru_window
);
3372 defsubr (&Sget_largest_window
);
3373 defsubr (&Sget_buffer_window
);
3374 defsubr (&Sdelete_other_windows
);
3375 defsubr (&Sdelete_windows_on
);
3376 defsubr (&Sreplace_buffer_in_windows
);
3377 defsubr (&Sdelete_window
);
3378 defsubr (&Sset_window_buffer
);
3379 defsubr (&Sselect_window
);
3380 defsubr (&Sdisplay_buffer
);
3381 defsubr (&Ssplit_window
);
3382 defsubr (&Senlarge_window
);
3383 defsubr (&Sshrink_window
);
3384 defsubr (&Sscroll_up
);
3385 defsubr (&Sscroll_down
);
3386 defsubr (&Sscroll_left
);
3387 defsubr (&Sscroll_right
);
3388 defsubr (&Sother_window_for_scrolling
);
3389 defsubr (&Sscroll_other_window
);
3390 defsubr (&Srecenter
);
3391 defsubr (&Smove_to_window_line
);
3392 defsubr (&Swindow_configuration_p
);
3393 defsubr (&Sset_window_configuration
);
3394 defsubr (&Scurrent_window_configuration
);
3395 defsubr (&Ssave_window_excursion
);
3400 initial_define_key (control_x_map
, '1', "delete-other-windows");
3401 initial_define_key (control_x_map
, '2', "split-window");
3402 initial_define_key (control_x_map
, '0', "delete-window");
3403 initial_define_key (control_x_map
, 'o', "other-window");
3404 initial_define_key (control_x_map
, '^', "enlarge-window");
3405 initial_define_key (control_x_map
, '<', "scroll-left");
3406 initial_define_key (control_x_map
, '>', "scroll-right");
3408 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3409 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3410 initial_define_key (meta_map
, 'v', "scroll-down");
3412 initial_define_key (global_map
, Ctl('L'), "recenter");
3413 initial_define_key (meta_map
, 'r', "move-to-window-line");