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
);
122 register Lisp_Object val
;
123 register struct window
*p
;
125 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector)
126 includes the first element. */
128 make_number ((sizeof (struct window
) - sizeof (struct Lisp_Vector
)
129 + sizeof (Lisp_Object
))
130 / sizeof (Lisp_Object
)),
132 XSETTYPE (val
, Lisp_Window
);
134 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
135 XSETFASTINT (p
->left
, 0);
136 XSETFASTINT (p
->top
, 0);
137 XSETFASTINT (p
->height
, 0);
138 XSETFASTINT (p
->width
, 0);
139 XSETFASTINT (p
->hscroll
, 0);
140 XSETFASTINT (p
->last_point_x
, 0);
141 XSETFASTINT (p
->last_point_y
, 0);
142 p
->start
= Fmake_marker ();
143 p
->pointm
= Fmake_marker ();
144 XSETFASTINT (p
->use_time
, 0);
146 p
->display_table
= Qnil
;
151 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
152 "Return the window that the cursor now appears in and commands apply to.")
155 return selected_window
;
158 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
159 "Return the window used now for minibuffers.\n\
160 If the optional argument FRAME is specified, return the minibuffer window\n\
161 used by that frame.")
167 XSETFRAME (frame
, selected_frame
);
169 CHECK_LIVE_FRAME (frame
, 0);
172 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
175 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
176 "Returns non-nil if WINDOW is a minibuffer window.")
180 struct window
*w
= decode_window (window
);
181 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
184 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
185 Spos_visible_in_window_p
, 0, 2, 0,
186 "Return t if position POS is currently on the frame in WINDOW.\n\
187 Returns nil if that position is scrolled vertically out of view.\n\
188 POS defaults to point; WINDOW, to the selected window.")
190 Lisp_Object pos
, window
;
192 register struct window
*w
;
196 register struct buffer
*buf
;
197 struct position posval
;
204 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
208 w
= decode_window (window
);
209 top
= marker_position (w
->start
);
210 hscroll
= XINT (w
->hscroll
);
215 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
217 buf
= XBUFFER (w
->buffer
);
218 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
220 /* If frame is up to date,
221 use the info recorded about how much text fit on it. */
222 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
223 || (XFASTINT (w
->window_end_vpos
) < height
))
229 if (posint
> BUF_ZV (buf
))
232 /* w->start can be out of range. If it is, do something reasonable. */
233 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
236 /* If that info is not correct, calculate afresh */
237 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
239 window_internal_width (w
) - 1,
242 return posval
.vpos
< height
? Qt
: Qnil
;
246 static struct window
*
247 decode_window (window
)
248 register Lisp_Object window
;
251 return XWINDOW (selected_window
);
253 CHECK_LIVE_WINDOW (window
, 0);
254 return XWINDOW (window
);
257 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
258 "Return the buffer that WINDOW is displaying.")
262 return decode_window (window
)->buffer
;
265 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
266 "Return the number of lines in WINDOW (including its mode line).")
270 return decode_window (window
)->height
;
273 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
274 "Return the number of display columns in WINDOW.\n\
275 This is the width that is usable columns available for text in WINDOW.\n\
276 If you want to find out how many columns WINDOW takes up,\n\
277 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
281 return make_number (window_internal_width (decode_window (window
)));
284 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
285 "Return the number of columns by which WINDOW is scrolled from left margin.")
289 return decode_window (window
)->hscroll
;
292 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
293 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
294 NCOL should be zero or positive.")
296 register Lisp_Object window
, ncol
;
298 register struct window
*w
;
300 CHECK_NUMBER (ncol
, 1);
301 if (XINT (ncol
) < 0) XSETFASTINT (ncol
, 0);
302 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
303 args_out_of_range (ncol
, Qnil
);
304 w
= decode_window (window
);
305 if (XINT (w
->hscroll
) != XINT (ncol
))
306 clip_changed
= 1; /* Prevent redisplay shortcuts */
311 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
312 "Return a list of the edge coordinates of WINDOW.\n\
313 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
314 RIGHT is one more than the rightmost column used by WINDOW,\n\
315 and BOTTOM is one more than the bottommost row used by WINDOW\n\
320 register struct window
*w
= decode_window (window
);
322 return Fcons (w
->left
, Fcons (w
->top
,
323 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
324 Fcons (make_number (XFASTINT (w
->top
)
325 + XFASTINT (w
->height
)),
329 /* Test if the character at column *x, row *y is within window *w.
330 If it is not, return 0;
331 if it is in the window's text area,
332 set *x and *y to its location relative to the upper left corner
335 if it is on the window's modeline, return 2;
336 if it is on the border between the window and its right sibling,
339 coordinates_in_window (w
, x
, y
)
340 register struct window
*w
;
343 register int left
= XINT (w
->left
);
344 register int width
= XINT (w
->width
);
345 register int window_height
= XINT (w
->height
);
346 register int top
= XFASTINT (w
->top
);
348 if ( *x
< left
|| *x
>= left
+ width
349 || *y
< top
|| *y
>= top
+ window_height
)
352 /* Is the character is the mode line? */
353 if (*y
== top
+ window_height
- 1
354 && ! MINI_WINDOW_P (w
))
357 /* Is the character in the right border? */
358 if (*x
== left
+ width
- 1
359 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
367 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
368 Scoordinates_in_window_p
, 2, 2, 0,
369 "Return non-nil if COORDINATES are in WINDOW.\n\
370 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
371 measured in characters from the upper-left corner of the frame.\n\
372 (0 . 0) denotes the character in the upper left corner of the\n\
374 If COORDINATES are in the text portion of WINDOW,\n\
375 the coordinates relative to the window are returned.\n\
376 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
377 If they are on the border between WINDOW and its right sibling,\n\
378 `vertical-line' is returned.")
379 (coordinates
, window
)
380 register Lisp_Object coordinates
, window
;
384 CHECK_LIVE_WINDOW (window
, 0);
385 CHECK_CONS (coordinates
, 1);
386 x
= XINT (Fcar (coordinates
));
387 y
= XINT (Fcdr (coordinates
));
389 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
391 case 0: /* NOT in window at all. */
394 case 1: /* In text part of window. */
397 case 2: /* In mode line of window. */
400 case 3: /* On right border of window. */
401 return Qvertical_line
;
408 /* Find the window containing column x, row y, and return it as a
409 Lisp_Object. If x, y is on the window's modeline, set *part
410 to 1; if it is on the separating line between the window and its
411 right sibling, set it to 2; otherwise set it to 0. If there is no
412 window under x, y return nil and leave *part unmodified. */
414 window_from_coordinates (frame
, x
, y
, part
)
419 register Lisp_Object tem
, first
;
421 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
425 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
433 tem
= Fnext_window (tem
, Qt
, Qlambda
);
435 while (! EQ (tem
, first
));
440 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
441 "Return window containing coordinates X and Y on FRAME.\n\
442 If omitted, FRAME defaults to the currently selected frame.\n\
443 The top left corner of the frame is considered to be row 0,\n\
446 Lisp_Object x
, y
, frame
;
452 XSETFRAME (frame
, selected_frame
);
454 CHECK_LIVE_FRAME (frame
, 2);
459 return window_from_coordinates (XFRAME (frame
),
464 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
465 "Return current value of point in WINDOW.\n\
466 For a nonselected window, this is the value point would have\n\
467 if that window were selected.\n\
469 Note that, when WINDOW is the selected window and its buffer\n\
470 is also currently selected, the value returned is the same as (point).\n\
471 It would be more strictly correct to return the `top-level' value\n\
472 of point, outside of any save-excursion forms.\n\
473 But that is hard to define.")
477 register struct window
*w
= decode_window (window
);
479 if (w
== XWINDOW (selected_window
)
480 && current_buffer
== XBUFFER (w
->buffer
))
482 return Fmarker_position (w
->pointm
);
485 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
486 "Return position at which display currently starts in WINDOW.")
490 return Fmarker_position (decode_window (window
)->start
);
493 /* This is text temporarily removed from the doc string below.
495 This function returns nil if the position is not currently known.\n\
496 That happens when redisplay is preempted and doesn't finish.\n\
497 If in that case you want to compute where the end of the window would\n\
498 have been if redisplay had finished, do this:\n\
500 (goto-char (window-start window))\n\
501 (vertical-motion (1- (window-height window)) window)\n\
504 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
505 "Return position at which display currently ends in WINDOW.\n\
506 This is updated by redisplay, when it runs to completion.\n\
507 Simply changing the buffer text or setting `window-start'\n\
508 does not update this value.")
513 struct window
*w
= decode_window (window
);
517 CHECK_BUFFER (buf
, 0);
519 #if 0 /* This change broke some things. We should make it later. */
520 /* If we don't know the end position, return nil.
521 The user can compute it with vertical-motion if he wants to.
522 It would be nicer to do it automatically,
523 but that's so slow that it would probably bother people. */
524 if (NILP (w
->window_end_valid
))
529 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
534 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
535 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
537 Lisp_Object window
, pos
;
539 register struct window
*w
= decode_window (window
);
541 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
542 if (w
== XWINDOW (selected_window
))
545 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
550 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
551 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
552 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
553 from overriding motion of point in order to display at this exact start.")
554 (window
, pos
, noforce
)
555 Lisp_Object window
, pos
, noforce
;
557 register struct window
*w
= decode_window (window
);
559 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
560 set_marker_restricted (w
->start
, pos
, w
->buffer
);
561 /* this is not right, but much easier than doing what is right. */
562 w
->start_at_line_beg
= Qnil
;
565 w
->update_mode_line
= Qt
;
566 XSETFASTINT (w
->last_modified
, 0);
567 if (!EQ (window
, selected_window
))
568 windows_or_buffers_changed
++;
572 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
574 "Return WINDOW's dedicated object, usually t or nil.\n\
575 See also `set-window-dedicated-p'.")
579 return decode_window (window
)->dedicated
;
582 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
583 Sset_window_dedicated_p
, 2, 2, 0,
584 "Control whether WINDOW is dedicated to the buffer it displays.\n\
585 If it is dedicated, Emacs will not automatically change\n\
586 which buffer appears in it.\n\
587 The second argument is the new value for the dedication flag;\n\
590 Lisp_Object window
, arg
;
592 register struct window
*w
= decode_window (window
);
602 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
604 "Return the display-table that WINDOW is using.")
608 return decode_window (window
)->display_table
;
611 /* Get the display table for use currently on window W.
612 This is either W's display table or W's buffer's display table.
613 Ignore the specified tables if they are not valid;
614 if no valid table is specified, return 0. */
617 window_display_table (w
)
621 tem
= w
->display_table
;
622 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
623 return XVECTOR (tem
);
624 tem
= XBUFFER (w
->buffer
)->display_table
;
625 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
626 return XVECTOR (tem
);
627 tem
= Vstandard_display_table
;
628 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
629 return XVECTOR (tem
);
633 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
634 "Set WINDOW's display-table to TABLE.")
636 register Lisp_Object window
, table
;
638 register struct window
*w
;
639 register Lisp_Object z
; /* Return value. */
641 w
= decode_window (window
);
642 w
->display_table
= table
;
646 /* Record info on buffer window w is displaying
647 when it is about to cease to display that buffer. */
650 register struct window
*w
;
655 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
659 if (w
== XWINDOW (selected_window
)
660 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
661 /* Do this except when the selected window's buffer
662 is being removed from some other window. */
664 /* last_window_start records the start position that this buffer
665 had in the last window to be disconnected from it.
666 Now that this statement is unconditional,
667 it is possible for the buffer to be displayed in the
668 selected window, while last_window_start reflects another
669 window which was recently showing the same buffer.
670 Some people might say that might be a good thing. Let's see. */
671 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
673 /* Point in the selected window's buffer
674 is actually stored in that buffer, and the window's pointm isn't used.
675 So don't clobber point in that buffer. */
676 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
677 BUF_PT (XBUFFER (buf
))
678 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
679 marker_position (w
->pointm
),
680 BUF_ZV (XBUFFER (buf
)));
683 /* Put replacement into the window structure in place of old. */
685 replace_window (old
, replacement
)
686 Lisp_Object old
, replacement
;
688 register Lisp_Object tem
;
689 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
691 /* If OLD is its frame's root_window, then replacement is the new
692 root_window for that frame. */
694 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
695 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
700 p
->height
= o
->height
;
702 p
->next
= tem
= o
->next
;
704 XWINDOW (tem
)->prev
= replacement
;
706 p
->prev
= tem
= o
->prev
;
708 XWINDOW (tem
)->next
= replacement
;
710 p
->parent
= tem
= o
->parent
;
713 if (EQ (XWINDOW (tem
)->vchild
, old
))
714 XWINDOW (tem
)->vchild
= replacement
;
715 if (EQ (XWINDOW (tem
)->hchild
, old
))
716 XWINDOW (tem
)->hchild
= replacement
;
719 /*** Here, if replacement is a vertical combination
720 and so is its new parent, we should make replacement's
721 children be children of that parent instead. ***/
724 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
725 "Remove WINDOW from the display. Default is selected window.")
727 register Lisp_Object window
;
729 register Lisp_Object tem
, parent
, sib
;
730 register struct window
*p
;
731 register struct window
*par
;
733 /* Because this function is called by other C code on non-leaf
734 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
735 so we can't decode_window here. */
737 window
= selected_window
;
739 CHECK_WINDOW (window
, 0);
740 p
= XWINDOW (window
);
742 /* It's okay to delete an already-deleted window. */
750 error ("Attempt to delete minibuffer or sole ordinary window");
751 par
= XWINDOW (parent
);
753 windows_or_buffers_changed
++;
755 /* Are we trying to delete any frame's selected window? */
757 Lisp_Object frame
, pwindow
;
759 /* See if the frame's selected window is either WINDOW
760 or any subwindow of it, by finding all that window's parents
761 and comparing each one with WINDOW. */
762 frame
= WINDOW_FRAME (XWINDOW (window
));
763 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
765 while (!NILP (pwindow
))
767 if (EQ (window
, pwindow
))
769 pwindow
= XWINDOW (pwindow
)->parent
;
772 if (EQ (window
, pwindow
))
774 Lisp_Object alternative
;
775 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
777 /* If we're about to delete the selected window on the
778 selected frame, then we should use Fselect_window to select
779 the new window. On the other hand, if we're about to
780 delete the selected window on any other frame, we shouldn't do
781 anything but set the frame's selected_window slot. */
782 if (EQ (window
, selected_window
))
783 Fselect_window (alternative
);
785 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
790 /* tem is null for dummy parent windows
791 (which have inferiors but not any contents themselves) */
795 unchain_marker (p
->pointm
);
796 unchain_marker (p
->start
);
801 XWINDOW (tem
)->prev
= p
->prev
;
805 XWINDOW (tem
)->next
= p
->next
;
807 if (EQ (window
, par
->hchild
))
808 par
->hchild
= p
->next
;
809 if (EQ (window
, par
->vchild
))
810 par
->vchild
= p
->next
;
812 /* Find one of our siblings to give our space to. */
816 /* If p gives its space to its next sibling, that sibling needs
817 to have its top/left side pulled back to where p's is.
818 set_window_{height,width} will re-position the sibling's
821 XWINDOW (sib
)->top
= p
->top
;
822 XWINDOW (sib
)->left
= p
->left
;
825 /* Stretch that sibling. */
826 if (!NILP (par
->vchild
))
827 set_window_height (sib
,
828 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
830 if (!NILP (par
->hchild
))
831 set_window_width (sib
,
832 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
835 /* If parent now has only one child,
836 put the child into the parent's place. */
840 if (NILP (XWINDOW (tem
)->next
))
841 replace_window (parent
, tem
);
843 /* Since we may be deleting combination windows, we must make sure that
844 not only p but all its children have been marked as deleted. */
845 if (! NILP (p
->hchild
))
846 delete_all_subwindows (XWINDOW (p
->hchild
));
847 else if (! NILP (p
->vchild
))
848 delete_all_subwindows (XWINDOW (p
->vchild
));
850 /* Mark this window as deleted. */
851 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
857 extern Lisp_Object
next_frame (), prev_frame ();
859 /* This comment supplies the doc string for `next-window',
860 for make-docfile to see. We cannot put this in the real DEFUN
861 due to limits in the Unix cpp.
863 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
864 "Return next window after WINDOW in canonical ordering of windows.\n\
865 If omitted, WINDOW defaults to the selected window.\n\
867 Optional second arg MINIBUF t means count the minibuffer window even\n\
868 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
869 it is active. MINIBUF neither t nor nil means not to count the\n\
870 minibuffer even if it is active.\n\
872 Several frames may share a single minibuffer; if the minibuffer\n\
873 counts, all windows on all frames that share that minibuffer count\n\
874 too. Therefore, `next-window' can be used to iterate through the\n\
875 set of windows even when the minibuffer is on another frame. If the\n\
876 minibuffer does not count, only windows from WINDOW's frame count.\n\
878 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
879 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
880 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
881 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
882 Anything else means restrict to WINDOW's frame.\n\
884 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
885 `next-window' to iterate through the entire cycle of acceptable\n\
886 windows, eventually ending up back at the window you started with.\n\
887 `previous-window' traverses the same cycle, in the reverse order.")
888 (window, minibuf, all_frames) */
890 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
892 (window
, minibuf
, all_frames
)
893 register Lisp_Object window
, minibuf
, all_frames
;
895 register Lisp_Object tem
;
896 Lisp_Object start_window
;
899 window
= selected_window
;
901 CHECK_LIVE_WINDOW (window
, 0);
903 start_window
= window
;
905 /* minibuf == nil may or may not include minibuffers.
906 Decide if it does. */
908 minibuf
= (minibuf_level
? Qt
: Qlambda
);
911 /* all_frames == nil doesn't specify which frames to include. */
912 if (NILP (all_frames
))
913 all_frames
= (EQ (minibuf
, Qt
)
914 ? (FRAME_MINIBUF_WINDOW
917 (XWINDOW (window
)))))
919 else if (EQ (all_frames
, Qvisible
))
921 else if (XFASTINT (all_frames
) == 0)
923 else if (! EQ (all_frames
, Qt
))
925 /* Now all_frames is t meaning search all frames,
926 nil meaning search just current frame,
927 visible meaning search just visible frames,
928 0 meaning search visible and iconified frames,
929 or a window, meaning search the frame that window belongs to. */
932 /* Do this loop at least once, to get the next window, and perhaps
933 again, if we hit the minibuffer and that is not acceptable. */
936 /* Find a window that actually has a next one. This loop
937 climbs up the tree. */
938 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
939 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
943 /* We've reached the end of this frame.
944 Which other frames are acceptable? */
945 tem
= WINDOW_FRAME (XWINDOW (window
));
947 if (! NILP (all_frames
))
952 tem
= next_frame (tem
, all_frames
);
953 /* In the case where the minibuffer is active,
954 and we include its frame as well as the selected one,
955 next_frame may get stuck in that frame.
956 If that happens, go back to the selected frame
957 so we can complete the cycle. */
959 XSETFRAME (tem
, selected_frame
);
962 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
969 /* If we're in a combination window, find its first child and
970 recurse on that. Otherwise, we've found the window we want. */
973 if (!NILP (XWINDOW (window
)->hchild
))
974 window
= XWINDOW (window
)->hchild
;
975 else if (!NILP (XWINDOW (window
)->vchild
))
976 window
= XWINDOW (window
)->vchild
;
980 /* Which windows are acceptible?
981 Exit the loop and accept this window if
982 this isn't a minibuffer window, or
983 we're accepting minibuffer windows, or
984 we've come all the way around and we're back at the original window. */
985 while (MINI_WINDOW_P (XWINDOW (window
))
986 && ! EQ (minibuf
, Qt
)
987 && ! EQ (window
, start_window
));
992 /* This comment supplies the doc string for `previous-window',
993 for make-docfile to see. We cannot put this in the real DEFUN
994 due to limits in the Unix cpp.
996 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
997 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
998 If omitted, WINDOW defaults to the selected window.\n\
1000 Optional second arg MINIBUF t means count the minibuffer window even\n\
1001 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
1002 it is active. MINIBUF neither t nor nil means not to count the\n\
1003 minibuffer even if it is active.\n\
1005 Several frames may share a single minibuffer; if the minibuffer\n\
1006 counts, all windows on all frames that share that minibuffer count\n\
1007 too. Therefore, `previous-window' can be used to iterate through\n\
1008 the set of windows even when the minibuffer is on another frame. If\n\
1009 the minibuffer does not count, only windows from WINDOW's frame count\n\
1011 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1012 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1013 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1014 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1015 Anything else means restrict to WINDOW's frame.\n\
1017 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1018 `previous-window' to iterate through the entire cycle of acceptable\n\
1019 windows, eventually ending up back at the window you started with.\n\
1020 `next-window' traverses the same cycle, in the reverse order.")
1021 (window, minibuf, all_frames) */
1024 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1026 (window
, minibuf
, all_frames
)
1027 register Lisp_Object window
, minibuf
, all_frames
;
1029 register Lisp_Object tem
;
1030 Lisp_Object start_window
;
1033 window
= selected_window
;
1035 CHECK_LIVE_WINDOW (window
, 0);
1037 start_window
= window
;
1039 /* minibuf == nil may or may not include minibuffers.
1040 Decide if it does. */
1042 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1045 /* all_frames == nil doesn't specify which frames to include.
1046 Decide which frames it includes. */
1047 if (NILP (all_frames
))
1048 all_frames
= (EQ (minibuf
, Qt
)
1049 ? (FRAME_MINIBUF_WINDOW
1052 (XWINDOW (window
)))))
1054 else if (EQ (all_frames
, Qvisible
))
1056 else if (XFASTINT (all_frames
) == 0)
1058 else if (! EQ (all_frames
, Qt
))
1060 /* Now all_frames is t meaning search all frames,
1061 nil meaning search just current frame,
1062 visible meaning search just visible frames,
1063 0 meaning search visible and iconified frames,
1064 or a window, meaning search the frame that window belongs to. */
1067 /* Do this loop at least once, to get the previous window, and perhaps
1068 again, if we hit the minibuffer and that is not acceptable. */
1071 /* Find a window that actually has a previous one. This loop
1072 climbs up the tree. */
1073 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1074 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1078 /* We have found the top window on the frame.
1079 Which frames are acceptable? */
1080 tem
= WINDOW_FRAME (XWINDOW (window
));
1082 if (! NILP (all_frames
))
1083 /* It's actually important that we use prev_frame here,
1084 rather than next_frame. All the windows acceptable
1085 according to the given parameters should form a ring;
1086 Fnext_window and Fprevious_window should go back and
1087 forth around the ring. If we use next_frame here,
1088 then Fnext_window and Fprevious_window take different
1089 paths through the set of acceptable windows.
1090 window_loop assumes that these `ring' requirement are
1096 tem
= prev_frame (tem
, all_frames
);
1097 /* In the case where the minibuffer is active,
1098 and we include its frame as well as the selected one,
1099 next_frame may get stuck in that frame.
1100 If that happens, go back to the selected frame
1101 so we can complete the cycle. */
1103 XSETFRAME (tem
, selected_frame
);
1106 /* If this frame has a minibuffer, find that window first,
1107 because it is conceptually the last window in that frame. */
1108 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1109 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1111 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1117 /* If we're in a combination window, find its last child and
1118 recurse on that. Otherwise, we've found the window we want. */
1121 if (!NILP (XWINDOW (window
)->hchild
))
1122 window
= XWINDOW (window
)->hchild
;
1123 else if (!NILP (XWINDOW (window
)->vchild
))
1124 window
= XWINDOW (window
)->vchild
;
1126 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1130 /* Which windows are acceptable?
1131 Exit the loop and accept this window if
1132 this isn't a minibuffer window, or
1133 we're accepting minibuffer windows, or
1134 we've come all the way around and we're back at the original window. */
1135 while (MINI_WINDOW_P (XWINDOW (window
))
1136 && !EQ (minibuf
, Qt
)
1137 && !EQ (window
, start_window
));
1142 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1143 "Select the ARG'th different window on this frame.\n\
1144 All windows on current frame are arranged in a cyclic order.\n\
1145 This command selects the window ARG steps away in that order.\n\
1146 A negative ARG moves in the opposite order. If the optional second\n\
1147 argument ALL_FRAMES is non-nil, cycle through all frames.")
1149 register Lisp_Object n
, all_frames
;
1152 register Lisp_Object w
;
1154 CHECK_NUMBER (n
, 0);
1155 w
= selected_window
;
1160 w
= Fnext_window (w
, Qnil
, all_frames
);
1165 w
= Fprevious_window (w
, Qnil
, all_frames
);
1172 /* Look at all windows, performing an operation specified by TYPE
1174 If FRAMES is Qt, look at all frames;
1175 Qnil, look at just the selected frame;
1176 Qvisible, look at visible frames;
1177 a frame, just look at windows on that frame.
1178 If MINI is non-zero, perform the operation on minibuffer windows too.
1184 GET_BUFFER_WINDOW
, /* Arg is buffer */
1185 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1186 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1187 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1189 UNSHOW_BUFFER
/* Arg is buffer */
1193 window_loop (type
, obj
, mini
, frames
)
1194 enum window_loop type
;
1195 register Lisp_Object obj
, frames
;
1198 register Lisp_Object w
;
1199 register Lisp_Object best_window
;
1200 register Lisp_Object next_window
;
1201 register Lisp_Object last_window
;
1203 Lisp_Object frame_arg
;
1207 /* If we're only looping through windows on a particular frame,
1208 frame points to that frame. If we're looping through windows
1209 on all frames, frame is 0. */
1210 if (FRAMEP (frames
))
1211 frame
= XFRAME (frames
);
1212 else if (NILP (frames
))
1213 frame
= selected_frame
;
1217 frame_arg
= Qlambda
;
1218 else if (XFASTINT (frames
) == 0)
1220 else if (EQ (frames
, Qvisible
))
1226 /* frame_arg is Qlambda to stick to one frame,
1227 Qvisible to consider all visible frames,
1230 /* Pick a window to start with. */
1234 w
= FRAME_SELECTED_WINDOW (frame
);
1236 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1238 /* Figure out the last window we're going to mess with. Since
1239 Fnext_window, given the same options, is guaranteed to go in a
1240 ring, we can just use Fprevious_window to find the last one.
1242 We can't just wait until we hit the first window again, because
1243 it might be deleted. */
1245 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1250 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1252 /* Pick the next window now, since some operations will delete
1253 the current window. */
1254 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1256 /* Note that we do not pay attention here to whether
1257 the frame is visible, since Fnext_window skips non-visible frames
1258 if that is desired, under the control of frame_arg. */
1259 if (! MINI_WINDOW_P (XWINDOW (w
))
1260 || (mini
&& minibuf_level
> 0))
1263 case GET_BUFFER_WINDOW
:
1264 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1268 case GET_LRU_WINDOW
:
1269 /* t as arg means consider only full-width windows */
1270 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1271 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1273 /* Ignore dedicated windows and minibuffers. */
1274 if (MINI_WINDOW_P (XWINDOW (w
))
1275 || !NILP (XWINDOW (w
)->dedicated
))
1277 if (NILP (best_window
)
1278 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1279 > XFASTINT (XWINDOW (w
)->use_time
)))
1283 case DELETE_OTHER_WINDOWS
:
1284 if (XWINDOW (w
) != XWINDOW (obj
))
1288 case DELETE_BUFFER_WINDOWS
:
1289 if (EQ (XWINDOW (w
)->buffer
, obj
))
1291 /* If we're deleting the buffer displayed in the only window
1292 on the frame, find a new buffer to display there. */
1293 if (NILP (XWINDOW (w
)->parent
))
1295 Lisp_Object new_buffer
;
1296 new_buffer
= Fother_buffer (obj
, Qnil
);
1297 if (NILP (new_buffer
))
1299 = Fget_buffer_create (build_string ("*scratch*"));
1300 Fset_window_buffer (w
, new_buffer
);
1301 if (EQ (w
, selected_window
))
1302 Fset_buffer (XWINDOW (w
)->buffer
);
1309 case GET_LARGEST_WINDOW
:
1310 /* Ignore dedicated windows and minibuffers. */
1311 if (MINI_WINDOW_P (XWINDOW (w
))
1312 || !NILP (XWINDOW (w
)->dedicated
))
1315 struct window
*best_window_ptr
= XWINDOW (best_window
);
1316 struct window
*w_ptr
= XWINDOW (w
);
1317 if (NILP (best_window
)
1318 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1319 > (XFASTINT (best_window_ptr
->height
)
1320 * XFASTINT (best_window_ptr
->width
))))
1326 if (EQ (XWINDOW (w
)->buffer
, obj
))
1328 /* Find another buffer to show in this window. */
1329 Lisp_Object another_buffer
;
1330 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1331 another_buffer
= Fother_buffer (obj
, Qnil
);
1332 if (NILP (another_buffer
))
1334 = Fget_buffer_create (build_string ("*scratch*"));
1336 /* If this window is dedicated, and in a frame of its own,
1338 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1339 && !NILP (XWINDOW (w
)->dedicated
)
1340 && other_visible_frames (f
))
1342 /* Skip the other windows on this frame.
1343 There might be one, the minibuffer! */
1344 if (! EQ (w
, last_window
))
1345 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1347 /* As we go, check for the end of the loop.
1348 We mustn't start going around a second time. */
1349 if (EQ (next_window
, last_window
))
1354 next_window
= Fnext_window (next_window
,
1358 /* Now we can safely delete the frame. */
1359 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1364 /* Otherwise show a different buffer in the window. */
1365 XWINDOW (w
)->dedicated
= Qnil
;
1366 Fset_window_buffer (w
, another_buffer
);
1367 if (EQ (w
, selected_window
))
1368 Fset_buffer (XWINDOW (w
)->buffer
);
1374 if (EQ (w
, last_window
))
1383 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1384 "Return the window least recently selected or used for display.\n\
1385 If optional argument FRAME is `visible', search all visible frames.\n\
1386 If FRAME is 0, search all visible and iconified frames.\n\
1387 If FRAME is t, search all frames.\n\
1388 If FRAME is nil, search only the selected frame.\n\
1389 If FRAME is a frame, search only that frame.")
1393 register Lisp_Object w
;
1394 /* First try for a window that is full-width */
1395 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1396 if (!NILP (w
) && !EQ (w
, selected_window
))
1398 /* If none of them, try the rest */
1399 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1402 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1403 "Return the largest window in area.\n\
1404 If optional argument FRAME is `visible', search all visible frames.\n\
1405 If FRAME is 0, search all visible and iconified frames.\n\
1406 If FRAME is t, search all frames.\n\
1407 If FRAME is nil, search only the selected frame.\n\
1408 If FRAME is a frame, search only that frame.")
1412 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1416 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1417 "Return a window currently displaying BUFFER, or nil if none.\n\
1418 If optional argument FRAME is `visible', search all visible frames.\n\
1419 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1420 If FRAME is t, search all frames.\n\
1421 If FRAME is nil, search only the selected frame.\n\
1422 If FRAME is a frame, search only that frame.")
1424 Lisp_Object buffer
, frame
;
1426 buffer
= Fget_buffer (buffer
);
1427 if (BUFFERP (buffer
))
1428 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1433 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1435 "Make WINDOW (or the selected window) fill its frame.\n\
1436 Only the frame WINDOW is on is affected.\n\
1437 This function tries to reduce display jumps\n\
1438 by keeping the text previously visible in WINDOW\n\
1439 in the same place on the frame. Doing this depends on\n\
1440 the value of (window-start WINDOW), so if calling this function\n\
1441 in a program gives strange scrolling, make sure the window-start\n\
1442 value is reasonable when this function is called.")
1451 window
= selected_window
;
1453 CHECK_LIVE_WINDOW (window
, 0);
1455 w
= XWINDOW (window
);
1457 startpos
= marker_position (w
->start
);
1458 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1460 if (MINI_WINDOW_P (w
) && top
> 0)
1461 error ("Can't expand minibuffer to full frame");
1463 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1465 /* Try to minimize scrolling, by setting the window start to the point
1466 will cause the text at the old window start to be at the same place
1467 on the frame. But don't try to do this if the window start is
1468 outside the visible portion (as might happen when the display is
1469 not current, due to typeahead). */
1470 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1471 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1473 struct position pos
;
1474 struct buffer
*obuf
= current_buffer
;
1476 Fset_buffer (w
->buffer
);
1477 /* This computation used to temporarily move point, but that can
1478 have unwanted side effects due to text properties. */
1479 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1480 XINT (w
->hscroll
), window
);
1481 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1482 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1483 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1486 set_buffer_internal (obuf
);
1491 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1492 1, 2, "bDelete windows on (buffer): ",
1493 "Delete all windows showing BUFFER.\n\
1494 Optional second argument FRAME controls which frames are affected.\n\
1495 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1496 If t, delete only windows showing BUFFER in the selected frame.\n\
1497 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1498 If a frame, delete only windows showing BUFFER in that frame.")
1500 Lisp_Object buffer
, frame
;
1503 /* FRAME uses t and nil to mean the opposite of what window_loop
1505 if (! FRAMEP (frame
))
1506 frame
= NILP (frame
) ? Qt
: Qnil
;
1513 buffer
= Fget_buffer (buffer
);
1514 CHECK_BUFFER (buffer
, 0);
1515 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1520 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1521 Sreplace_buffer_in_windows
,
1522 1, 1, "bReplace buffer in windows: ",
1523 "Replace BUFFER with some other buffer in all windows showing it.")
1529 buffer
= Fget_buffer (buffer
);
1530 CHECK_BUFFER (buffer
, 0);
1531 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1536 /* Set the height of WINDOW and all its inferiors. */
1538 /* The smallest acceptable dimensions for a window. Anything smaller
1539 might crash Emacs. */
1540 #define MIN_SAFE_WINDOW_WIDTH (2)
1541 #define MIN_SAFE_WINDOW_HEIGHT (2)
1543 /* Make sure that window_min_height and window_min_width are
1544 not too small; if they are, set them to safe minima. */
1547 check_min_window_sizes ()
1549 /* Smaller values might permit a crash. */
1550 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1551 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1552 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1553 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1556 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1557 minimum allowable size. */
1559 check_frame_size (frame
, rows
, cols
)
1563 /* For height, we have to see:
1564 whether the frame has a minibuffer,
1565 whether it wants a mode line, and
1566 whether it has a menu bar. */
1568 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1569 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1570 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1571 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1572 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1574 if (*rows
< min_height
)
1576 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1577 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1580 /* Normally the window is deleted if it gets too small.
1581 nodelete nonzero means do not do this.
1582 (The caller should check later and do so if appropriate) */
1584 set_window_height (window
, height
, nodelete
)
1589 register struct window
*w
= XWINDOW (window
);
1590 register struct window
*c
;
1591 int oheight
= XFASTINT (w
->height
);
1592 int top
, pos
, lastbot
, opos
, lastobot
;
1595 check_min_window_sizes ();
1598 && ! NILP (w
->parent
)
1599 && height
< window_min_height
)
1601 Fdelete_window (window
);
1605 XSETFASTINT (w
->last_modified
, 0);
1606 windows_or_buffers_changed
++;
1607 XSETFASTINT (w
->height
, height
);
1608 if (!NILP (w
->hchild
))
1610 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1612 XWINDOW (child
)->top
= w
->top
;
1613 set_window_height (child
, height
, nodelete
);
1616 else if (!NILP (w
->vchild
))
1618 lastbot
= top
= XFASTINT (w
->top
);
1620 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1622 c
= XWINDOW (child
);
1624 opos
= lastobot
+ XFASTINT (c
->height
);
1626 XSETFASTINT (c
->top
, lastbot
);
1628 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1630 /* Avoid confusion: inhibit deletion of child if becomes too small */
1631 set_window_height (child
, pos
+ top
- lastbot
, 1);
1633 /* Now advance child to next window,
1634 and set lastbot if child was not just deleted. */
1635 lastbot
= pos
+ top
;
1638 /* Now delete any children that became too small. */
1640 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1642 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1647 /* Recursively set width of WINDOW and its inferiors. */
1649 set_window_width (window
, width
, nodelete
)
1654 register struct window
*w
= XWINDOW (window
);
1655 register struct window
*c
;
1656 int owidth
= XFASTINT (w
->width
);
1657 int left
, pos
, lastright
, opos
, lastoright
;
1660 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1662 Fdelete_window (window
);
1666 XSETFASTINT (w
->last_modified
, 0);
1667 windows_or_buffers_changed
++;
1668 XSETFASTINT (w
->width
, width
);
1669 if (!NILP (w
->vchild
))
1671 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1673 XWINDOW (child
)->left
= w
->left
;
1674 set_window_width (child
, width
, nodelete
);
1677 else if (!NILP (w
->hchild
))
1679 lastright
= left
= XFASTINT (w
->left
);
1681 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1683 c
= XWINDOW (child
);
1685 opos
= lastoright
+ XFASTINT (c
->width
);
1687 XSETFASTINT (c
->left
, lastright
);
1689 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1691 /* Inhibit deletion for becoming too small */
1692 set_window_width (child
, pos
+ left
- lastright
, 1);
1694 /* Now advance child to next window,
1695 and set lastright if child was not just deleted. */
1696 lastright
= pos
+ left
, lastoright
= opos
;
1698 /* Delete children that became too small */
1700 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1702 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1707 int window_select_count
;
1709 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1710 "Make WINDOW display BUFFER as its contents.\n\
1711 BUFFER can be a buffer or buffer name.")
1713 register Lisp_Object window
, buffer
;
1715 register Lisp_Object tem
;
1716 register struct window
*w
= decode_window (window
);
1718 buffer
= Fget_buffer (buffer
);
1719 CHECK_BUFFER (buffer
, 1);
1721 if (NILP (XBUFFER (buffer
)->name
))
1722 error ("Attempt to display deleted buffer");
1726 error ("Window is deleted");
1727 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1728 is first being set up. */
1730 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1731 error ("Window is dedicated to `%s'",
1732 XSTRING (XBUFFER (tem
)->name
)->data
);
1738 XSETFASTINT (w
->window_end_pos
, 0);
1739 w
->window_end_valid
= Qnil
;
1740 XSETFASTINT(w
->hscroll
, 0);
1741 Fset_marker (w
->pointm
,
1742 make_number (BUF_PT (XBUFFER (buffer
))),
1744 set_marker_restricted (w
->start
,
1745 make_number (XBUFFER (buffer
)->last_window_start
),
1747 w
->start_at_line_beg
= Qnil
;
1748 w
->force_start
= Qnil
;
1749 XSETFASTINT (w
->last_modified
, 0);
1750 windows_or_buffers_changed
++;
1751 if (EQ (window
, selected_window
))
1752 Fset_buffer (buffer
);
1757 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1758 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1759 The main editor command loop selects the buffer of the selected window\n\
1760 before each command.")
1762 register Lisp_Object window
;
1764 register struct window
*w
;
1765 register struct window
*ow
= XWINDOW (selected_window
);
1767 CHECK_LIVE_WINDOW (window
, 0);
1769 w
= XWINDOW (window
);
1771 if (NILP (w
->buffer
))
1772 error ("Trying to select deleted window or non-leaf window");
1774 XSETFASTINT (w
->use_time
, ++window_select_count
);
1775 if (EQ (window
, selected_window
))
1778 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1781 selected_window
= window
;
1783 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1785 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1786 /* Use this rather than Fhandle_switch_frame
1787 so that FRAME_FOCUS_FRAME is moved appropriately as we
1788 move around in the state where a minibuffer in a separate
1790 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1793 selected_frame
->selected_window
= window
;
1796 record_buffer (w
->buffer
);
1797 Fset_buffer (w
->buffer
);
1799 /* Go to the point recorded in the window.
1800 This is important when the buffer is in more
1801 than one window. It also matters when
1802 redisplay_window has altered point after scrolling,
1803 because it makes the change only in the window. */
1805 register int new_point
= marker_position (w
->pointm
);
1806 if (new_point
< BEGV
)
1808 else if (new_point
> ZV
)
1814 windows_or_buffers_changed
++;
1818 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1819 "BDisplay buffer: \nP",
1820 "Make BUFFER appear in some window but don't select it.\n\
1821 BUFFER can be a buffer or a buffer name.\n\
1822 If BUFFER is shown already in some window, just use that one,\n\
1823 unless the window is the selected window and the optional second\n\
1824 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1825 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1826 Returns the window displaying BUFFER.")
1827 (buffer
, not_this_window
)
1828 register Lisp_Object buffer
, not_this_window
;
1830 register Lisp_Object window
, tem
;
1832 buffer
= Fget_buffer (buffer
);
1833 CHECK_BUFFER (buffer
, 0);
1835 if (!NILP (Vdisplay_buffer_function
))
1836 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1838 if (NILP (not_this_window
)
1839 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1840 return selected_window
;
1843 /* If pop_up_frames,
1844 look for a window showing BUFFER on any visible or iconified frame. */
1845 window
= Fget_buffer_window (buffer
, pop_up_frames
? make_number (0) : Qnil
);
1847 window
= Fget_buffer_window (buffer
, Qnil
);
1850 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1853 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1854 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1859 /* Certain buffer names get special handling. */
1860 if (! NILP (Vspecial_display_function
))
1862 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1864 return call1 (Vspecial_display_function
, buffer
);
1866 tem
= Fassoc (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1868 return call2 (Vspecial_display_function
, buffer
, XCONS (tem
)->cdr
);
1870 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1872 Lisp_Object car
= XCONS (tem
)->car
;
1874 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1875 return call1 (Vspecial_display_function
, buffer
);
1876 else if (CONSP (car
)
1877 && STRINGP (XCONS (car
)->car
)
1878 && fast_string_match (XCONS (car
)->car
,
1879 XBUFFER (buffer
)->name
) >= 0)
1880 return call2 (Vspecial_display_function
,
1887 /* If there are no frames open that have more than a minibuffer,
1888 we need to create a new frame. */
1889 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1891 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1892 Fset_window_buffer (window
, buffer
);
1895 #endif /* MULTI_FRAME */
1899 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1900 /* If the current frame is a special display frame,
1901 don't try to reuse its windows. */
1902 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
1910 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1911 XSETFRAME (frames
, last_nonminibuf_frame
);
1913 /* Don't try to create a window if would get an error */
1914 if (split_height_threshold
< window_min_height
<< 1)
1915 split_height_threshold
= window_min_height
<< 1;
1917 /* Note that both Fget_largest_window and Fget_lru_window
1918 ignore minibuffers and dedicated windows.
1919 This means they can return nil. */
1922 /* If the frame we would try to split cannot be split,
1923 try other frames. */
1924 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
1925 : last_nonminibuf_frame
))
1927 /* Try visible frames first. */
1928 window
= Fget_largest_window (Qvisible
);
1929 /* If that didn't work, try iconified frames. */
1931 window
= Fget_largest_window (make_number (0));
1933 window
= Fget_largest_window (Qt
);
1937 window
= Fget_largest_window (frames
);
1939 /* If we got a tall enough full-width window that can be split,
1942 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
1943 && window_height (window
) >= split_height_threshold
1944 && (XFASTINT (XWINDOW (window
)->width
)
1945 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1946 window
= Fsplit_window (window
, Qnil
, Qnil
);
1949 Lisp_Object upper
, lower
, other
;
1951 window
= Fget_lru_window (frames
);
1952 /* If the LRU window is selected, and big enough,
1953 and can be split, split it. */
1955 && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window
)->frame
))
1956 && (EQ (window
, selected_window
)
1957 || EQ (XWINDOW (window
)->parent
, Qnil
))
1958 && window_height (window
) >= window_min_height
<< 1)
1959 window
= Fsplit_window (window
, Qnil
, Qnil
);
1961 /* If Fget_lru_window returned nil, try other approaches. */
1962 /* Try visible frames first. */
1964 window
= Fget_largest_window (Qvisible
);
1965 /* If that didn't work, try iconified frames. */
1967 window
= Fget_largest_window (make_number (0));
1968 /* Try invisible frames. */
1970 window
= Fget_largest_window (Qt
);
1971 /* As a last resort, make a new frame. */
1973 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1975 /* As a last resort, use a non minibuffer window. */
1977 window
= Fframe_first_window (Fselected_frame ());
1979 /* If window appears above or below another,
1980 even out their heights. */
1981 if (!NILP (XWINDOW (window
)->prev
))
1982 other
= upper
= XWINDOW (window
)->prev
, lower
= window
;
1983 if (!NILP (XWINDOW (window
)->next
))
1984 other
= lower
= XWINDOW (window
)->next
, upper
= window
;
1986 /* Check that OTHER and WINDOW are vertically arrayed. */
1987 && XWINDOW (other
)->top
!= XWINDOW (window
)->top
1988 && XWINDOW (other
)->height
> XWINDOW (window
)->height
)
1990 int total
= XWINDOW (other
)->height
+ XWINDOW (window
)->height
;
1991 Lisp_Object old_selected_window
;
1992 old_selected_window
= selected_window
;
1994 selected_window
= upper
;
1995 change_window_height (total
/ 2 - XWINDOW (upper
)->height
, 0);
1996 selected_window
= old_selected_window
;
2001 window
= Fget_lru_window (Qnil
);
2003 Fset_window_buffer (window
, buffer
);
2008 temp_output_buffer_show (buf
)
2009 register Lisp_Object buf
;
2011 register struct buffer
*old
= current_buffer
;
2012 register Lisp_Object window
;
2013 register struct window
*w
;
2016 XBUFFER (buf
)->save_modified
= MODIFF
;
2021 set_buffer_internal (old
);
2023 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
2024 call1 (Vtemp_buffer_show_function
, buf
);
2027 window
= Fdisplay_buffer (buf
, Qnil
);
2030 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2031 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2032 #endif /* MULTI_FRAME */
2033 Vminibuf_scroll_window
= window
;
2034 w
= XWINDOW (window
);
2035 XSETFASTINT (w
->hscroll
, 0);
2036 set_marker_restricted (w
->start
, make_number (1), buf
);
2037 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2042 make_dummy_parent (window
)
2045 register Lisp_Object old
, new;
2046 register struct window
*o
, *p
;
2049 XSETTYPE (old
, Lisp_Vector
);
2050 new = Fcopy_sequence (old
);
2051 XSETTYPE (new, Lisp_Window
);
2055 XSETFASTINT (p
->sequence_number
, ++sequence_number
);
2057 /* Put new into window structure in place of window */
2058 replace_window (window
, new);
2071 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2072 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2073 WINDOW defaults to selected one and SIZE to half its size.\n\
2074 If optional third arg HOR-FLAG is non-nil, split side by side\n\
2075 and put SIZE columns in the first of the pair.")
2076 (window
, chsize
, horflag
)
2077 Lisp_Object window
, chsize
, horflag
;
2079 register Lisp_Object
new;
2080 register struct window
*o
, *p
;
2084 window
= selected_window
;
2086 CHECK_LIVE_WINDOW (window
, 0);
2088 o
= XWINDOW (window
);
2092 if (!NILP (horflag
))
2093 /* Round odd size up, since this is for the left-hand window,
2094 and it will lose a column for the separators. */
2095 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
2097 size
= XFASTINT (o
->height
) >> 1;
2101 CHECK_NUMBER (chsize
, 1);
2102 size
= XINT (chsize
);
2105 if (MINI_WINDOW_P (o
))
2106 error ("Attempt to split minibuffer window");
2107 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
2108 error ("Attempt to split unsplittable frame");
2110 check_min_window_sizes ();
2114 if (size
< window_min_height
2115 || size
+ window_min_height
> XFASTINT (o
->height
))
2116 args_out_of_range_3 (window
, chsize
, horflag
);
2117 if (NILP (o
->parent
)
2118 || NILP (XWINDOW (o
->parent
)->vchild
))
2120 make_dummy_parent (window
);
2122 XWINDOW (new)->vchild
= window
;
2127 if (size
< window_min_width
2128 || size
+ window_min_width
> XFASTINT (o
->width
))
2129 args_out_of_range_3 (window
, chsize
, horflag
);
2130 if (NILP (o
->parent
)
2131 || NILP (XWINDOW (o
->parent
)->hchild
))
2133 make_dummy_parent (window
);
2135 XWINDOW (new)->hchild
= window
;
2139 /* Now we know that window's parent is a vertical combination
2140 if we are dividing vertically, or a horizontal combination
2141 if we are making side-by-side windows */
2143 windows_or_buffers_changed
++;
2144 new = make_window ();
2147 p
->frame
= o
->frame
;
2149 if (!NILP (p
->next
))
2150 XWINDOW (p
->next
)->prev
= new;
2153 p
->parent
= o
->parent
;
2156 Fset_window_buffer (new, o
->buffer
);
2158 /* Apportion the available frame space among the two new windows */
2160 if (!NILP (horflag
))
2162 p
->height
= o
->height
;
2164 XSETFASTINT (p
->width
, XFASTINT (o
->width
) - size
);
2165 XSETFASTINT (o
->width
, size
);
2166 XSETFASTINT (p
->left
, XFASTINT (o
->left
) + size
);
2171 p
->width
= o
->width
;
2172 XSETFASTINT (p
->height
, XFASTINT (o
->height
) - size
);
2173 XSETFASTINT (o
->height
, size
);
2174 XSETFASTINT (p
->top
, XFASTINT (o
->top
) + size
);
2180 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2181 "Make current window ARG lines bigger.\n\
2182 From program, optional second arg non-nil means grow sideways ARG columns.")
2184 register Lisp_Object n
, side
;
2186 CHECK_NUMBER (n
, 0);
2187 change_window_height (XINT (n
), !NILP (side
));
2191 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2192 "Make current window ARG lines smaller.\n\
2193 From program, optional second arg non-nil means shrink sideways ARG columns.")
2195 register Lisp_Object n
, side
;
2197 CHECK_NUMBER (n
, 0);
2198 change_window_height (-XINT (n
), !NILP (side
));
2203 window_height (window
)
2206 register struct window
*p
= XWINDOW (window
);
2207 return XFASTINT (p
->height
);
2211 window_width (window
)
2214 register struct window
*p
= XWINDOW (window
);
2215 return XFASTINT (p
->width
);
2218 #define MINSIZE(w) \
2220 ? window_min_width \
2221 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2224 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2226 #define CURSIZE(w) \
2227 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2229 /* Unlike set_window_height, this function
2230 also changes the heights of the siblings so as to
2231 keep everything consistent. */
2233 change_window_height (delta
, widthflag
)
2237 register Lisp_Object parent
;
2239 register struct window
*p
;
2241 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2242 register int (*setsizefun
) () = (widthflag
2244 : set_window_height
);
2246 check_min_window_sizes ();
2248 window
= selected_window
;
2251 p
= XWINDOW (window
);
2256 error ("No other window to side of this one");
2259 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2260 : !NILP (XWINDOW (parent
)->vchild
))
2265 sizep
= &CURSIZE (window
);
2268 register int maxdelta
;
2270 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2271 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2272 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2273 /* This is a frame with only one window, a minibuffer-only
2274 or a minibufferless frame. */
2277 if (delta
> maxdelta
)
2278 /* This case traps trying to make the minibuffer
2279 the full frame, or make the only window aside from the
2280 minibuffer the full frame. */
2284 if (*sizep
+ delta
< MINSIZE (window
))
2286 Fdelete_window (window
);
2294 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2296 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2297 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2298 CURBEG (p
->next
) += delta
;
2299 /* This does not change size of p->next,
2300 but it propagates the new top edge to its children */
2301 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2303 else if (!NILP (p
->prev
)
2304 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2306 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2307 CURBEG (window
) -= delta
;
2308 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2312 register int delta1
;
2313 register int opht
= (*sizefun
) (parent
);
2315 /* If trying to grow this window to or beyond size of the parent,
2316 make delta1 so big that, on shrinking back down,
2317 all the siblings end up with less than one line and are deleted. */
2318 if (opht
<= *sizep
+ delta
)
2319 delta1
= opht
* opht
* 2;
2320 /* Otherwise, make delta1 just right so that if we add delta1
2321 lines to this window and to the parent, and then shrink
2322 the parent back to its original size, the new proportional
2323 size of this window will increase by delta. */
2325 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2327 /* Add delta1 lines or columns to this window, and to the parent,
2328 keeping things consistent while not affecting siblings. */
2329 CURSIZE (parent
) = opht
+ delta1
;
2330 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2332 /* Squeeze out delta1 lines or columns from our parent,
2333 shriking this window and siblings proportionately.
2334 This brings parent back to correct size.
2335 Delta1 was calculated so this makes this window the desired size,
2336 taking it all out of the siblings. */
2337 (*setsizefun
) (parent
, opht
, 0);
2340 XSETFASTINT (p
->last_modified
, 0);
2347 /* Return number of lines of text (not counting mode line) in W. */
2350 window_internal_height (w
)
2353 int ht
= XFASTINT (w
->height
);
2355 if (MINI_WINDOW_P (w
))
2358 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2359 || !NILP (w
->next
) || !NILP (w
->prev
)
2360 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2367 /* Return the number of columns in W.
2368 Don't count columns occupied by scroll bars or the vertical bar
2369 separating W from the sibling to its right. */
2371 window_internal_width (w
)
2374 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2375 int left
= XINT (w
->left
);
2376 int width
= XINT (w
->width
);
2378 /* If this window is flush against the right edge of the frame, its
2379 internal width is its full width. */
2380 if (left
+ width
>= FRAME_WIDTH (f
))
2383 /* If we are not flush right, then our rightmost columns are
2384 occupied by some sort of separator. */
2386 /* Scroll bars occupy a few columns. */
2387 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2388 return width
- FRAME_SCROLL_BAR_COLS (f
);
2390 /* The column of `|' characters separating side-by-side windows
2391 occupies one column only. */
2396 /* Scroll contents of window WINDOW up N lines. */
2399 window_scroll (window
, n
, noerror
)
2404 register struct window
*w
= XWINDOW (window
);
2405 register int opoint
= PT
;
2407 register int ht
= window_internal_height (w
);
2408 register Lisp_Object tem
;
2410 Lisp_Object bolp
, nmoved
;
2412 XSETFASTINT (tem
, PT
);
2413 tem
= Fpos_visible_in_window_p (tem
, window
);
2417 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2418 XSETFASTINT (tem
, PT
);
2419 Fset_marker (w
->start
, tem
, w
->buffer
);
2420 w
->force_start
= Qt
;
2423 SET_PT (marker_position (w
->start
));
2424 lose
= n
< 0 && PT
== BEGV
;
2425 Fvertical_motion (make_number (n
), window
);
2435 Fsignal (Qbeginning_of_buffer
, Qnil
);
2440 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2441 w
->start_at_line_beg
= bolp
;
2442 w
->update_mode_line
= Qt
;
2443 XSETFASTINT (w
->last_modified
, 0);
2449 tem
= Fvertical_motion (make_number (ht
), window
);
2450 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2453 Fvertical_motion (make_number (-1), window
);
2461 Fsignal (Qend_of_buffer
, Qnil
);
2465 /* This is the guts of Fscroll_up and Fscroll_down. */
2468 scroll_command (n
, direction
)
2469 register Lisp_Object n
;
2472 register int defalt
;
2473 int count
= specpdl_ptr
- specpdl
;
2475 /* If selected window's buffer isn't current, make it current for the moment.
2476 But don't screw up if window_scroll gets an error. */
2477 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2479 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2480 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2483 defalt
= (window_internal_height (XWINDOW (selected_window
))
2484 - next_screen_context_lines
);
2485 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2488 window_scroll (selected_window
, defalt
, 0);
2489 else if (EQ (n
, Qminus
))
2490 window_scroll (selected_window
, - defalt
, 0);
2493 n
= Fprefix_numeric_value (n
);
2494 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2497 unbind_to (count
, Qnil
);
2500 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2501 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2502 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2503 Negative ARG means scroll downward.\n\
2504 When calling from a program, supply a number as argument or nil.")
2508 scroll_command (n
, 1);
2512 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2513 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2514 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2515 Negative ARG means scroll upward.\n\
2516 When calling from a program, supply a number as argument or nil.")
2520 scroll_command (n
, -1);
2524 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2525 "Return the other window for \"other window scroll\" commands.\n\
2526 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2527 specifies the window.\n\
2528 If `other-window-scroll-buffer' is non-nil, a window\n\
2529 showing that buffer is used.")
2534 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2535 && !NILP (Vminibuf_scroll_window
))
2536 window
= Vminibuf_scroll_window
;
2537 /* If buffer is specified, scroll that buffer. */
2538 else if (!NILP (Vother_window_scroll_buffer
))
2540 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2542 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2546 /* Nothing specified; look for a neighboring window on the same
2548 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2550 if (EQ (window
, selected_window
))
2551 /* That didn't get us anywhere; look for a window on another
2554 window
= Fnext_window (window
, Qnil
, Qt
);
2555 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2556 && ! EQ (window
, selected_window
));
2559 CHECK_LIVE_WINDOW (window
, 0);
2561 if (EQ (window
, selected_window
))
2562 error ("There is no other window");
2567 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2568 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2569 The next window is the one below the current one; or the one at the top\n\
2570 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2571 When calling from a program, supply a number as argument or nil.\n\
2573 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2574 specifies the window to scroll.\n\
2575 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2576 showing that buffer, popping the buffer up if necessary.")
2578 register Lisp_Object n
;
2580 register Lisp_Object window
;
2582 register struct window
*w
;
2583 register int count
= specpdl_ptr
- specpdl
;
2585 window
= Fother_window_for_scrolling ();
2587 w
= XWINDOW (window
);
2588 ht
= window_internal_height (w
);
2590 /* Don't screw up if window_scroll gets an error. */
2591 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2593 Fset_buffer (w
->buffer
);
2594 SET_PT (marker_position (w
->pointm
));
2597 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2598 else if (EQ (n
, Qminus
))
2599 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2604 CHECK_NUMBER (n
, 0);
2605 window_scroll (window
, XINT (n
), 1);
2608 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2609 unbind_to (count
, Qnil
);
2614 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2615 "Scroll selected window display ARG columns left.\n\
2616 Default for ARG is window width minus 2.")
2618 register Lisp_Object arg
;
2622 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2624 arg
= Fprefix_numeric_value (arg
);
2627 Fset_window_hscroll (selected_window
,
2628 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2632 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2633 "Scroll selected window display ARG columns right.\n\
2634 Default for ARG is window width minus 2.")
2636 register Lisp_Object arg
;
2639 XSETFASTINT (arg
, window_internal_width (XWINDOW (selected_window
)) - 2);
2641 arg
= Fprefix_numeric_value (arg
);
2644 Fset_window_hscroll (selected_window
,
2645 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2649 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2650 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2651 The desired position of point is always relative to the current window.\n\
2652 Just C-u as prefix means put point in the center of the window.\n\
2653 No arg (i.e., it is nil) erases the entire frame and then\n\
2654 redraws with point in the center of the current window.")
2656 register Lisp_Object n
;
2658 register struct window
*w
= XWINDOW (selected_window
);
2659 register int ht
= window_internal_height (w
);
2660 struct position pos
;
2665 extern int frame_garbaged
;
2667 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2668 XSETFASTINT (n
, ht
/ 2);
2670 else if (CONSP (n
)) /* Just C-u. */
2672 XSETFASTINT (n
, ht
/ 2);
2676 n
= Fprefix_numeric_value (n
);
2677 CHECK_NUMBER (n
, 0);
2681 XSETINT (n
, XINT (n
) + ht
);
2683 XSETWINDOW (window
, w
);
2684 pos
= *vmotion (point
, - XINT (n
), window_internal_width (w
) - 1,
2685 XINT (w
->hscroll
), window
);
2687 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
2688 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
2689 || FETCH_CHAR (pos
.bufpos
- 1) == '\n')
2691 w
->force_start
= Qt
;
2696 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2698 "Position point relative to window.\n\
2699 With no argument, position point at center of window.\n\
2700 An argument specifies frame line; zero means top of window,\n\
2701 negative means relative to bottom of window.")
2703 register Lisp_Object arg
;
2705 register struct window
*w
= XWINDOW (selected_window
);
2706 register int height
= window_internal_height (w
);
2711 XSETFASTINT (arg
, height
/ 2);
2714 arg
= Fprefix_numeric_value (arg
);
2716 XSETINT (arg
, XINT (arg
) + height
);
2719 start
= marker_position (w
->start
);
2720 XSETWINDOW (window
, w
);
2721 if (start
< BEGV
|| start
> ZV
)
2723 Fvertical_motion (make_number (- (height
/ 2)), window
);
2724 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2725 w
->start_at_line_beg
= Fbolp ();
2726 w
->force_start
= Qt
;
2731 return Fvertical_motion (arg
, window
);
2734 struct save_window_data
2736 int size_from_Lisp_Vector_struct
;
2737 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2738 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2739 Lisp_Object selected_frame
;
2740 Lisp_Object current_window
;
2741 Lisp_Object current_buffer
;
2742 Lisp_Object minibuf_scroll_window
;
2743 Lisp_Object root_window
;
2744 Lisp_Object focus_frame
;
2745 /* Record the values of window-min-width and window-min-height
2746 so that window sizes remain consistent with them. */
2747 Lisp_Object min_width
, min_height
;
2748 /* A vector, interpreted as a struct saved_window */
2749 Lisp_Object saved_windows
;
2752 /* Arg to Fmake_vector */
2753 #define SAVE_WINDOW_DATA_SIZE \
2754 ((sizeof (struct save_window_data) \
2755 - (sizeof (struct Lisp_Vector) \
2756 /* Don't count the contents member of the struct Lisp_Vector */ \
2757 - sizeof (Lisp_Object))) \
2758 / sizeof (Lisp_Object))
2760 /* This is saved as a Lisp_Vector */
2763 /* these first two must agree with struct Lisp_Vector in lisp.h */
2764 int size_from_Lisp_Vector_struct
;
2765 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2768 Lisp_Object buffer
, start
, pointm
, mark
;
2769 Lisp_Object left
, top
, width
, height
, hscroll
;
2770 Lisp_Object parent
, prev
;
2771 Lisp_Object start_at_line_beg
;
2772 Lisp_Object display_table
;
2774 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2776 #define SAVED_WINDOW_N(swv,n) \
2777 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2779 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2780 "T if OBJECT is a window-configration object.")
2784 if (WINDOW_CONFIGURATIONP (obj
))
2790 DEFUN ("set-window-configuration", Fset_window_configuration
,
2791 Sset_window_configuration
, 1, 1, 0,
2792 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2793 CONFIGURATION must be a value previously returned\n\
2794 by `current-window-configuration' (which see).")
2796 Lisp_Object configuration
;
2798 register struct save_window_data
*data
;
2799 struct Lisp_Vector
*saved_windows
;
2800 Lisp_Object new_current_buffer
;
2804 while (!WINDOW_CONFIGURATIONP (configuration
))
2806 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2810 data
= (struct save_window_data
*) XVECTOR (configuration
);
2811 saved_windows
= XVECTOR (data
->saved_windows
);
2813 new_current_buffer
= data
->current_buffer
;
2814 if (NILP (XBUFFER (new_current_buffer
)->name
))
2815 new_current_buffer
= Qnil
;
2817 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2820 /* If f is a dead frame, don't bother rebuilding its window tree.
2821 However, there is other stuff we should still try to do below. */
2822 if (FRAME_LIVE_P (f
))
2824 register struct window
*w
;
2825 register struct saved_window
*p
;
2828 /* If the frame has been resized since this window configuration was
2829 made, we change the frame to the size specified in the
2830 configuration, restore the configuration, and then resize it
2831 back. We keep track of the prevailing height in these variables. */
2832 int previous_frame_height
= FRAME_HEIGHT (f
);
2833 int previous_frame_width
= FRAME_WIDTH (f
);
2834 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2836 if (XFASTINT (data
->frame_height
) != previous_frame_height
2837 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2838 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2839 #ifdef HAVE_X_WINDOWS
2840 if (XFASTINT (data
->frame_menu_bar_lines
)
2841 != previous_frame_menu_bar_lines
)
2842 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2845 windows_or_buffers_changed
++;
2847 /* Temporarily avoid any problems with windows that are smaller
2848 than they are supposed to be. */
2849 window_min_height
= 1;
2850 window_min_width
= 1;
2853 Mark all windows now on frame as "deleted".
2854 Restoring the new configuration "undeletes" any that are in it.
2856 Save their current buffers in their height fields, since we may
2857 need it later, if a buffer saved in the configuration is now
2859 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2861 for (k
= 0; k
< saved_windows
->size
; k
++)
2863 p
= SAVED_WINDOW_N (saved_windows
, k
);
2864 w
= XWINDOW (p
->window
);
2867 if (!NILP (p
->parent
))
2868 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2869 XFASTINT (p
->parent
))->window
;
2873 if (!NILP (p
->prev
))
2875 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2876 XFASTINT (p
->prev
))->window
;
2877 XWINDOW (w
->prev
)->next
= p
->window
;
2882 if (!NILP (w
->parent
))
2884 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2886 XWINDOW (w
->parent
)->vchild
= p
->window
;
2887 XWINDOW (w
->parent
)->hchild
= Qnil
;
2891 XWINDOW (w
->parent
)->hchild
= p
->window
;
2892 XWINDOW (w
->parent
)->vchild
= Qnil
;
2897 /* If we squirreled away the buffer in the window's height,
2899 if (BUFFERP (w
->height
))
2900 w
->buffer
= w
->height
;
2903 w
->width
= p
->width
;
2904 w
->height
= p
->height
;
2905 w
->hscroll
= p
->hscroll
;
2906 w
->display_table
= p
->display_table
;
2907 XSETFASTINT (w
->last_modified
, 0);
2909 /* Reinstall the saved buffer and pointers into it. */
2910 if (NILP (p
->buffer
))
2911 w
->buffer
= p
->buffer
;
2914 if (!NILP (XBUFFER (p
->buffer
)->name
))
2915 /* If saved buffer is alive, install it. */
2917 w
->buffer
= p
->buffer
;
2918 w
->start_at_line_beg
= p
->start_at_line_beg
;
2919 set_marker_restricted (w
->start
,
2920 Fmarker_position (p
->start
),
2922 set_marker_restricted (w
->pointm
,
2923 Fmarker_position (p
->pointm
),
2925 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2926 Fmarker_position (p
->mark
), w
->buffer
);
2928 /* As documented in Fcurrent_window_configuration, don't
2929 save the location of point in the buffer which was current
2930 when the window configuration was recorded. */
2931 if (!EQ (p
->buffer
, new_current_buffer
)
2932 && XBUFFER (p
->buffer
) == current_buffer
)
2933 Fgoto_char (w
->pointm
);
2935 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2936 /* Else unless window has a live buffer, get one. */
2938 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2939 /* This will set the markers to beginning of visible
2941 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2942 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2943 w
->start_at_line_beg
= Qt
;
2946 /* Keeping window's old buffer; make sure the markers
2949 /* Set window markers at start of visible range. */
2950 if (XMARKER (w
->start
)->buffer
== 0)
2951 set_marker_restricted (w
->start
, make_number (0),
2953 if (XMARKER (w
->pointm
)->buffer
== 0)
2954 set_marker_restricted (w
->pointm
,
2956 (BUF_PT (XBUFFER (w
->buffer
)))),
2958 w
->start_at_line_beg
= Qt
;
2963 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2964 Fselect_window (data
->current_window
);
2967 if (NILP (data
->focus_frame
)
2968 || (FRAMEP (data
->focus_frame
)
2969 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2970 Fredirect_frame_focus (frame
, data
->focus_frame
);
2973 #if 0 /* I don't understand why this is needed, and it causes problems
2974 when the frame's old selected window has been deleted. */
2976 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2977 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2981 /* Set the screen height to the value it had before this function. */
2982 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2983 || previous_frame_width
!= FRAME_WIDTH (f
))
2984 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2986 #ifdef HAVE_X_WINDOWS
2987 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2988 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2992 /* Restore the minimum heights recorded in the configuration. */
2993 window_min_height
= XINT (data
->min_height
);
2994 window_min_width
= XINT (data
->min_width
);
2997 /* Fselect_window will have made f the selected frame, so we
2998 reselect the proper frame here. Fhandle_switch_frame will change the
2999 selected window too, but that doesn't make the call to
3000 Fselect_window above totally superfluous; it still sets f's
3002 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
3003 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
3006 if (!NILP (new_current_buffer
))
3007 Fset_buffer (new_current_buffer
);
3009 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
3013 /* Mark all windows now on frame as deleted
3014 by setting their buffers to nil. */
3017 delete_all_subwindows (w
)
3018 register struct window
*w
;
3020 if (!NILP (w
->next
))
3021 delete_all_subwindows (XWINDOW (w
->next
));
3022 if (!NILP (w
->vchild
))
3023 delete_all_subwindows (XWINDOW (w
->vchild
));
3024 if (!NILP (w
->hchild
))
3025 delete_all_subwindows (XWINDOW (w
->hchild
));
3027 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3029 /* We set all three of these fields to nil, to make sure that we can
3030 distinguish this dead window from any live window. Live leaf
3031 windows will have buffer set, and combination windows will have
3032 vchild or hchild set. */
3039 count_windows (window
)
3040 register struct window
*window
;
3042 register int count
= 1;
3043 if (!NILP (window
->next
))
3044 count
+= count_windows (XWINDOW (window
->next
));
3045 if (!NILP (window
->vchild
))
3046 count
+= count_windows (XWINDOW (window
->vchild
));
3047 if (!NILP (window
->hchild
))
3048 count
+= count_windows (XWINDOW (window
->hchild
));
3053 save_window_save (window
, vector
, i
)
3055 struct Lisp_Vector
*vector
;
3058 register struct saved_window
*p
;
3059 register struct window
*w
;
3060 register Lisp_Object tem
;
3062 for (;!NILP (window
); window
= w
->next
)
3064 p
= SAVED_WINDOW_N (vector
, i
);
3065 w
= XWINDOW (window
);
3067 XSETFASTINT (w
->temslot
, i
++);
3069 p
->buffer
= w
->buffer
;
3072 p
->width
= w
->width
;
3073 p
->height
= w
->height
;
3074 p
->hscroll
= w
->hscroll
;
3075 p
->display_table
= w
->display_table
;
3076 if (!NILP (w
->buffer
))
3078 /* Save w's value of point in the window configuration.
3079 If w is the selected window, then get the value of point
3080 from the buffer; pointm is garbage in the selected window. */
3081 if (EQ (window
, selected_window
))
3083 p
->pointm
= Fmake_marker ();
3084 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
3088 p
->pointm
= Fcopy_marker (w
->pointm
);
3090 p
->start
= Fcopy_marker (w
->start
);
3091 p
->start_at_line_beg
= w
->start_at_line_beg
;
3093 tem
= XBUFFER (w
->buffer
)->mark
;
3094 p
->mark
= Fcopy_marker (tem
);
3101 p
->start_at_line_beg
= Qnil
;
3104 if (NILP (w
->parent
))
3107 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3112 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3114 if (!NILP (w
->vchild
))
3115 i
= save_window_save (w
->vchild
, vector
, i
);
3116 if (!NILP (w
->hchild
))
3117 i
= save_window_save (w
->hchild
, vector
, i
);
3123 DEFUN ("current-window-configuration",
3124 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3125 "Return an object representing the current window configuration of FRAME.\n\
3126 If FRAME is nil or omitted, use the selected frame.\n\
3127 This describes the number of windows, their sizes and current buffers,\n\
3128 and for each displayed buffer, where display starts, and the positions of\n\
3129 point and mark. An exception is made for point in the current buffer:\n\
3130 its value is -not- saved.\n\
3131 This also records the currently selected frame, and FRAME's focus\n\
3132 redirection (see `redirect-frame-focus').")
3136 register Lisp_Object tem
;
3137 register int n_windows
;
3138 register struct save_window_data
*data
;
3146 CHECK_LIVE_FRAME (frame
, 0);
3150 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3151 data
= (struct save_window_data
*)
3152 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
3154 XSETFASTINT (data
->frame_width
, FRAME_WIDTH (f
));
3155 XSETFASTINT (data
->frame_height
, FRAME_HEIGHT (f
));
3156 XSETFASTINT (data
->frame_menu_bar_lines
, FRAME_MENU_BAR_LINES (f
));
3158 XSETFRAME (data
->selected_frame
, selected_frame
);
3160 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3161 XSETBUFFER (data
->current_buffer
, current_buffer
);
3162 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3163 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3164 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3165 XSETINT (data
->min_height
, window_min_height
);
3166 XSETINT (data
->min_width
, window_min_width
);
3167 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3168 data
->saved_windows
= tem
;
3169 for (i
= 0; i
< n_windows
; i
++)
3170 XVECTOR (tem
)->contents
[i
]
3171 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3172 save_window_save (FRAME_ROOT_WINDOW (f
),
3174 XSETWINDOW_CONFIGURATION (tem
, data
);
3178 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3180 "Execute body, preserving window sizes and contents.\n\
3181 Restore which buffer appears in which window, where display starts,\n\
3182 and the value of point and mark for each window.\n\
3183 Also restore which buffer is current.\n\
3184 But do not preserve point in the current buffer.\n\
3185 Does not restore the value of point in current buffer.")
3189 register Lisp_Object val
;
3190 register int count
= specpdl_ptr
- specpdl
;
3192 record_unwind_protect (Fset_window_configuration
,
3193 Fcurrent_window_configuration (Qnil
));
3194 val
= Fprogn (args
);
3195 return unbind_to (count
, val
);
3201 selected_frame
= make_terminal_frame ();
3202 minibuf_window
= selected_frame
->minibuffer_window
;
3203 selected_window
= selected_frame
->selected_window
;
3204 last_nonminibuf_frame
= selected_frame
;
3205 #else /* not MULTI_FRAME */
3206 extern Lisp_Object
get_minibuffer ();
3208 selected_frame
= last_nonminibuf_frame
= &the_only_frame
;
3210 minibuf_window
= make_window ();
3211 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3213 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3214 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3215 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3217 /* These values 9 and 10 are arbitrary,
3218 just so that there is "something there."
3219 Correct values are put in in init_xdisp */
3221 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
, 10);
3222 XSETFASTINT (XWINDOW (minibuf_window
)->width
, 10);
3224 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
, 9);
3225 XSETFASTINT (XWINDOW (minibuf_window
)->top
, 9);
3226 XSETFASTINT (XWINDOW (minibuf_window
)->height
, 1);
3228 /* Prevent error in Fset_window_buffer. */
3229 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3230 XWINDOW (minibuf_window
)->buffer
= Qt
;
3232 /* Now set them up for real. */
3233 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3234 Fcurrent_buffer ());
3235 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3237 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3238 /* Make sure this window seems more recently used than
3239 a newly-created, never-selected window. Increment
3240 window_select_count so the first selection ever will get
3241 something newer than this. */
3242 XSETFASTINT (XWINDOW (selected_window
)->use_time
, ++window_select_count
);
3243 #endif /* not MULTI_FRAME */
3248 Qwindowp
= intern ("windowp");
3249 staticpro (&Qwindowp
);
3251 Qwindow_live_p
= intern ("window-live-p");
3252 staticpro (&Qwindow_live_p
);
3255 /* Make sure all windows get marked */
3256 staticpro (&minibuf_window
);
3259 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3260 "Non-nil means call as function to display a help buffer.\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
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
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");