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 XTYPE (obj
) == Lisp_Window
? 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 ((XTYPE (obj
) == Lisp_Window
117 && ! NILP (XWINDOW (obj
)->buffer
))
124 register Lisp_Object val
;
125 register struct window
*p
;
127 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector)
128 includes the first element. */
130 make_number ((sizeof (struct window
) - sizeof (struct Lisp_Vector
)
131 + sizeof (Lisp_Object
))
132 / sizeof (Lisp_Object
)),
134 XSETTYPE (val
, Lisp_Window
);
136 XFASTINT (p
->sequence_number
) = ++sequence_number
;
137 XFASTINT (p
->left
) = XFASTINT (p
->top
)
138 = XFASTINT (p
->height
) = XFASTINT (p
->width
)
139 = XFASTINT (p
->hscroll
) = 0;
140 XFASTINT (p
->last_point_x
) = XFASTINT (p
->last_point_y
) = 0;
141 p
->start
= Fmake_marker ();
142 p
->pointm
= Fmake_marker ();
143 XFASTINT (p
->use_time
) = 0;
145 p
->display_table
= Qnil
;
150 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
151 "Return the window that the cursor now appears in and commands apply to.")
154 return selected_window
;
157 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
158 "Return the window used now for minibuffers.\n\
159 If the optional argument FRAME is specified, return the minibuffer window\n\
160 used by that frame.")
166 XSET (frame
, Lisp_Frame
, selected_frame
);
168 CHECK_LIVE_FRAME (frame
, 0);
171 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
174 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
175 "Returns non-nil if WINDOW is a minibuffer window.")
179 struct window
*w
= decode_window (window
);
180 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
183 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
184 Spos_visible_in_window_p
, 0, 2, 0,
185 "Return t if position POS is currently on the frame in WINDOW.\n\
186 Returns nil if that position is scrolled vertically out of view.\n\
187 POS defaults to point; WINDOW, to the selected window.")
189 Lisp_Object pos
, window
;
191 register struct window
*w
;
195 register struct buffer
*buf
;
196 struct position posval
;
203 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
207 w
= decode_window (window
);
208 top
= marker_position (w
->start
);
209 hscroll
= XINT (w
->hscroll
);
214 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
216 buf
= XBUFFER (w
->buffer
);
217 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
219 /* If frame is up to date,
220 use the info recorded about how much text fit on it. */
221 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
222 || (XFASTINT (w
->window_end_vpos
) < height
))
228 if (posint
> BUF_ZV (buf
))
231 /* w->start can be out of range. If it is, do something reasonable. */
232 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
235 /* If that info is not correct, calculate afresh */
236 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
238 window_internal_width (w
) - 1,
241 return posval
.vpos
< height
? Qt
: Qnil
;
245 static struct window
*
246 decode_window (window
)
247 register Lisp_Object window
;
250 return XWINDOW (selected_window
);
252 CHECK_LIVE_WINDOW (window
, 0);
253 return XWINDOW (window
);
256 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
257 "Return the buffer that WINDOW is displaying.")
261 return decode_window (window
)->buffer
;
264 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
265 "Return the number of lines in WINDOW (including its mode line).")
269 return decode_window (window
)->height
;
272 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
273 "Return the number of display columns in WINDOW.\n\
274 This is the width that is usable columns available for text in WINDOW.\n\
275 If you want to find out how many columns WINDOW takes up,\n\
276 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
280 return make_number (window_internal_width (decode_window (window
)));
283 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
284 "Return the number of columns by which WINDOW is scrolled from left margin.")
288 return decode_window (window
)->hscroll
;
291 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
292 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
293 NCOL should be zero or positive.")
295 register Lisp_Object window
, ncol
;
297 register struct window
*w
;
299 CHECK_NUMBER (ncol
, 1);
300 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
301 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
302 args_out_of_range (ncol
, Qnil
);
303 w
= decode_window (window
);
304 if (XINT (w
->hscroll
) != XINT (ncol
))
305 clip_changed
= 1; /* Prevent redisplay shortcuts */
310 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
311 "Return a list of the edge coordinates of WINDOW.\n\
312 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
313 RIGHT is one more than the rightmost column used by WINDOW,\n\
314 and BOTTOM is one more than the bottommost row used by WINDOW\n\
319 register struct window
*w
= decode_window (window
);
321 return Fcons (w
->left
, Fcons (w
->top
,
322 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
323 Fcons (make_number (XFASTINT (w
->top
)
324 + XFASTINT (w
->height
)),
328 /* Test if the character at column *x, row *y is within window *w.
329 If it is not, return 0;
330 if it is in the window's text area,
331 set *x and *y to its location relative to the upper left corner
334 if it is on the window's modeline, return 2;
335 if it is on the border between the window and its right sibling,
338 coordinates_in_window (w
, x
, y
)
339 register struct window
*w
;
342 register int left
= XINT (w
->left
);
343 register int width
= XINT (w
->width
);
344 register int window_height
= XINT (w
->height
);
345 register int top
= XFASTINT (w
->top
);
347 if ( *x
< left
|| *x
>= left
+ width
348 || *y
< top
|| *y
>= top
+ window_height
)
351 /* Is the character is the mode line? */
352 if (*y
== top
+ window_height
- 1
353 && ! MINI_WINDOW_P (w
))
356 /* Is the character in the right border? */
357 if (*x
== left
+ width
- 1
358 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
366 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
367 Scoordinates_in_window_p
, 2, 2, 0,
368 "Return non-nil if COORDINATES are in WINDOW.\n\
369 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
370 measured in characters from the upper-left corner of the frame.\n\
371 (0 . 0) denotes the character in the upper left corner of the\n\
373 If COORDINATES are in the text portion of WINDOW,\n\
374 the coordinates relative to the window are returned.\n\
375 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
376 If they are on the border between WINDOW and its right sibling,\n\
377 `vertical-line' is returned.")
378 (coordinates
, window
)
379 register Lisp_Object coordinates
, window
;
383 CHECK_LIVE_WINDOW (window
, 0);
384 CHECK_CONS (coordinates
, 1);
385 x
= XINT (Fcar (coordinates
));
386 y
= XINT (Fcdr (coordinates
));
388 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
390 case 0: /* NOT in window at all. */
393 case 1: /* In text part of window. */
396 case 2: /* In mode line of window. */
399 case 3: /* On right border of window. */
400 return Qvertical_line
;
407 /* Find the window containing column x, row y, and return it as a
408 Lisp_Object. If x, y is on the window's modeline, set *part
409 to 1; if it is on the separating line between the window and its
410 right sibling, set it to 2; otherwise set it to 0. If there is no
411 window under x, y return nil and leave *part unmodified. */
413 window_from_coordinates (frame
, x
, y
, part
)
418 register Lisp_Object tem
, first
;
420 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
424 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
432 tem
= Fnext_window (tem
, Qt
, Qlambda
);
434 while (! EQ (tem
, first
));
439 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
440 "Return window containing coordinates X and Y on FRAME.\n\
441 If omitted, FRAME defaults to the currently selected frame.\n\
442 The top left corner of the frame is considered to be row 0,\n\
445 Lisp_Object x
, y
, frame
;
451 XSET (frame
, Lisp_Frame
, selected_frame
);
453 CHECK_LIVE_FRAME (frame
, 2);
458 return window_from_coordinates (XFRAME (frame
),
463 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
464 "Return current value of point in WINDOW.\n\
465 For a nonselected window, this is the value point would have\n\
466 if that window were selected.\n\
468 Note that, when WINDOW is the selected window and its buffer\n\
469 is also currently selected, the value returned is the same as (point).\n\
470 It would be more strictly correct to return the `top-level' value\n\
471 of point, outside of any save-excursion forms.\n\
472 But that is hard to define.")
476 register struct window
*w
= decode_window (window
);
478 if (w
== XWINDOW (selected_window
)
479 && current_buffer
== XBUFFER (w
->buffer
))
481 return Fmarker_position (w
->pointm
);
484 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
485 "Return position at which display currently starts in WINDOW.")
489 return Fmarker_position (decode_window (window
)->start
);
492 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
493 "Return position at which display currently ends in WINDOW.\n\
494 This is updated by redisplay, when it runs to completion.\n\
495 Simply changing the buffer text or setting `window-start'\n\
496 does not update this value.")
501 struct window
*w
= decode_window (window
);
505 CHECK_BUFFER (buf
, 0);
507 XSET (value
, Lisp_Int
,
508 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
513 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
514 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
516 Lisp_Object window
, pos
;
518 register struct window
*w
= decode_window (window
);
520 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
521 if (w
== XWINDOW (selected_window
))
524 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
529 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
530 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
531 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
532 from overriding motion of point in order to display at this exact start.")
533 (window
, pos
, noforce
)
534 Lisp_Object window
, pos
, noforce
;
536 register struct window
*w
= decode_window (window
);
538 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
539 set_marker_restricted (w
->start
, pos
, w
->buffer
);
540 /* this is not right, but much easier than doing what is right. */
541 w
->start_at_line_beg
= Qnil
;
544 w
->update_mode_line
= Qt
;
545 XFASTINT (w
->last_modified
) = 0;
546 if (!EQ (window
, selected_window
))
547 windows_or_buffers_changed
++;
551 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
553 "Return WINDOW's dedicated object, usually t or nil.\n\
554 See also `set-window-dedicated-p'.")
558 return decode_window (window
)->dedicated
;
561 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
562 Sset_window_dedicated_p
, 2, 2, 0,
563 "Control whether WINDOW is dedicated to the buffer it displays.\n\
564 If it is dedicated, Emacs will not automatically change\n\
565 which buffer appears in it.\n\
566 The second argument is the new value for the dedication flag;\n\
569 Lisp_Object window
, arg
;
571 register struct window
*w
= decode_window (window
);
581 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
583 "Return the display-table that WINDOW is using.")
587 return decode_window (window
)->display_table
;
590 /* Get the display table for use currently on window W.
591 This is either W's display table or W's buffer's display table.
592 Ignore the specified tables if they are not valid;
593 if no valid table is specified, return 0. */
596 window_display_table (w
)
600 tem
= w
->display_table
;
601 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
602 return XVECTOR (tem
);
603 tem
= XBUFFER (w
->buffer
)->display_table
;
604 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
605 return XVECTOR (tem
);
606 tem
= Vstandard_display_table
;
607 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
608 return XVECTOR (tem
);
612 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
613 "Set WINDOW's display-table to TABLE.")
615 register Lisp_Object window
, table
;
617 register struct window
*w
;
618 register Lisp_Object z
; /* Return value. */
620 w
= decode_window (window
);
621 w
->display_table
= table
;
625 /* Record info on buffer window w is displaying
626 when it is about to cease to display that buffer. */
629 register struct window
*w
;
634 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
638 if (w
== XWINDOW (selected_window
)
639 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
640 /* Do this except when the selected window's buffer
641 is being removed from some other window. */
643 /* last_window_start records the start position that this buffer
644 had in the last window to be disconnected from it.
645 Now that this statement is unconditional,
646 it is possible for the buffer to be displayed in the
647 selected window, while last_window_start reflects another
648 window which was recently showing the same buffer.
649 Some people might say that might be a good thing. Let's see. */
650 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
652 /* Point in the selected window's buffer
653 is actually stored in that buffer, and the window's pointm isn't used.
654 So don't clobber point in that buffer. */
655 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
656 BUF_PT (XBUFFER (buf
))
657 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
658 marker_position (w
->pointm
),
659 BUF_ZV (XBUFFER (buf
)));
662 /* Put replacement into the window structure in place of old. */
664 replace_window (old
, replacement
)
665 Lisp_Object old
, replacement
;
667 register Lisp_Object tem
;
668 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
670 /* If OLD is its frame's root_window, then replacement is the new
671 root_window for that frame. */
673 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
674 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
679 p
->height
= o
->height
;
681 p
->next
= tem
= o
->next
;
683 XWINDOW (tem
)->prev
= replacement
;
685 p
->prev
= tem
= o
->prev
;
687 XWINDOW (tem
)->next
= replacement
;
689 p
->parent
= tem
= o
->parent
;
692 if (EQ (XWINDOW (tem
)->vchild
, old
))
693 XWINDOW (tem
)->vchild
= replacement
;
694 if (EQ (XWINDOW (tem
)->hchild
, old
))
695 XWINDOW (tem
)->hchild
= replacement
;
698 /*** Here, if replacement is a vertical combination
699 and so is its new parent, we should make replacement's
700 children be children of that parent instead. ***/
703 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
704 "Remove WINDOW from the display. Default is selected window.")
706 register Lisp_Object window
;
708 register Lisp_Object tem
, parent
, sib
;
709 register struct window
*p
;
710 register struct window
*par
;
712 /* Because this function is called by other C code on non-leaf
713 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
714 so we can't decode_window here. */
716 window
= selected_window
;
718 CHECK_WINDOW (window
, 0);
719 p
= XWINDOW (window
);
721 /* It's okay to delete an already-deleted window. */
729 error ("Attempt to delete minibuffer or sole ordinary window");
730 par
= XWINDOW (parent
);
732 windows_or_buffers_changed
++;
734 /* Are we trying to delete any frame's selected window? */
736 Lisp_Object frame
, pwindow
;
738 /* See if the frame's selected window is either WINDOW
739 or any subwindow of it, by finding all that window's parents
740 and comparing each one with WINDOW. */
741 frame
= WINDOW_FRAME (XWINDOW (window
));
742 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
744 while (!NILP (pwindow
))
746 if (EQ (window
, pwindow
))
748 pwindow
= XWINDOW (pwindow
)->parent
;
751 if (EQ (window
, pwindow
))
753 Lisp_Object alternative
;
754 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
756 /* If we're about to delete the selected window on the
757 selected frame, then we should use Fselect_window to select
758 the new window. On the other hand, if we're about to
759 delete the selected window on any other frame, we shouldn't do
760 anything but set the frame's selected_window slot. */
761 if (EQ (window
, selected_window
))
762 Fselect_window (alternative
);
764 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
769 /* tem is null for dummy parent windows
770 (which have inferiors but not any contents themselves) */
774 unchain_marker (p
->pointm
);
775 unchain_marker (p
->start
);
780 XWINDOW (tem
)->prev
= p
->prev
;
784 XWINDOW (tem
)->next
= p
->next
;
786 if (EQ (window
, par
->hchild
))
787 par
->hchild
= p
->next
;
788 if (EQ (window
, par
->vchild
))
789 par
->vchild
= p
->next
;
791 /* Find one of our siblings to give our space to. */
795 /* If p gives its space to its next sibling, that sibling needs
796 to have its top/left side pulled back to where p's is.
797 set_window_{height,width} will re-position the sibling's
800 XWINDOW (sib
)->top
= p
->top
;
801 XWINDOW (sib
)->left
= p
->left
;
804 /* Stretch that sibling. */
805 if (!NILP (par
->vchild
))
806 set_window_height (sib
,
807 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
809 if (!NILP (par
->hchild
))
810 set_window_width (sib
,
811 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
814 /* If parent now has only one child,
815 put the child into the parent's place. */
819 if (NILP (XWINDOW (tem
)->next
))
820 replace_window (parent
, tem
);
822 /* Since we may be deleting combination windows, we must make sure that
823 not only p but all its children have been marked as deleted. */
824 if (! NILP (p
->hchild
))
825 delete_all_subwindows (XWINDOW (p
->hchild
));
826 else if (! NILP (p
->vchild
))
827 delete_all_subwindows (XWINDOW (p
->vchild
));
829 /* Mark this window as deleted. */
830 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
836 extern Lisp_Object
next_frame (), prev_frame ();
838 /* This comment supplies the doc string for `next-window',
839 for make-docfile to see. We cannot put this in the real DEFUN
840 due to limits in the Unix cpp.
842 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
843 "Return next window after WINDOW in canonical ordering of windows.\n\
844 If omitted, WINDOW defaults to the selected window.\n\
846 Optional second arg MINIBUF t means count the minibuffer window even\n\
847 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
848 it is active. MINIBUF neither t nor nil means not to count the\n\
849 minibuffer even if it is active.\n\
851 Several frames may share a single minibuffer; if the minibuffer\n\
852 counts, all windows on all frames that share that minibuffer count\n\
853 too. Therefore, `next-window' can be used to iterate through the\n\
854 set of windows even when the minibuffer is on another frame. If the\n\
855 minibuffer does not count, only windows from WINDOW's frame count.\n\
857 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
858 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
859 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
860 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
861 Anything else means restrict to WINDOW's frame.\n\
863 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
864 `next-window' to iterate through the entire cycle of acceptable\n\
865 windows, eventually ending up back at the window you started with.\n\
866 `previous-window' traverses the same cycle, in the reverse order.")
867 (window, minibuf, all_frames) */
869 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
871 (window
, minibuf
, all_frames
)
872 register Lisp_Object window
, minibuf
, all_frames
;
874 register Lisp_Object tem
;
875 Lisp_Object start_window
;
878 window
= selected_window
;
880 CHECK_LIVE_WINDOW (window
, 0);
882 start_window
= window
;
884 /* minibuf == nil may or may not include minibuffers.
885 Decide if it does. */
887 minibuf
= (minibuf_level
? Qt
: Qlambda
);
890 /* all_frames == nil doesn't specify which frames to include. */
891 if (NILP (all_frames
))
892 all_frames
= (EQ (minibuf
, Qt
)
893 ? (FRAME_MINIBUF_WINDOW
896 (XWINDOW (window
)))))
898 else if (EQ (all_frames
, Qvisible
))
900 else if (XFASTINT (all_frames
) == 0)
902 else if (! EQ (all_frames
, Qt
))
904 /* Now all_frames is t meaning search all frames,
905 nil meaning search just current frame,
906 visible meaning search just visible frames,
907 0 meaning search visible and iconified frames,
908 or a window, meaning search the frame that window belongs to. */
911 /* Do this loop at least once, to get the next window, and perhaps
912 again, if we hit the minibuffer and that is not acceptable. */
915 /* Find a window that actually has a next one. This loop
916 climbs up the tree. */
917 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
918 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
922 /* We've reached the end of this frame.
923 Which other frames are acceptable? */
924 tem
= WINDOW_FRAME (XWINDOW (window
));
926 if (! NILP (all_frames
))
931 tem
= next_frame (tem
, all_frames
);
932 /* In the case where the minibuffer is active,
933 and we include its frame as well as the selected one,
934 next_frame may get stuck in that frame.
935 If that happens, go back to the selected frame
936 so we can complete the cycle. */
938 XSET (tem
, Lisp_Frame
, selected_frame
);
941 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
948 /* If we're in a combination window, find its first child and
949 recurse on that. Otherwise, we've found the window we want. */
952 if (!NILP (XWINDOW (window
)->hchild
))
953 window
= XWINDOW (window
)->hchild
;
954 else if (!NILP (XWINDOW (window
)->vchild
))
955 window
= XWINDOW (window
)->vchild
;
959 /* Which windows are acceptible?
960 Exit the loop and accept this window if
961 this isn't a minibuffer window, or
962 we're accepting minibuffer windows, or
963 we've come all the way around and we're back at the original window. */
964 while (MINI_WINDOW_P (XWINDOW (window
))
965 && ! EQ (minibuf
, Qt
)
966 && ! EQ (window
, start_window
));
971 /* This comment supplies the doc string for `previous-window',
972 for make-docfile to see. We cannot put this in the real DEFUN
973 due to limits in the Unix cpp.
975 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
976 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
977 If omitted, WINDOW defaults to the selected window.\n\
979 Optional second arg MINIBUF t means count the minibuffer window even\n\
980 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
981 it is active. MINIBUF neither t nor nil means not to count the\n\
982 minibuffer even if it is active.\n\
984 Several frames may share a single minibuffer; if the minibuffer\n\
985 counts, all windows on all frames that share that minibuffer count\n\
986 too. Therefore, `previous-window' can be used to iterate through\n\
987 the set of windows even when the minibuffer is on another frame. If\n\
988 the minibuffer does not count, only windows from WINDOW's frame count\n\
990 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
991 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
992 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
993 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
994 Anything else means restrict to WINDOW's frame.\n\
996 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
997 `previous-window' to iterate through the entire cycle of acceptable\n\
998 windows, eventually ending up back at the window you started with.\n\
999 `next-window' traverses the same cycle, in the reverse order.")
1000 (window, minibuf, all_frames) */
1003 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1005 (window
, minibuf
, all_frames
)
1006 register Lisp_Object window
, minibuf
, all_frames
;
1008 register Lisp_Object tem
;
1009 Lisp_Object start_window
;
1012 window
= selected_window
;
1014 CHECK_LIVE_WINDOW (window
, 0);
1016 start_window
= window
;
1018 /* minibuf == nil may or may not include minibuffers.
1019 Decide if it does. */
1021 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1024 /* all_frames == nil doesn't specify which frames to include.
1025 Decide which frames it includes. */
1026 if (NILP (all_frames
))
1027 all_frames
= (EQ (minibuf
, Qt
)
1028 ? (FRAME_MINIBUF_WINDOW
1031 (XWINDOW (window
)))))
1033 else if (EQ (all_frames
, Qvisible
))
1035 else if (XFASTINT (all_frames
) == 0)
1037 else if (! EQ (all_frames
, Qt
))
1039 /* Now all_frames is t meaning search all frames,
1040 nil meaning search just current frame,
1041 visible meaning search just visible frames,
1042 0 meaning search visible and iconified frames,
1043 or a window, meaning search the frame that window belongs to. */
1046 /* Do this loop at least once, to get the previous window, and perhaps
1047 again, if we hit the minibuffer and that is not acceptable. */
1050 /* Find a window that actually has a previous one. This loop
1051 climbs up the tree. */
1052 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1053 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1057 /* We have found the top window on the frame.
1058 Which frames are acceptable? */
1059 tem
= WINDOW_FRAME (XWINDOW (window
));
1061 if (! NILP (all_frames
))
1062 /* It's actually important that we use prev_frame here,
1063 rather than next_frame. All the windows acceptable
1064 according to the given parameters should form a ring;
1065 Fnext_window and Fprevious_window should go back and
1066 forth around the ring. If we use next_frame here,
1067 then Fnext_window and Fprevious_window take different
1068 paths through the set of acceptable windows.
1069 window_loop assumes that these `ring' requirement are
1075 tem
= prev_frame (tem
, all_frames
);
1076 /* In the case where the minibuffer is active,
1077 and we include its frame as well as the selected one,
1078 next_frame may get stuck in that frame.
1079 If that happens, go back to the selected frame
1080 so we can complete the cycle. */
1082 XSET (tem
, Lisp_Frame
, selected_frame
);
1085 /* If this frame has a minibuffer, find that window first,
1086 because it is conceptually the last window in that frame. */
1087 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1088 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1090 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1096 /* If we're in a combination window, find its last child and
1097 recurse on that. Otherwise, we've found the window we want. */
1100 if (!NILP (XWINDOW (window
)->hchild
))
1101 window
= XWINDOW (window
)->hchild
;
1102 else if (!NILP (XWINDOW (window
)->vchild
))
1103 window
= XWINDOW (window
)->vchild
;
1105 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1109 /* Which windows are acceptable?
1110 Exit the loop and accept this window if
1111 this isn't a minibuffer window, or
1112 we're accepting minibuffer windows, or
1113 we've come all the way around and we're back at the original window. */
1114 while (MINI_WINDOW_P (XWINDOW (window
))
1115 && !EQ (minibuf
, Qt
)
1116 && !EQ (window
, start_window
));
1121 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1122 "Select the ARG'th different window on this frame.\n\
1123 All windows on current frame are arranged in a cyclic order.\n\
1124 This command selects the window ARG steps away in that order.\n\
1125 A negative ARG moves in the opposite order. If the optional second\n\
1126 argument ALL_FRAMES is non-nil, cycle through all frames.")
1128 register Lisp_Object n
, all_frames
;
1131 register Lisp_Object w
;
1133 CHECK_NUMBER (n
, 0);
1134 w
= selected_window
;
1139 w
= Fnext_window (w
, Qnil
, all_frames
);
1144 w
= Fprevious_window (w
, Qnil
, all_frames
);
1151 /* Look at all windows, performing an operation specified by TYPE
1153 If FRAMES is Qt, look at all frames;
1154 Qnil, look at just the selected frame;
1155 Qvisible, look at visible frames;
1156 a frame, just look at windows on that frame.
1157 If MINI is non-zero, perform the operation on minibuffer windows too.
1163 GET_BUFFER_WINDOW
, /* Arg is buffer */
1164 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1165 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1166 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1168 UNSHOW_BUFFER
/* Arg is buffer */
1172 window_loop (type
, obj
, mini
, frames
)
1173 enum window_loop type
;
1174 register Lisp_Object obj
, frames
;
1177 register Lisp_Object w
;
1178 register Lisp_Object best_window
;
1179 register Lisp_Object next_window
;
1180 register Lisp_Object last_window
;
1182 Lisp_Object frame_arg
;
1186 /* If we're only looping through windows on a particular frame,
1187 frame points to that frame. If we're looping through windows
1188 on all frames, frame is 0. */
1189 if (FRAMEP (frames
))
1190 frame
= XFRAME (frames
);
1191 else if (NILP (frames
))
1192 frame
= selected_frame
;
1196 frame_arg
= Qlambda
;
1197 else if (XFASTINT (frames
) == 0)
1199 else if (EQ (frames
, Qvisible
))
1205 /* frame_arg is Qlambda to stick to one frame,
1206 Qvisible to consider all visible frames,
1209 /* Pick a window to start with. */
1210 if (XTYPE (obj
) == Lisp_Window
)
1213 w
= FRAME_SELECTED_WINDOW (frame
);
1215 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1217 /* Figure out the last window we're going to mess with. Since
1218 Fnext_window, given the same options, is guaranteed to go in a
1219 ring, we can just use Fprevious_window to find the last one.
1221 We can't just wait until we hit the first window again, because
1222 it might be deleted. */
1224 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1229 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1231 /* Pick the next window now, since some operations will delete
1232 the current window. */
1233 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1235 /* Note that we do not pay attention here to whether
1236 the frame is visible, since Fnext_window skips non-visible frames
1237 if that is desired, under the control of frame_arg. */
1238 if (! MINI_WINDOW_P (XWINDOW (w
))
1239 || (mini
&& minibuf_level
> 0))
1242 case GET_BUFFER_WINDOW
:
1243 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1247 case GET_LRU_WINDOW
:
1248 /* t as arg means consider only full-width windows */
1249 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1250 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1252 /* Ignore dedicated windows and minibuffers. */
1253 if (MINI_WINDOW_P (XWINDOW (w
))
1254 || !NILP (XWINDOW (w
)->dedicated
))
1256 if (NILP (best_window
)
1257 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1258 > XFASTINT (XWINDOW (w
)->use_time
)))
1262 case DELETE_OTHER_WINDOWS
:
1263 if (XWINDOW (w
) != XWINDOW (obj
))
1267 case DELETE_BUFFER_WINDOWS
:
1268 if (EQ (XWINDOW (w
)->buffer
, obj
))
1270 /* If we're deleting the buffer displayed in the only window
1271 on the frame, find a new buffer to display there. */
1272 if (NILP (XWINDOW (w
)->parent
))
1274 Lisp_Object new_buffer
;
1275 new_buffer
= Fother_buffer (obj
, Qnil
);
1276 if (NILP (new_buffer
))
1278 = Fget_buffer_create (build_string ("*scratch*"));
1279 Fset_window_buffer (w
, new_buffer
);
1280 if (EQ (w
, selected_window
))
1281 Fset_buffer (XWINDOW (w
)->buffer
);
1288 case GET_LARGEST_WINDOW
:
1289 /* Ignore dedicated windows and minibuffers. */
1290 if (MINI_WINDOW_P (XWINDOW (w
))
1291 || !NILP (XWINDOW (w
)->dedicated
))
1294 struct window
*best_window_ptr
= XWINDOW (best_window
);
1295 struct window
*w_ptr
= XWINDOW (w
);
1296 if (NILP (best_window
)
1297 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1298 > (XFASTINT (best_window_ptr
->height
)
1299 * XFASTINT (best_window_ptr
->width
))))
1305 if (EQ (XWINDOW (w
)->buffer
, obj
))
1307 /* Find another buffer to show in this window. */
1308 Lisp_Object another_buffer
;
1309 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1310 another_buffer
= Fother_buffer (obj
, Qnil
);
1311 if (NILP (another_buffer
))
1313 = Fget_buffer_create (build_string ("*scratch*"));
1315 /* If this window is dedicated, and in a frame of its own,
1317 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1318 && !NILP (XWINDOW (w
)->dedicated
)
1319 && other_visible_frames (f
))
1320 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1324 /* Otherwise show a different buffer in the window. */
1325 XWINDOW (w
)->dedicated
= Qnil
;
1326 Fset_window_buffer (w
, another_buffer
);
1327 if (EQ (w
, selected_window
))
1328 Fset_buffer (XWINDOW (w
)->buffer
);
1334 if (EQ (w
, last_window
))
1343 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1344 "Return the window least recently selected or used for display.\n\
1345 If optional argument FRAME is `visible', search all visible frames.\n\
1346 If FRAME is 0, search all visible and iconified frames.\n\
1347 If FRAME is t, search all frames.\n\
1348 If FRAME is nil, search only the selected frame.\n\
1349 If FRAME is a frame, search only that frame.")
1353 register Lisp_Object w
;
1354 /* First try for a window that is full-width */
1355 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1356 if (!NILP (w
) && !EQ (w
, selected_window
))
1358 /* If none of them, try the rest */
1359 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1362 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1363 "Return the largest window in area.\n\
1364 If optional argument FRAME is `visible', search all visible frames.\n\
1365 If FRAME is 0, search all visible and iconified frames.\n\
1366 If FRAME is t, search all frames.\n\
1367 If FRAME is nil, search only the selected frame.\n\
1368 If FRAME is a frame, search only that frame.")
1372 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1376 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1377 "Return a window currently displaying BUFFER, or nil if none.\n\
1378 If optional argument FRAME is `visible', search all visible frames.\n\
1379 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1380 If FRAME is t, search all frames.\n\
1381 If FRAME is nil, search only the selected frame.\n\
1382 If FRAME is a frame, search only that frame.")
1384 Lisp_Object buffer
, frame
;
1386 buffer
= Fget_buffer (buffer
);
1387 if (XTYPE (buffer
) == Lisp_Buffer
)
1388 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1393 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1395 "Make WINDOW (or the selected window) fill its frame.\n\
1396 Only the frame WINDOW is on is affected.\n\
1397 This function tries to reduce display jumps\n\
1398 by keeping the text previously visible in WINDOW\n\
1399 in the same place on the frame. Doing this depends on\n\
1400 the value of (window-start WINDOW), so if calling this function\n\
1401 in a program gives strange scrolling, make sure the window-start\n\
1402 value is reasonable when this function is called.")
1411 window
= selected_window
;
1413 CHECK_LIVE_WINDOW (window
, 0);
1415 w
= XWINDOW (window
);
1416 startpos
= marker_position (w
->start
);
1417 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1419 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1421 /* Try to minimize scrolling, by setting the window start to the point
1422 will cause the text at the old window start to be at the same place
1423 on the frame. But don't try to do this if the window start is
1424 outside the visible portion (as might happen when the display is
1425 not current, due to typeahead). */
1426 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1427 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1429 struct position pos
;
1430 struct buffer
*obuf
= current_buffer
;
1432 Fset_buffer (w
->buffer
);
1433 /* This computation used to temporarily move point, but that can
1434 have unwanted side effects due to text properties. */
1435 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1436 XINT (w
->hscroll
), window
);
1437 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1438 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1439 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1442 set_buffer_internal (obuf
);
1447 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1448 1, 2, "bDelete windows on (buffer): ",
1449 "Delete all windows showing BUFFER.\n\
1450 Optional second argument FRAME controls which frames are affected.\n\
1451 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1452 If t, delete only windows showing BUFFER in the selected frame.\n\
1453 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1454 If a frame, delete only windows showing BUFFER in that frame.")
1456 Lisp_Object buffer
, frame
;
1459 /* FRAME uses t and nil to mean the opposite of what window_loop
1461 if (! FRAMEP (frame
))
1462 frame
= NILP (frame
) ? Qt
: Qnil
;
1469 buffer
= Fget_buffer (buffer
);
1470 CHECK_BUFFER (buffer
, 0);
1471 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1476 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1477 Sreplace_buffer_in_windows
,
1478 1, 1, "bReplace buffer in windows: ",
1479 "Replace BUFFER with some other buffer in all windows showing it.")
1485 buffer
= Fget_buffer (buffer
);
1486 CHECK_BUFFER (buffer
, 0);
1487 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1492 /* Set the height of WINDOW and all its inferiors. */
1494 /* The smallest acceptable dimensions for a window. Anything smaller
1495 might crash Emacs. */
1496 #define MIN_SAFE_WINDOW_WIDTH (2)
1497 #define MIN_SAFE_WINDOW_HEIGHT (2)
1499 /* Make sure that window_min_height and window_min_width are
1500 not too small; if they are, set them to safe minima. */
1503 check_min_window_sizes ()
1505 /* Smaller values might permit a crash. */
1506 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1507 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1508 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1509 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1512 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1513 minimum allowable size. */
1515 check_frame_size (frame
, rows
, cols
)
1519 /* For height, we have to see:
1520 whether the frame has a minibuffer,
1521 whether it wants a mode line, and
1522 whether it has a menu bar. */
1524 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1525 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1526 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1527 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1528 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1530 if (*rows
< min_height
)
1532 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1533 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1536 /* Normally the window is deleted if it gets too small.
1537 nodelete nonzero means do not do this.
1538 (The caller should check later and do so if appropriate) */
1540 set_window_height (window
, height
, nodelete
)
1545 register struct window
*w
= XWINDOW (window
);
1546 register struct window
*c
;
1547 int oheight
= XFASTINT (w
->height
);
1548 int top
, pos
, lastbot
, opos
, lastobot
;
1551 check_min_window_sizes ();
1554 && ! NILP (w
->parent
)
1555 && height
< window_min_height
)
1557 Fdelete_window (window
);
1561 XFASTINT (w
->last_modified
) = 0;
1562 windows_or_buffers_changed
++;
1563 XFASTINT (w
->height
) = height
;
1564 if (!NILP (w
->hchild
))
1566 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1568 XWINDOW (child
)->top
= w
->top
;
1569 set_window_height (child
, height
, nodelete
);
1572 else if (!NILP (w
->vchild
))
1574 lastbot
= top
= XFASTINT (w
->top
);
1576 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1578 c
= XWINDOW (child
);
1580 opos
= lastobot
+ XFASTINT (c
->height
);
1582 XFASTINT (c
->top
) = lastbot
;
1584 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1586 /* Avoid confusion: inhibit deletion of child if becomes too small */
1587 set_window_height (child
, pos
+ top
- lastbot
, 1);
1589 /* Now advance child to next window,
1590 and set lastbot if child was not just deleted. */
1591 lastbot
= pos
+ top
;
1594 /* Now delete any children that became too small. */
1596 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1598 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1603 /* Recursively set width of WINDOW and its inferiors. */
1605 set_window_width (window
, width
, nodelete
)
1610 register struct window
*w
= XWINDOW (window
);
1611 register struct window
*c
;
1612 int owidth
= XFASTINT (w
->width
);
1613 int left
, pos
, lastright
, opos
, lastoright
;
1616 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1618 Fdelete_window (window
);
1622 XFASTINT (w
->last_modified
) = 0;
1623 windows_or_buffers_changed
++;
1624 XFASTINT (w
->width
) = width
;
1625 if (!NILP (w
->vchild
))
1627 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1629 XWINDOW (child
)->left
= w
->left
;
1630 set_window_width (child
, width
, nodelete
);
1633 else if (!NILP (w
->hchild
))
1635 lastright
= left
= XFASTINT (w
->left
);
1637 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1639 c
= XWINDOW (child
);
1641 opos
= lastoright
+ XFASTINT (c
->width
);
1643 XFASTINT (c
->left
) = lastright
;
1645 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1647 /* Inhibit deletion for becoming too small */
1648 set_window_width (child
, pos
+ left
- lastright
, 1);
1650 /* Now advance child to next window,
1651 and set lastright if child was not just deleted. */
1652 lastright
= pos
+ left
, lastoright
= opos
;
1654 /* Delete children that became too small */
1656 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1658 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1663 int window_select_count
;
1665 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1666 "Make WINDOW display BUFFER as its contents.\n\
1667 BUFFER can be a buffer or buffer name.")
1669 register Lisp_Object window
, buffer
;
1671 register Lisp_Object tem
;
1672 register struct window
*w
= decode_window (window
);
1674 buffer
= Fget_buffer (buffer
);
1675 CHECK_BUFFER (buffer
, 1);
1677 if (NILP (XBUFFER (buffer
)->name
))
1678 error ("Attempt to display deleted buffer");
1682 error ("Window is deleted");
1683 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1684 is first being set up. */
1686 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1687 error ("Window is dedicated to `%s'",
1688 XSTRING (XBUFFER (tem
)->name
)->data
);
1694 w
->window_end_pos
= 0;
1695 w
->window_end_valid
= Qnil
;
1697 Fset_marker (w
->pointm
,
1698 make_number (BUF_PT (XBUFFER (buffer
))),
1700 set_marker_restricted (w
->start
,
1701 make_number (XBUFFER (buffer
)->last_window_start
),
1703 w
->start_at_line_beg
= Qnil
;
1704 w
->force_start
= Qnil
;
1705 XFASTINT (w
->last_modified
) = 0;
1706 windows_or_buffers_changed
++;
1707 if (EQ (window
, selected_window
))
1708 Fset_buffer (buffer
);
1713 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1714 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1715 The main editor command loop selects the buffer of the selected window\n\
1716 before each command.")
1718 register Lisp_Object window
;
1720 register struct window
*w
;
1721 register struct window
*ow
= XWINDOW (selected_window
);
1723 CHECK_LIVE_WINDOW (window
, 0);
1725 w
= XWINDOW (window
);
1727 if (NILP (w
->buffer
))
1728 error ("Trying to select deleted window or non-leaf window");
1730 XFASTINT (w
->use_time
) = ++window_select_count
;
1731 if (EQ (window
, selected_window
))
1734 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1737 selected_window
= window
;
1739 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1741 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1742 /* Use this rather than Fhandle_switch_frame
1743 so that FRAME_FOCUS_FRAME is moved appropriately as we
1744 move around in the state where a minibuffer in a separate
1746 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1749 selected_frame
->selected_window
= window
;
1752 record_buffer (w
->buffer
);
1753 Fset_buffer (w
->buffer
);
1755 /* Go to the point recorded in the window.
1756 This is important when the buffer is in more
1757 than one window. It also matters when
1758 redisplay_window has altered point after scrolling,
1759 because it makes the change only in the window. */
1761 register int new_point
= marker_position (w
->pointm
);
1762 if (new_point
< BEGV
)
1764 else if (new_point
> ZV
)
1770 windows_or_buffers_changed
++;
1774 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1775 "BDisplay buffer: \nP",
1776 "Make BUFFER appear in some window but don't select it.\n\
1777 BUFFER can be a buffer or a buffer name.\n\
1778 If BUFFER is shown already in some window, just use that one,\n\
1779 unless the window is the selected window and the optional second\n\
1780 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1781 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1782 Returns the window displaying BUFFER.")
1783 (buffer
, not_this_window
)
1784 register Lisp_Object buffer
, not_this_window
;
1786 register Lisp_Object window
, tem
;
1788 buffer
= Fget_buffer (buffer
);
1789 CHECK_BUFFER (buffer
, 0);
1791 if (!NILP (Vdisplay_buffer_function
))
1792 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1794 if (NILP (not_this_window
)
1795 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1796 return selected_window
;
1799 /* If pop_up_frames,
1800 look for a window showing BUFFER on any visible or iconified frame. */
1801 window
= Fget_buffer_window (buffer
, pop_up_frames
? make_number (0) : Qnil
);
1803 window
= Fget_buffer_window (buffer
, Qnil
);
1806 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1809 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1810 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1815 /* Certain buffer names get special handling. */
1816 if (! NILP (Vspecial_display_function
))
1818 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1820 return call1 (Vspecial_display_function
, buffer
);
1822 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1823 if (fast_string_match (XCONS (tem
)->car
, XBUFFER (buffer
)->name
) >= 0)
1824 return call1 (Vspecial_display_function
, buffer
);
1828 /* If there are no frames open that have more than a minibuffer,
1829 we need to create a new frame. */
1830 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1832 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1833 Fset_window_buffer (window
, buffer
);
1836 #endif /* MULTI_FRAME */
1840 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1841 /* If the current frame is a special display frame,
1842 don't try to reuse its windows. */
1843 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
1851 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1852 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1854 /* Don't try to create a window if would get an error */
1855 if (split_height_threshold
< window_min_height
<< 1)
1856 split_height_threshold
= window_min_height
<< 1;
1858 /* Note that both Fget_largest_window and Fget_lru_window
1859 ignore minibuffers and dedicated windows.
1860 This means they can return nil. */
1863 /* If the frame we would try to split cannot be split,
1864 try other frames. */
1865 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
1866 : last_nonminibuf_frame
))
1868 /* Try visible frames first. */
1869 window
= Fget_largest_window (Qvisible
);
1870 /* If that didn't work, try iconified frames. */
1872 window
= Fget_largest_window (make_number (0));
1874 window
= Fget_largest_window (Qt
);
1878 window
= Fget_largest_window (frames
);
1880 /* If we got a tall enough full-width window, split it. */
1882 && window_height (window
) >= split_height_threshold
1883 && (XFASTINT (XWINDOW (window
)->width
)
1884 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1885 window
= Fsplit_window (window
, Qnil
, Qnil
);
1888 window
= Fget_lru_window (frames
);
1889 /* If the LRU window is selected, and big enough, split it. */
1891 && (EQ (window
, selected_window
)
1892 || EQ (XWINDOW (window
)->parent
, Qnil
))
1893 && window_height (window
) >= window_min_height
<< 1)
1894 window
= Fsplit_window (window
, Qnil
, Qnil
);
1896 /* If Fget_lru_window returned nil, try other approaches. */
1897 /* Try visible frames first. */
1899 window
= Fget_largest_window (Qvisible
);
1900 /* If that didn't work, try iconified frames. */
1902 window
= Fget_largest_window (make_number (0));
1903 /* Try invisible frames. */
1905 window
= Fget_largest_window (Qt
);
1906 /* As a last resort, make a new frame. */
1908 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1910 /* As a last resort, use a non minibuffer window. */
1912 window
= Fframe_first_window (Fselected_frame ());
1917 window
= Fget_lru_window (Qnil
);
1919 Fset_window_buffer (window
, buffer
);
1924 temp_output_buffer_show (buf
)
1925 register Lisp_Object buf
;
1927 register struct buffer
*old
= current_buffer
;
1928 register Lisp_Object window
;
1929 register struct window
*w
;
1932 XBUFFER (buf
)->save_modified
= MODIFF
;
1937 set_buffer_internal (old
);
1939 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1940 call1 (Vtemp_buffer_show_function
, buf
);
1943 window
= Fdisplay_buffer (buf
, Qnil
);
1946 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1947 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1948 #endif /* MULTI_FRAME */
1949 Vminibuf_scroll_window
= window
;
1950 w
= XWINDOW (window
);
1951 XFASTINT (w
->hscroll
) = 0;
1952 set_marker_restricted (w
->start
, make_number (1), buf
);
1953 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1958 make_dummy_parent (window
)
1961 register Lisp_Object old
, new;
1962 register struct window
*o
, *p
;
1965 XSETTYPE (old
, Lisp_Vector
);
1966 new = Fcopy_sequence (old
);
1967 XSETTYPE (new, Lisp_Window
);
1971 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1973 /* Put new into window structure in place of window */
1974 replace_window (window
, new);
1987 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1988 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1989 WINDOW defaults to selected one and SIZE to half its size.\n\
1990 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1991 and put SIZE columns in the first of the pair.")
1992 (window
, chsize
, horflag
)
1993 Lisp_Object window
, chsize
, horflag
;
1995 register Lisp_Object
new;
1996 register struct window
*o
, *p
;
2000 window
= selected_window
;
2002 CHECK_LIVE_WINDOW (window
, 0);
2004 o
= XWINDOW (window
);
2008 if (!NILP (horflag
))
2009 /* Round odd size up, since this is for the left-hand window,
2010 and it will lose a column for the separators. */
2011 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
2013 size
= XFASTINT (o
->height
) >> 1;
2017 CHECK_NUMBER (chsize
, 1);
2018 size
= XINT (chsize
);
2021 if (MINI_WINDOW_P (o
))
2022 error ("Attempt to split minibuffer window");
2023 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
2024 error ("Attempt to split unsplittable frame");
2026 check_min_window_sizes ();
2030 if (size
< window_min_height
2031 || size
+ window_min_height
> XFASTINT (o
->height
))
2032 args_out_of_range_3 (window
, chsize
, horflag
);
2033 if (NILP (o
->parent
)
2034 || NILP (XWINDOW (o
->parent
)->vchild
))
2036 make_dummy_parent (window
);
2038 XWINDOW (new)->vchild
= window
;
2043 if (size
< window_min_width
2044 || size
+ window_min_width
> XFASTINT (o
->width
))
2045 args_out_of_range_3 (window
, chsize
, horflag
);
2046 if (NILP (o
->parent
)
2047 || NILP (XWINDOW (o
->parent
)->hchild
))
2049 make_dummy_parent (window
);
2051 XWINDOW (new)->hchild
= window
;
2055 /* Now we know that window's parent is a vertical combination
2056 if we are dividing vertically, or a horizontal combination
2057 if we are making side-by-side windows */
2059 windows_or_buffers_changed
++;
2060 new = make_window ();
2063 p
->frame
= o
->frame
;
2065 if (!NILP (p
->next
))
2066 XWINDOW (p
->next
)->prev
= new;
2069 p
->parent
= o
->parent
;
2072 Fset_window_buffer (new, o
->buffer
);
2074 /* Apportion the available frame space among the two new windows */
2076 if (!NILP (horflag
))
2078 p
->height
= o
->height
;
2080 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
2081 XFASTINT (o
->width
) = size
;
2082 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
2087 p
->width
= o
->width
;
2088 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
2089 XFASTINT (o
->height
) = size
;
2090 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
2096 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2097 "Make current window ARG lines bigger.\n\
2098 From program, optional second arg non-nil means grow sideways ARG columns.")
2100 register Lisp_Object n
, side
;
2102 CHECK_NUMBER (n
, 0);
2103 change_window_height (XINT (n
), !NILP (side
));
2107 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2108 "Make current window ARG lines smaller.\n\
2109 From program, optional second arg non-nil means shrink sideways ARG columns.")
2111 register Lisp_Object n
, side
;
2113 CHECK_NUMBER (n
, 0);
2114 change_window_height (-XINT (n
), !NILP (side
));
2119 window_height (window
)
2122 register struct window
*p
= XWINDOW (window
);
2123 return XFASTINT (p
->height
);
2127 window_width (window
)
2130 register struct window
*p
= XWINDOW (window
);
2131 return XFASTINT (p
->width
);
2134 #define MINSIZE(w) \
2136 ? window_min_width \
2137 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2140 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2142 #define CURSIZE(w) \
2143 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2145 /* Unlike set_window_height, this function
2146 also changes the heights of the siblings so as to
2147 keep everything consistent. */
2149 change_window_height (delta
, widthflag
)
2153 register Lisp_Object parent
;
2155 register struct window
*p
;
2157 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2158 register int (*setsizefun
) () = (widthflag
2160 : set_window_height
);
2162 check_min_window_sizes ();
2164 window
= selected_window
;
2167 p
= XWINDOW (window
);
2172 error ("No other window to side of this one");
2175 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2176 : !NILP (XWINDOW (parent
)->vchild
))
2181 sizep
= &CURSIZE (window
);
2184 register int maxdelta
;
2186 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2187 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2188 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2189 /* This is a frame with only one window, a minibuffer-only
2190 or a minibufferless frame. */
2193 if (delta
> maxdelta
)
2194 /* This case traps trying to make the minibuffer
2195 the full frame, or make the only window aside from the
2196 minibuffer the full frame. */
2200 if (*sizep
+ delta
< MINSIZE (window
))
2202 Fdelete_window (window
);
2210 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2212 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2213 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2214 CURBEG (p
->next
) += delta
;
2215 /* This does not change size of p->next,
2216 but it propagates the new top edge to its children */
2217 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2219 else if (!NILP (p
->prev
)
2220 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2222 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2223 CURBEG (window
) -= delta
;
2224 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2228 register int delta1
;
2229 register int opht
= (*sizefun
) (parent
);
2231 /* If trying to grow this window to or beyond size of the parent,
2232 make delta1 so big that, on shrinking back down,
2233 all the siblings end up with less than one line and are deleted. */
2234 if (opht
<= *sizep
+ delta
)
2235 delta1
= opht
* opht
* 2;
2236 /* Otherwise, make delta1 just right so that if we add delta1
2237 lines to this window and to the parent, and then shrink
2238 the parent back to its original size, the new proportional
2239 size of this window will increase by delta. */
2241 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2243 /* Add delta1 lines or columns to this window, and to the parent,
2244 keeping things consistent while not affecting siblings. */
2245 CURSIZE (parent
) = opht
+ delta1
;
2246 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2248 /* Squeeze out delta1 lines or columns from our parent,
2249 shriking this window and siblings proportionately.
2250 This brings parent back to correct size.
2251 Delta1 was calculated so this makes this window the desired size,
2252 taking it all out of the siblings. */
2253 (*setsizefun
) (parent
, opht
, 0);
2256 XFASTINT (p
->last_modified
) = 0;
2263 /* Return number of lines of text (not counting mode line) in W. */
2266 window_internal_height (w
)
2269 int ht
= XFASTINT (w
->height
);
2271 if (MINI_WINDOW_P (w
))
2274 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2275 || !NILP (w
->next
) || !NILP (w
->prev
)
2276 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2283 /* Return the number of columns in W.
2284 Don't count columns occupied by scroll bars or the vertical bar
2285 separating W from the sibling to its right. */
2287 window_internal_width (w
)
2290 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2291 int left
= XINT (w
->left
);
2292 int width
= XINT (w
->width
);
2294 /* If this window is flush against the right edge of the frame, its
2295 internal width is its full width. */
2296 if (left
+ width
>= FRAME_WIDTH (f
))
2299 /* If we are not flush right, then our rightmost columns are
2300 occupied by some sort of separator. */
2302 /* Scroll bars occupy a few columns. */
2303 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2304 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2306 /* The column of `|' characters separating side-by-side windows
2307 occupies one column only. */
2312 /* Scroll contents of window WINDOW up N lines. */
2315 window_scroll (window
, n
, noerror
)
2320 register struct window
*w
= XWINDOW (window
);
2321 register int opoint
= PT
;
2323 register int ht
= window_internal_height (w
);
2324 register Lisp_Object tem
;
2326 Lisp_Object bolp
, nmoved
;
2328 XFASTINT (tem
) = PT
;
2329 tem
= Fpos_visible_in_window_p (tem
, window
);
2333 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2334 XFASTINT (tem
) = PT
;
2335 Fset_marker (w
->start
, tem
, w
->buffer
);
2336 w
->force_start
= Qt
;
2339 SET_PT (marker_position (w
->start
));
2340 lose
= n
< 0 && PT
== BEGV
;
2341 Fvertical_motion (make_number (n
), window
);
2351 Fsignal (Qbeginning_of_buffer
, Qnil
);
2356 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2357 w
->start_at_line_beg
= bolp
;
2358 w
->update_mode_line
= Qt
;
2359 XFASTINT (w
->last_modified
) = 0;
2365 tem
= Fvertical_motion (make_number (ht
), window
);
2366 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2369 Fvertical_motion (make_number (-1), window
);
2377 Fsignal (Qend_of_buffer
, Qnil
);
2381 /* This is the guts of Fscroll_up and Fscroll_down. */
2384 scroll_command (n
, direction
)
2385 register Lisp_Object n
;
2388 register int defalt
;
2389 int count
= specpdl_ptr
- specpdl
;
2391 /* If selected window's buffer isn't current, make it current for the moment.
2392 But don't screw up if window_scroll gets an error. */
2393 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2395 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2396 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2399 defalt
= (window_internal_height (XWINDOW (selected_window
))
2400 - next_screen_context_lines
);
2401 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2404 window_scroll (selected_window
, defalt
, 0);
2405 else if (EQ (n
, Qminus
))
2406 window_scroll (selected_window
, - defalt
, 0);
2409 n
= Fprefix_numeric_value (n
);
2410 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2413 unbind_to (count
, Qnil
);
2416 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2417 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2418 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2419 Negative ARG means scroll downward.\n\
2420 When calling from a program, supply a number as argument or nil.")
2424 scroll_command (n
, 1);
2428 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2429 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2430 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2431 Negative ARG means scroll upward.\n\
2432 When calling from a program, supply a number as argument or nil.")
2436 scroll_command (n
, -1);
2440 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2441 "Return the other window for \"other window scroll\" commands.\n\
2442 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2443 specifies the window.\n\
2444 If `other-window-scroll-buffer' is non-nil, a window\n\
2445 showing that buffer is used.")
2450 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2451 && !NILP (Vminibuf_scroll_window
))
2452 window
= Vminibuf_scroll_window
;
2453 /* If buffer is specified, scroll that buffer. */
2454 else if (!NILP (Vother_window_scroll_buffer
))
2456 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2458 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2462 /* Nothing specified; look for a neighboring window on the same
2464 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2466 if (EQ (window
, selected_window
))
2467 /* That didn't get us anywhere; look for a window on another
2470 window
= Fnext_window (window
, Qnil
, Qt
);
2471 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2472 && ! EQ (window
, selected_window
));
2475 CHECK_LIVE_WINDOW (window
, 0);
2477 if (EQ (window
, selected_window
))
2478 error ("There is no other window");
2483 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2484 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2485 The next window is the one below the current one; or the one at the top\n\
2486 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2487 When calling from a program, supply a number as argument or nil.\n\
2489 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2490 specifies the window to scroll.\n\
2491 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2492 showing that buffer, popping the buffer up if necessary.")
2494 register Lisp_Object n
;
2496 register Lisp_Object window
;
2498 register struct window
*w
;
2499 register int count
= specpdl_ptr
- specpdl
;
2501 window
= Fother_window_for_scrolling ();
2503 w
= XWINDOW (window
);
2504 ht
= window_internal_height (w
);
2506 /* Don't screw up if window_scroll gets an error. */
2507 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2509 Fset_buffer (w
->buffer
);
2510 SET_PT (marker_position (w
->pointm
));
2513 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2514 else if (EQ (n
, Qminus
))
2515 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2518 if (XTYPE (n
) == Lisp_Cons
)
2520 CHECK_NUMBER (n
, 0);
2521 window_scroll (window
, XINT (n
), 1);
2524 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2525 unbind_to (count
, Qnil
);
2530 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2531 "Scroll selected window display ARG columns left.\n\
2532 Default for ARG is window width minus 2.")
2534 register Lisp_Object arg
;
2538 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2540 arg
= Fprefix_numeric_value (arg
);
2543 Fset_window_hscroll (selected_window
,
2544 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2548 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2549 "Scroll selected window display ARG columns right.\n\
2550 Default for ARG is window width minus 2.")
2552 register Lisp_Object arg
;
2555 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2557 arg
= Fprefix_numeric_value (arg
);
2560 Fset_window_hscroll (selected_window
,
2561 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2565 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2566 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2567 The desired position of point is always relative to the current window.\n\
2568 Just C-u as prefix means put point in the center of the window.\n\
2569 No arg (i.e., it is nil) erases the entire frame and then\n\
2570 redraws with point in the center of the current window.")
2572 register Lisp_Object n
;
2574 register struct window
*w
= XWINDOW (selected_window
);
2575 register int ht
= window_internal_height (w
);
2576 register int opoint
= PT
;
2581 extern int frame_garbaged
;
2583 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2584 XFASTINT (n
) = ht
/ 2;
2586 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2588 XFASTINT (n
) = ht
/ 2;
2592 n
= Fprefix_numeric_value (n
);
2593 CHECK_NUMBER (n
, 0);
2597 XSETINT (n
, XINT (n
) + ht
);
2599 XSETINT (n
, - XINT (n
));
2601 XSET (window
, Lisp_Window
, w
);
2602 Fvertical_motion (n
, window
);
2603 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2604 w
->start_at_line_beg
= Fbolp ();
2607 w
->force_start
= Qt
;
2612 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2614 "Position point relative to window.\n\
2615 With no argument, position point at center of window.\n\
2616 An argument specifies frame line; zero means top of window,\n\
2617 negative means relative to bottom of window.")
2619 register Lisp_Object arg
;
2621 register struct window
*w
= XWINDOW (selected_window
);
2622 register int height
= window_internal_height (w
);
2627 XFASTINT (arg
) = height
/ 2;
2630 arg
= Fprefix_numeric_value (arg
);
2632 XSETINT (arg
, XINT (arg
) + height
);
2635 start
= marker_position (w
->start
);
2636 XSET (window
, Lisp_Window
, w
);
2637 if (start
< BEGV
|| start
> ZV
)
2639 Fvertical_motion (make_number (- (height
/ 2)), window
);
2640 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2641 w
->start_at_line_beg
= Fbolp ();
2642 w
->force_start
= Qt
;
2647 return Fvertical_motion (arg
, window
);
2650 struct save_window_data
2652 int size_from_Lisp_Vector_struct
;
2653 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2654 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2655 Lisp_Object selected_frame
;
2656 Lisp_Object current_window
;
2657 Lisp_Object current_buffer
;
2658 Lisp_Object minibuf_scroll_window
;
2659 Lisp_Object root_window
;
2660 Lisp_Object focus_frame
;
2661 /* A vector, interpreted as a struct saved_window */
2662 Lisp_Object saved_windows
;
2665 /* Arg to Fmake_vector */
2666 #define SAVE_WINDOW_DATA_SIZE \
2667 ((sizeof (struct save_window_data) \
2668 - (sizeof (struct Lisp_Vector) \
2669 /* Don't count the contents member of the struct Lisp_Vector */ \
2670 - sizeof (Lisp_Object))) \
2671 / sizeof (Lisp_Object))
2673 /* This is saved as a Lisp_Vector */
2676 /* these first two must agree with struct Lisp_Vector in lisp.h */
2677 int size_from_Lisp_Vector_struct
;
2678 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2681 Lisp_Object buffer
, start
, pointm
, mark
;
2682 Lisp_Object left
, top
, width
, height
, hscroll
;
2683 Lisp_Object parent
, prev
;
2684 Lisp_Object start_at_line_beg
;
2685 Lisp_Object display_table
;
2687 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2689 #define SAVED_WINDOW_N(swv,n) \
2690 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2692 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2693 "T if OBJECT is a window-configration object.")
2697 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2703 DEFUN ("set-window-configuration", Fset_window_configuration
,
2704 Sset_window_configuration
, 1, 1, 0,
2705 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2706 CONFIGURATION must be a value previously returned\n\
2707 by `current-window-configuration' (which see).")
2709 Lisp_Object configuration
;
2711 register struct save_window_data
*data
;
2712 struct Lisp_Vector
*saved_windows
;
2713 Lisp_Object new_current_buffer
;
2717 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2719 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2723 data
= (struct save_window_data
*) XVECTOR (configuration
);
2724 saved_windows
= XVECTOR (data
->saved_windows
);
2726 new_current_buffer
= data
->current_buffer
;
2727 if (NILP (XBUFFER (new_current_buffer
)->name
))
2728 new_current_buffer
= Qnil
;
2730 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2733 /* If f is a dead frame, don't bother rebuilding its window tree.
2734 However, there is other stuff we should still try to do below. */
2735 if (FRAME_LIVE_P (f
))
2737 register struct window
*w
;
2738 register struct saved_window
*p
;
2741 /* If the frame has been resized since this window configuration was
2742 made, we change the frame to the size specified in the
2743 configuration, restore the configuration, and then resize it
2744 back. We keep track of the prevailing height in these variables. */
2745 int previous_frame_height
= FRAME_HEIGHT (f
);
2746 int previous_frame_width
= FRAME_WIDTH (f
);
2747 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2749 if (XFASTINT (data
->frame_height
) != previous_frame_height
2750 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2751 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2752 #ifdef HAVE_X_WINDOWS
2753 if (XFASTINT (data
->frame_menu_bar_lines
)
2754 != previous_frame_menu_bar_lines
)
2755 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2758 windows_or_buffers_changed
++;
2761 Mark all windows now on frame as "deleted".
2762 Restoring the new configuration "undeletes" any that are in it.
2764 Save their current buffers in their height fields, since we may
2765 need it later, if a buffer saved in the configuration is now
2767 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2769 for (k
= 0; k
< saved_windows
->size
; k
++)
2771 p
= SAVED_WINDOW_N (saved_windows
, k
);
2772 w
= XWINDOW (p
->window
);
2775 if (!NILP (p
->parent
))
2776 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2777 XFASTINT (p
->parent
))->window
;
2781 if (!NILP (p
->prev
))
2783 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2784 XFASTINT (p
->prev
))->window
;
2785 XWINDOW (w
->prev
)->next
= p
->window
;
2790 if (!NILP (w
->parent
))
2792 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2794 XWINDOW (w
->parent
)->vchild
= p
->window
;
2795 XWINDOW (w
->parent
)->hchild
= Qnil
;
2799 XWINDOW (w
->parent
)->hchild
= p
->window
;
2800 XWINDOW (w
->parent
)->vchild
= Qnil
;
2805 /* If we squirreled away the buffer in the window's height,
2807 if (XTYPE (w
->height
) == Lisp_Buffer
)
2808 w
->buffer
= w
->height
;
2811 w
->width
= p
->width
;
2812 w
->height
= p
->height
;
2813 w
->hscroll
= p
->hscroll
;
2814 w
->display_table
= p
->display_table
;
2815 XFASTINT (w
->last_modified
) = 0;
2817 /* Reinstall the saved buffer and pointers into it. */
2818 if (NILP (p
->buffer
))
2819 w
->buffer
= p
->buffer
;
2822 if (!NILP (XBUFFER (p
->buffer
)->name
))
2823 /* If saved buffer is alive, install it. */
2825 w
->buffer
= p
->buffer
;
2826 w
->start_at_line_beg
= p
->start_at_line_beg
;
2827 set_marker_restricted (w
->start
,
2828 Fmarker_position (p
->start
),
2830 set_marker_restricted (w
->pointm
,
2831 Fmarker_position (p
->pointm
),
2833 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2834 Fmarker_position (p
->mark
), w
->buffer
);
2836 /* As documented in Fcurrent_window_configuration, don't
2837 save the location of point in the buffer which was current
2838 when the window configuration was recorded. */
2839 if (!EQ (p
->buffer
, new_current_buffer
)
2840 && XBUFFER (p
->buffer
) == current_buffer
)
2841 Fgoto_char (w
->pointm
);
2843 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2844 /* Else unless window has a live buffer, get one. */
2846 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2847 /* This will set the markers to beginning of visible
2849 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2850 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2851 w
->start_at_line_beg
= Qt
;
2854 /* Keeping window's old buffer; make sure the markers
2857 /* Set window markers at start of visible range. */
2858 if (XMARKER (w
->start
)->buffer
== 0)
2859 set_marker_restricted (w
->start
, make_number (0),
2861 if (XMARKER (w
->pointm
)->buffer
== 0)
2862 set_marker_restricted (w
->pointm
,
2864 (BUF_PT (XBUFFER (w
->buffer
)))),
2866 w
->start_at_line_beg
= Qt
;
2871 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2872 Fselect_window (data
->current_window
);
2875 if (NILP (data
->focus_frame
)
2876 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2877 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2878 Fredirect_frame_focus (frame
, data
->focus_frame
);
2881 #if 0 /* I don't understand why this is needed, and it causes problems
2882 when the frame's old selected window has been deleted. */
2884 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2885 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2889 /* Set the screen height to the value it had before this function. */
2890 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2891 || previous_frame_width
!= FRAME_WIDTH (f
))
2892 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2894 #ifdef HAVE_X_WINDOWS
2895 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2896 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2901 /* Fselect_window will have made f the selected frame, so we
2902 reselect the proper frame here. Fhandle_switch_frame will change the
2903 selected window too, but that doesn't make the call to
2904 Fselect_window above totally superfluous; it still sets f's
2906 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2907 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2910 if (!NILP (new_current_buffer
))
2911 Fset_buffer (new_current_buffer
);
2913 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2917 /* Mark all windows now on frame as deleted
2918 by setting their buffers to nil. */
2921 delete_all_subwindows (w
)
2922 register struct window
*w
;
2924 if (!NILP (w
->next
))
2925 delete_all_subwindows (XWINDOW (w
->next
));
2926 if (!NILP (w
->vchild
))
2927 delete_all_subwindows (XWINDOW (w
->vchild
));
2928 if (!NILP (w
->hchild
))
2929 delete_all_subwindows (XWINDOW (w
->hchild
));
2931 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2933 /* We set all three of these fields to nil, to make sure that we can
2934 distinguish this dead window from any live window. Live leaf
2935 windows will have buffer set, and combination windows will have
2936 vchild or hchild set. */
2943 count_windows (window
)
2944 register struct window
*window
;
2946 register int count
= 1;
2947 if (!NILP (window
->next
))
2948 count
+= count_windows (XWINDOW (window
->next
));
2949 if (!NILP (window
->vchild
))
2950 count
+= count_windows (XWINDOW (window
->vchild
));
2951 if (!NILP (window
->hchild
))
2952 count
+= count_windows (XWINDOW (window
->hchild
));
2957 save_window_save (window
, vector
, i
)
2959 struct Lisp_Vector
*vector
;
2962 register struct saved_window
*p
;
2963 register struct window
*w
;
2964 register Lisp_Object tem
;
2966 for (;!NILP (window
); window
= w
->next
)
2968 p
= SAVED_WINDOW_N (vector
, i
);
2969 w
= XWINDOW (window
);
2971 XFASTINT (w
->temslot
) = i
++;
2973 p
->buffer
= w
->buffer
;
2976 p
->width
= w
->width
;
2977 p
->height
= w
->height
;
2978 p
->hscroll
= w
->hscroll
;
2979 p
->display_table
= w
->display_table
;
2980 if (!NILP (w
->buffer
))
2982 /* Save w's value of point in the window configuration.
2983 If w is the selected window, then get the value of point
2984 from the buffer; pointm is garbage in the selected window. */
2985 if (EQ (window
, selected_window
))
2987 p
->pointm
= Fmake_marker ();
2988 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2992 p
->pointm
= Fcopy_marker (w
->pointm
);
2994 p
->start
= Fcopy_marker (w
->start
);
2995 p
->start_at_line_beg
= w
->start_at_line_beg
;
2997 tem
= XBUFFER (w
->buffer
)->mark
;
2998 p
->mark
= Fcopy_marker (tem
);
3005 p
->start_at_line_beg
= Qnil
;
3008 if (NILP (w
->parent
))
3011 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3016 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3018 if (!NILP (w
->vchild
))
3019 i
= save_window_save (w
->vchild
, vector
, i
);
3020 if (!NILP (w
->hchild
))
3021 i
= save_window_save (w
->hchild
, vector
, i
);
3027 DEFUN ("current-window-configuration",
3028 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3029 "Return an object representing the current window configuration of FRAME.\n\
3030 If FRAME is nil or omitted, use the selected frame.\n\
3031 This describes the number of windows, their sizes and current buffers,\n\
3032 and for each displayed buffer, where display starts, and the positions of\n\
3033 point and mark. An exception is made for point in the current buffer:\n\
3034 its value is -not- saved.\n\
3035 This also records the currently selected frame, and FRAME's focus\n\
3036 redirection (see `redirect-frame-focus').")
3040 register Lisp_Object tem
;
3041 register int n_windows
;
3042 register struct save_window_data
*data
;
3050 CHECK_LIVE_FRAME (frame
, 0);
3054 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3055 data
= (struct save_window_data
*)
3056 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
3058 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
3059 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
3060 XFASTINT (data
->frame_menu_bar_lines
) = FRAME_MENU_BAR_LINES (f
);
3062 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
3064 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3065 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
3066 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3067 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3068 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3069 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3070 data
->saved_windows
= tem
;
3071 for (i
= 0; i
< n_windows
; i
++)
3072 XVECTOR (tem
)->contents
[i
]
3073 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3074 save_window_save (FRAME_ROOT_WINDOW (f
),
3076 XSET (tem
, Lisp_Window_Configuration
, data
);
3080 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3082 "Execute body, preserving window sizes and contents.\n\
3083 Restore which buffer appears in which window, where display starts,\n\
3084 and the value of point and mark for each window.\n\
3085 Also restore which buffer is current.\n\
3086 But do not preserve point in the current buffer.\n\
3087 Does not restore the value of point in current buffer.")
3091 register Lisp_Object val
;
3092 register int count
= specpdl_ptr
- specpdl
;
3094 record_unwind_protect (Fset_window_configuration
,
3095 Fcurrent_window_configuration (Qnil
));
3096 val
= Fprogn (args
);
3097 return unbind_to (count
, val
);
3103 selected_frame
= make_terminal_frame ();
3104 minibuf_window
= selected_frame
->minibuffer_window
;
3105 selected_window
= selected_frame
->selected_window
;
3106 last_nonminibuf_frame
= selected_frame
;
3107 #else /* not MULTI_FRAME */
3108 extern Lisp_Object
get_minibuffer ();
3110 minibuf_window
= make_window ();
3111 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3113 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3114 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3115 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3117 /* These values 9 and 10 are arbitrary,
3118 just so that there is "something there."
3119 Correct values are put in in init_xdisp */
3121 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
3122 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
3124 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
3125 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
3126 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
3128 /* Prevent error in Fset_window_buffer. */
3129 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3130 XWINDOW (minibuf_window
)->buffer
= Qt
;
3132 /* Now set them up for real. */
3133 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3134 Fcurrent_buffer ());
3135 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3137 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3138 /* Make sure this window seems more recently used than
3139 a newly-created, never-selected window. Increment
3140 window_select_count so the first selection ever will get
3141 something newer than this. */
3142 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
3143 #endif /* not MULTI_FRAME */
3148 Qwindowp
= intern ("windowp");
3149 staticpro (&Qwindowp
);
3151 Qwindow_live_p
= intern ("window-live-p");
3152 staticpro (&Qwindow_live_p
);
3155 /* Make sure all windows get marked */
3156 staticpro (&minibuf_window
);
3159 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3160 "Non-nil means call as function to display a help buffer.\n\
3161 Used by `with-output-to-temp-buffer'.");
3162 Vtemp_buffer_show_function
= Qnil
;
3164 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3165 "If non-nil, function to call to handle `display-buffer'.\n\
3166 It will receive two args, the buffer and a flag which if non-nil means\n\
3167 that the currently selected window is not acceptable.\n\
3168 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3169 work using this function.");
3170 Vdisplay_buffer_function
= Qnil
;
3172 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3173 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3174 Vminibuf_scroll_window
= Qnil
;
3176 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3177 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3178 Vother_window_scroll_buffer
= Qnil
;
3180 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3181 "*Non-nil means `display-buffer' should make a separate frame.");
3184 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3185 "Function to call to handle automatic new frame creation.\n\
3186 It is called with no arguments and should return a newly created frame.\n\
3188 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3189 where `pop-up-frame-alist' would hold the default frame parameters.");
3190 Vpop_up_frame_function
= Qnil
;
3192 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3193 "*List of buffer names that should have their own special frames.\n\
3194 Displaying a buffer whose name is in this list makes a special frame for it\n\
3195 using `special-display-function'. See also `special-display-regexps'.");
3196 Vspecial_display_buffer_names
= Qnil
;
3198 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3199 "*List of regexps saying which buffers should have their own special frames.\n\
3200 If a buffer name matches one of these regexps, it gets its own frame.\n\
3201 Displaying a buffer whose name is in this list makes a special frame for it\n\
3202 using `special-display-function'. See also `special-display-buffer-names'.");
3203 Vspecial_display_regexps
= Qnil
;
3205 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3206 "Function to call to make a new frame for a special buffer.\n\
3207 It is called with one argument, the buffer,\n\
3208 and should return a window displaying that buffer.\n\
3209 The default value makes a separate frame for the buffer,\n\
3210 using `special-display-alist' to specify the frame parameters.\n\
3212 A buffer is special if its is listed in `special-display-buffer-names'\n\
3213 or matches a regexp in `special-display-regexps'.");
3214 Vspecial_display_function
= Qnil
;
3216 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3217 "*Non-nil means display-buffer should make new windows.");
3220 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3221 "*Number of lines of continuity when scrolling by screenfuls.");
3222 next_screen_context_lines
= 2;
3224 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3225 "*display-buffer would prefer to split the largest window if this large.\n\
3226 If there is only one window, it is split regardless of this value.");
3227 split_height_threshold
= 500;
3229 DEFVAR_INT ("window-min-height", &window_min_height
,
3230 "*Delete any window less than this tall (including its mode line).");
3231 window_min_height
= 4;
3233 DEFVAR_INT ("window-min-width", &window_min_width
,
3234 "*Delete any window less than this wide.");
3235 window_min_width
= 10;
3237 defsubr (&Sselected_window
);
3238 defsubr (&Sminibuffer_window
);
3239 defsubr (&Swindow_minibuffer_p
);
3240 defsubr (&Swindowp
);
3241 defsubr (&Swindow_live_p
);
3242 defsubr (&Spos_visible_in_window_p
);
3243 defsubr (&Swindow_buffer
);
3244 defsubr (&Swindow_height
);
3245 defsubr (&Swindow_width
);
3246 defsubr (&Swindow_hscroll
);
3247 defsubr (&Sset_window_hscroll
);
3248 defsubr (&Swindow_edges
);
3249 defsubr (&Scoordinates_in_window_p
);
3250 defsubr (&Swindow_at
);
3251 defsubr (&Swindow_point
);
3252 defsubr (&Swindow_start
);
3253 defsubr (&Swindow_end
);
3254 defsubr (&Sset_window_point
);
3255 defsubr (&Sset_window_start
);
3256 defsubr (&Swindow_dedicated_p
);
3257 defsubr (&Sset_window_dedicated_p
);
3258 defsubr (&Swindow_display_table
);
3259 defsubr (&Sset_window_display_table
);
3260 defsubr (&Snext_window
);
3261 defsubr (&Sprevious_window
);
3262 defsubr (&Sother_window
);
3263 defsubr (&Sget_lru_window
);
3264 defsubr (&Sget_largest_window
);
3265 defsubr (&Sget_buffer_window
);
3266 defsubr (&Sdelete_other_windows
);
3267 defsubr (&Sdelete_windows_on
);
3268 defsubr (&Sreplace_buffer_in_windows
);
3269 defsubr (&Sdelete_window
);
3270 defsubr (&Sset_window_buffer
);
3271 defsubr (&Sselect_window
);
3272 defsubr (&Sdisplay_buffer
);
3273 defsubr (&Ssplit_window
);
3274 defsubr (&Senlarge_window
);
3275 defsubr (&Sshrink_window
);
3276 defsubr (&Sscroll_up
);
3277 defsubr (&Sscroll_down
);
3278 defsubr (&Sscroll_left
);
3279 defsubr (&Sscroll_right
);
3280 defsubr (&Sother_window_for_scrolling
);
3281 defsubr (&Sscroll_other_window
);
3282 defsubr (&Srecenter
);
3283 defsubr (&Smove_to_window_line
);
3284 defsubr (&Swindow_configuration_p
);
3285 defsubr (&Sset_window_configuration
);
3286 defsubr (&Scurrent_window_configuration
);
3287 defsubr (&Ssave_window_excursion
);
3292 initial_define_key (control_x_map
, '1', "delete-other-windows");
3293 initial_define_key (control_x_map
, '2', "split-window");
3294 initial_define_key (control_x_map
, '0', "delete-window");
3295 initial_define_key (control_x_map
, 'o', "other-window");
3296 initial_define_key (control_x_map
, '^', "enlarge-window");
3297 initial_define_key (control_x_map
, '<', "scroll-left");
3298 initial_define_key (control_x_map
, '>', "scroll-right");
3300 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3301 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3302 initial_define_key (meta_map
, 'v', "scroll-down");
3304 initial_define_key (global_map
, Ctl('L'), "recenter");
3305 initial_define_key (meta_map
, 'r', "move-to-window-line");