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 /* If that info is not correct, calculate afresh */
232 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
234 window_internal_width (w
) - 1,
237 return posval
.vpos
< height
? Qt
: Qnil
;
241 static struct window
*
242 decode_window (window
)
243 register Lisp_Object window
;
246 return XWINDOW (selected_window
);
248 CHECK_LIVE_WINDOW (window
, 0);
249 return XWINDOW (window
);
252 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
253 "Return the buffer that WINDOW is displaying.")
257 return decode_window (window
)->buffer
;
260 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
261 "Return the number of lines in WINDOW (including its mode line).")
265 return decode_window (window
)->height
;
268 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
269 "Return the number of display columns in WINDOW.\n\
270 This is the width that is usable columns available for text in WINDOW.\n\
271 If you want to find out how many columns WINDOW takes up,\n\
272 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
276 return make_number (window_internal_width (decode_window (window
)));
279 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
280 "Return the number of columns by which WINDOW is scrolled from left margin.")
284 return decode_window (window
)->hscroll
;
287 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
288 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
289 NCOL should be zero or positive.")
291 register Lisp_Object window
, ncol
;
293 register struct window
*w
;
295 CHECK_NUMBER (ncol
, 1);
296 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
297 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
298 args_out_of_range (ncol
, Qnil
);
299 w
= decode_window (window
);
300 if (XINT (w
->hscroll
) != XINT (ncol
))
301 clip_changed
= 1; /* Prevent redisplay shortcuts */
306 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
307 "Return a list of the edge coordinates of WINDOW.\n\
308 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
309 RIGHT is one more than the rightmost column used by WINDOW,\n\
310 and BOTTOM is one more than the bottommost row used by WINDOW\n\
315 register struct window
*w
= decode_window (window
);
317 return Fcons (w
->left
, Fcons (w
->top
,
318 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
319 Fcons (make_number (XFASTINT (w
->top
)
320 + XFASTINT (w
->height
)),
324 /* Test if the character at column *x, row *y is within window *w.
325 If it is not, return 0;
326 if it is in the window's text area,
327 set *x and *y to its location relative to the upper left corner
330 if it is on the window's modeline, return 2;
331 if it is on the border between the window and its right sibling,
334 coordinates_in_window (w
, x
, y
)
335 register struct window
*w
;
338 register int left
= XINT (w
->left
);
339 register int width
= XINT (w
->width
);
340 register int window_height
= XINT (w
->height
);
341 register int top
= XFASTINT (w
->top
);
343 if ( *x
< left
|| *x
>= left
+ width
344 || *y
< top
|| *y
>= top
+ window_height
)
347 /* Is the character is the mode line? */
348 if (*y
== top
+ window_height
- 1
349 && ! MINI_WINDOW_P (w
))
352 /* Is the character in the right border? */
353 if (*x
== left
+ width
- 1
354 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
362 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
363 Scoordinates_in_window_p
, 2, 2, 0,
364 "Return non-nil if COORDINATES are in WINDOW.\n\
365 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
366 measured in characters from the upper-left corner of the frame.\n\
367 (0 . 0) denotes the character in the upper left corner of the\n\
369 If COORDINATES are in the text portion of WINDOW,\n\
370 the coordinates relative to the window are returned.\n\
371 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
372 If they are on the border between WINDOW and its right sibling,\n\
373 `vertical-line' is returned.")
374 (coordinates
, window
)
375 register Lisp_Object coordinates
, window
;
379 CHECK_LIVE_WINDOW (window
, 0);
380 CHECK_CONS (coordinates
, 1);
381 x
= XINT (Fcar (coordinates
));
382 y
= XINT (Fcdr (coordinates
));
384 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
386 case 0: /* NOT in window at all. */
389 case 1: /* In text part of window. */
392 case 2: /* In mode line of window. */
395 case 3: /* On right border of window. */
396 return Qvertical_line
;
403 /* Find the window containing column x, row y, and return it as a
404 Lisp_Object. If x, y is on the window's modeline, set *part
405 to 1; if it is on the separating line between the window and its
406 right sibling, set it to 2; otherwise set it to 0. If there is no
407 window under x, y return nil and leave *part unmodified. */
409 window_from_coordinates (frame
, x
, y
, part
)
414 register Lisp_Object tem
, first
;
416 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
420 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
428 tem
= Fnext_window (tem
, Qt
, Qlambda
);
430 while (! EQ (tem
, first
));
435 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
436 "Return window containing coordinates X and Y on FRAME.\n\
437 If omitted, FRAME defaults to the currently selected frame.\n\
438 The top left corner of the frame is considered to be row 0,\n\
441 Lisp_Object x
, y
, frame
;
447 XSET (frame
, Lisp_Frame
, selected_frame
);
449 CHECK_LIVE_FRAME (frame
, 2);
454 return window_from_coordinates (XFRAME (frame
),
459 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
460 "Return current value of point in WINDOW.\n\
461 For a nonselected window, this is the value point would have\n\
462 if that window were selected.\n\
464 Note that, when WINDOW is the selected window and its buffer\n\
465 is also currently selected, the value returned is the same as (point).\n\
466 It would be more strictly correct to return the `top-level' value\n\
467 of point, outside of any save-excursion forms.\n\
468 But that is hard to define.")
472 register struct window
*w
= decode_window (window
);
474 if (w
== XWINDOW (selected_window
)
475 && current_buffer
== XBUFFER (w
->buffer
))
477 return Fmarker_position (w
->pointm
);
480 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
481 "Return position at which display currently starts in WINDOW.")
485 return Fmarker_position (decode_window (window
)->start
);
488 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
489 "Return position at which display currently ends in WINDOW.")
494 struct window
*w
= decode_window (window
);
498 CHECK_BUFFER (buf
, 0);
500 XSET (value
, Lisp_Int
,
501 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
506 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
507 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
509 Lisp_Object window
, pos
;
511 register struct window
*w
= decode_window (window
);
513 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
514 if (w
== XWINDOW (selected_window
))
517 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
522 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
523 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
524 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
525 from overriding motion of point in order to display at this exact start.")
526 (window
, pos
, noforce
)
527 Lisp_Object window
, pos
, noforce
;
529 register struct window
*w
= decode_window (window
);
531 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
532 set_marker_restricted (w
->start
, pos
, w
->buffer
);
533 /* this is not right, but much easier than doing what is right. */
534 w
->start_at_line_beg
= Qnil
;
537 w
->update_mode_line
= Qt
;
538 XFASTINT (w
->last_modified
) = 0;
539 if (!EQ (window
, selected_window
))
540 windows_or_buffers_changed
++;
544 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
546 "Return WINDOW's dedicated object, usually t or nil.\n\
547 See also `set-window-dedicated-p'.")
551 return decode_window (window
)->dedicated
;
554 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
555 Sset_window_dedicated_p
, 2, 2, 0,
556 "Control whether WINDOW is dedicated to the buffer it displays.\n\
557 If it is dedicated, Emacs will not automatically change\n\
558 which buffer appears in it.\n\
559 The second argument is the new value for the dedication flag;\n\
562 Lisp_Object window
, arg
;
564 register struct window
*w
= decode_window (window
);
574 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
576 "Return the display-table that WINDOW is using.")
580 return decode_window (window
)->display_table
;
583 /* Get the display table for use currently on window W.
584 This is either W's display table or W's buffer's display table.
585 Ignore the specified tables if they are not valid;
586 if no valid table is specified, return 0. */
589 window_display_table (w
)
593 tem
= w
->display_table
;
594 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
595 return XVECTOR (tem
);
596 tem
= XBUFFER (w
->buffer
)->display_table
;
597 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
598 return XVECTOR (tem
);
599 tem
= Vstandard_display_table
;
600 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
601 return XVECTOR (tem
);
605 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
606 "Set WINDOW's display-table to TABLE.")
608 register Lisp_Object window
, table
;
610 register struct window
*w
;
611 register Lisp_Object z
; /* Return value. */
613 w
= decode_window (window
);
614 w
->display_table
= table
;
618 /* Record info on buffer window w is displaying
619 when it is about to cease to display that buffer. */
622 register struct window
*w
;
627 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
631 if (w
== XWINDOW (selected_window
)
632 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
633 /* Do this except when the selected window's buffer
634 is being removed from some other window. */
636 /* last_window_start records the start position that this buffer
637 had in the last window to be disconnected from it.
638 Now that this statement is unconditional,
639 it is possible for the buffer to be displayed in the
640 selected window, while last_window_start reflects another
641 window which was recently showing the same buffer.
642 Some people might say that might be a good thing. Let's see. */
643 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
645 /* Point in the selected window's buffer
646 is actually stored in that buffer, and the window's pointm isn't used.
647 So don't clobber point in that buffer. */
648 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
649 BUF_PT (XBUFFER (buf
))
650 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
651 marker_position (w
->pointm
),
652 BUF_ZV (XBUFFER (buf
)));
655 /* Put replacement into the window structure in place of old. */
657 replace_window (old
, replacement
)
658 Lisp_Object old
, replacement
;
660 register Lisp_Object tem
;
661 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
663 /* If OLD is its frame's root_window, then replacement is the new
664 root_window for that frame. */
666 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
667 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
672 p
->height
= o
->height
;
674 p
->next
= tem
= o
->next
;
676 XWINDOW (tem
)->prev
= replacement
;
678 p
->prev
= tem
= o
->prev
;
680 XWINDOW (tem
)->next
= replacement
;
682 p
->parent
= tem
= o
->parent
;
685 if (EQ (XWINDOW (tem
)->vchild
, old
))
686 XWINDOW (tem
)->vchild
= replacement
;
687 if (EQ (XWINDOW (tem
)->hchild
, old
))
688 XWINDOW (tem
)->hchild
= replacement
;
691 /*** Here, if replacement is a vertical combination
692 and so is its new parent, we should make replacement's
693 children be children of that parent instead. ***/
696 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
697 "Remove WINDOW from the display. Default is selected window.")
699 register Lisp_Object window
;
701 register Lisp_Object tem
, parent
, sib
;
702 register struct window
*p
;
703 register struct window
*par
;
705 /* Because this function is called by other C code on non-leaf
706 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
707 so we can't decode_window here. */
709 window
= selected_window
;
711 CHECK_WINDOW (window
, 0);
712 p
= XWINDOW (window
);
714 /* It's okay to delete an already-deleted window. */
722 error ("Attempt to delete minibuffer or sole ordinary window");
723 par
= XWINDOW (parent
);
725 windows_or_buffers_changed
++;
727 /* Are we trying to delete any frame's selected window? */
729 Lisp_Object frame
, pwindow
;
731 /* See if the frame's selected window is either WINDOW
732 or any subwindow of it, by finding all that window's parents
733 and comparing each one with WINDOW. */
734 frame
= WINDOW_FRAME (XWINDOW (window
));
735 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
737 while (!NILP (pwindow
))
739 if (EQ (window
, pwindow
))
741 pwindow
= XWINDOW (pwindow
)->parent
;
744 if (EQ (window
, pwindow
))
746 Lisp_Object alternative
;
747 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
749 /* If we're about to delete the selected window on the
750 selected frame, then we should use Fselect_window to select
751 the new window. On the other hand, if we're about to
752 delete the selected window on any other frame, we shouldn't do
753 anything but set the frame's selected_window slot. */
754 if (EQ (window
, selected_window
))
755 Fselect_window (alternative
);
757 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
762 /* tem is null for dummy parent windows
763 (which have inferiors but not any contents themselves) */
767 unchain_marker (p
->pointm
);
768 unchain_marker (p
->start
);
773 XWINDOW (tem
)->prev
= p
->prev
;
777 XWINDOW (tem
)->next
= p
->next
;
779 if (EQ (window
, par
->hchild
))
780 par
->hchild
= p
->next
;
781 if (EQ (window
, par
->vchild
))
782 par
->vchild
= p
->next
;
784 /* Find one of our siblings to give our space to. */
788 /* If p gives its space to its next sibling, that sibling needs
789 to have its top/left side pulled back to where p's is.
790 set_window_{height,width} will re-position the sibling's
793 XWINDOW (sib
)->top
= p
->top
;
794 XWINDOW (sib
)->left
= p
->left
;
797 /* Stretch that sibling. */
798 if (!NILP (par
->vchild
))
799 set_window_height (sib
,
800 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
802 if (!NILP (par
->hchild
))
803 set_window_width (sib
,
804 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
807 /* If parent now has only one child,
808 put the child into the parent's place. */
812 if (NILP (XWINDOW (tem
)->next
))
813 replace_window (parent
, tem
);
815 /* Since we may be deleting combination windows, we must make sure that
816 not only p but all its children have been marked as deleted. */
817 if (! NILP (p
->hchild
))
818 delete_all_subwindows (XWINDOW (p
->hchild
));
819 else if (! NILP (p
->vchild
))
820 delete_all_subwindows (XWINDOW (p
->vchild
));
822 /* Mark this window as deleted. */
823 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
829 extern Lisp_Object
next_frame (), prev_frame ();
831 /* This comment supplies the doc string for `next-window',
832 for make-docfile to see. We cannot put this in the real DEFUN
833 due to limits in the Unix cpp.
835 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
836 "Return next window after WINDOW in canonical ordering of windows.\n\
837 If omitted, WINDOW defaults to the selected window.\n\
839 Optional second arg MINIBUF t means count the minibuffer window even\n\
840 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
841 it is active. MINIBUF neither t nor nil means not to count the\n\
842 minibuffer even if it is active.\n\
844 Several frames may share a single minibuffer; if the minibuffer\n\
845 counts, all windows on all frames that share that minibuffer count\n\
846 too. Therefore, `next-window' can be used to iterate through the\n\
847 set of windows even when the minibuffer is on another frame. If the\n\
848 minibuffer does not count, only windows from WINDOW's frame count.\n\
850 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
851 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
852 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
853 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
854 Anything else means restrict to WINDOW's frame.\n\
856 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
857 `next-window' to iterate through the entire cycle of acceptable\n\
858 windows, eventually ending up back at the window you started with.\n\
859 `previous-window' traverses the same cycle, in the reverse order.")
860 (window, minibuf, all_frames) */
862 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
864 (window
, minibuf
, all_frames
)
865 register Lisp_Object window
, minibuf
, all_frames
;
867 register Lisp_Object tem
;
868 Lisp_Object start_window
;
871 window
= selected_window
;
873 CHECK_LIVE_WINDOW (window
, 0);
875 start_window
= window
;
877 /* minibuf == nil may or may not include minibuffers.
878 Decide if it does. */
880 minibuf
= (minibuf_level
? Qt
: Qlambda
);
883 /* all_frames == nil doesn't specify which frames to include.
884 Decide which frames it includes. */
885 if (NILP (all_frames
))
886 all_frames
= (EQ (minibuf
, Qt
)
887 ? (FRAME_MINIBUF_WINDOW
890 (XWINDOW (window
)))))
892 else if (EQ (all_frames
, Qvisible
))
894 else if (XFASTINT (all_frames
) == 0)
896 else if (! EQ (all_frames
, Qt
))
898 /* Now all_frames is t meaning search all frames,
899 nil meaning search just current frame,
900 visible meaning search just visible frames,
901 0 meaning search visible and iconified frames,
902 or a window, meaning search the frame that window belongs to. */
905 /* Do this loop at least once, to get the next window, and perhaps
906 again, if we hit the minibuffer and that is not acceptable. */
909 /* Find a window that actually has a next one. This loop
910 climbs up the tree. */
911 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
912 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
916 /* We've reached the end of this frame.
917 Which other frames are acceptable? */
918 tem
= WINDOW_FRAME (XWINDOW (window
));
920 if (! NILP (all_frames
))
921 tem
= next_frame (tem
, all_frames
);
923 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
930 /* If we're in a combination window, find its first child and
931 recurse on that. Otherwise, we've found the window we want. */
934 if (!NILP (XWINDOW (window
)->hchild
))
935 window
= XWINDOW (window
)->hchild
;
936 else if (!NILP (XWINDOW (window
)->vchild
))
937 window
= XWINDOW (window
)->vchild
;
941 /* Which windows are acceptible?
942 Exit the loop and accept this window if
943 this isn't a minibuffer window, or
944 we're accepting minibuffer windows, or
945 we've come all the way around and we're back at the original window. */
946 while (MINI_WINDOW_P (XWINDOW (window
))
947 && ! EQ (minibuf
, Qt
)
948 && ! EQ (window
, start_window
));
953 /* This comment supplies the doc string for `previous-window',
954 for make-docfile to see. We cannot put this in the real DEFUN
955 due to limits in the Unix cpp.
957 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
958 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
959 If omitted, WINDOW defaults to the selected window.\n\
961 Optional second arg MINIBUF t means count the minibuffer window even\n\
962 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
963 it is active. MINIBUF neither t nor nil means not to count the\n\
964 minibuffer even if it is active.\n\
966 Several frames may share a single minibuffer; if the minibuffer\n\
967 counts, all windows on all frames that share that minibuffer count\n\
968 too. Therefore, `previous-window' can be used to iterate through\n\
969 the set of windows even when the minibuffer is on another frame. If\n\
970 the minibuffer does not count, only windows from WINDOW's frame count\n\
972 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
973 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
974 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
975 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
976 Anything else means restrict to WINDOW's frame.\n\
978 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
979 `previous-window' to iterate through the entire cycle of acceptable\n\
980 windows, eventually ending up back at the window you started with.\n\
981 `next-window' traverses the same cycle, in the reverse order.")
982 (window, minibuf, all_frames) */
985 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
987 (window
, minibuf
, all_frames
)
988 register Lisp_Object window
, minibuf
, all_frames
;
990 register Lisp_Object tem
;
991 Lisp_Object start_window
;
994 window
= selected_window
;
996 CHECK_LIVE_WINDOW (window
, 0);
998 start_window
= window
;
1000 /* minibuf == nil may or may not include minibuffers.
1001 Decide if it does. */
1003 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1006 /* all_frames == nil doesn't specify which frames to include.
1007 Decide which frames it includes. */
1008 if (NILP (all_frames
))
1009 all_frames
= (EQ (minibuf
, Qt
)
1010 ? (FRAME_MINIBUF_WINDOW
1013 (XWINDOW (window
)))))
1015 else if (EQ (all_frames
, Qvisible
))
1017 else if (XFASTINT (all_frames
) == 0)
1019 else if (! EQ (all_frames
, Qt
))
1021 /* Now all_frames is t meaning search all frames,
1022 nil meaning search just current frame,
1023 visible meaning search just visible frames,
1024 0 meaning search visible and iconified frames,
1025 or a window, meaning search the frame that window belongs to. */
1028 /* Do this loop at least once, to get the previous window, and perhaps
1029 again, if we hit the minibuffer and that is not acceptable. */
1032 /* Find a window that actually has a previous one. This loop
1033 climbs up the tree. */
1034 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1035 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1039 /* We have found the top window on the frame.
1040 Which frames are acceptable? */
1041 tem
= WINDOW_FRAME (XWINDOW (window
));
1043 if (! NILP (all_frames
))
1044 /* It's actually important that we use prev_frame here,
1045 rather than next_frame. All the windows acceptable
1046 according to the given parameters should form a ring;
1047 Fnext_window and Fprevious_window should go back and
1048 forth around the ring. If we use next_frame here,
1049 then Fnext_window and Fprevious_window take different
1050 paths through the set of acceptable windows.
1051 window_loop assumes that these `ring' requirement are
1053 tem
= prev_frame (tem
, all_frames
);
1055 /* If this frame has a minibuffer, find that window first,
1056 because it is conceptually the last window in that frame. */
1057 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1058 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1060 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1066 /* If we're in a combination window, find its last child and
1067 recurse on that. Otherwise, we've found the window we want. */
1070 if (!NILP (XWINDOW (window
)->hchild
))
1071 window
= XWINDOW (window
)->hchild
;
1072 else if (!NILP (XWINDOW (window
)->vchild
))
1073 window
= XWINDOW (window
)->vchild
;
1075 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1079 /* Which windows are acceptable?
1080 Exit the loop and accept this window if
1081 this isn't a minibuffer window, or
1082 we're accepting minibuffer windows, or
1083 we've come all the way around and we're back at the original window. */
1084 while (MINI_WINDOW_P (XWINDOW (window
))
1085 && !EQ (minibuf
, Qt
)
1086 && !EQ (window
, start_window
));
1091 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1092 "Select the ARG'th different window on this frame.\n\
1093 All windows on current frame are arranged in a cyclic order.\n\
1094 This command selects the window ARG steps away in that order.\n\
1095 A negative ARG moves in the opposite order. If the optional second\n\
1096 argument ALL_FRAMES is non-nil, cycle through all frames.")
1098 register Lisp_Object n
, all_frames
;
1101 register Lisp_Object w
;
1103 CHECK_NUMBER (n
, 0);
1104 w
= selected_window
;
1109 w
= Fnext_window (w
, Qnil
, all_frames
);
1114 w
= Fprevious_window (w
, Qnil
, all_frames
);
1121 /* Look at all windows, performing an operation specified by TYPE
1123 If FRAMES is Qt, look at all frames;
1124 Qnil, look at just the selected frame;
1125 Qvisible, look at visible frames;
1126 a frame, just look at windows on that frame.
1127 If MINI is non-zero, perform the operation on minibuffer windows too.
1133 GET_BUFFER_WINDOW
, /* Arg is buffer */
1134 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1135 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1136 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1138 UNSHOW_BUFFER
/* Arg is buffer */
1142 window_loop (type
, obj
, mini
, frames
)
1143 enum window_loop type
;
1144 register Lisp_Object obj
, frames
;
1147 register Lisp_Object w
;
1148 register Lisp_Object best_window
;
1149 register Lisp_Object next_window
;
1150 register Lisp_Object last_window
;
1152 Lisp_Object frame_arg
;
1156 /* If we're only looping through windows on a particular frame,
1157 frame points to that frame. If we're looping through windows
1158 on all frames, frame is 0. */
1159 if (FRAMEP (frames
))
1160 frame
= XFRAME (frames
);
1161 else if (NILP (frames
))
1162 frame
= selected_frame
;
1166 frame_arg
= Qlambda
;
1167 else if (XFASTINT (frames
) == 0)
1169 else if (EQ (frames
, Qvisible
))
1175 /* frame_arg is Qlambda to stick to one frame,
1176 Qvisible to consider all visible frames,
1179 /* Pick a window to start with. */
1180 if (XTYPE (obj
) == Lisp_Window
)
1183 w
= FRAME_SELECTED_WINDOW (frame
);
1185 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1187 /* Figure out the last window we're going to mess with. Since
1188 Fnext_window, given the same options, is guaranteed to go in a
1189 ring, we can just use Fprevious_window to find the last one.
1191 We can't just wait until we hit the first window again, because
1192 it might be deleted. */
1194 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1199 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1201 /* Pick the next window now, since some operations will delete
1202 the current window. */
1203 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1205 /* Note that we do not pay attention here to whether
1206 the frame is visible, since Fnext_window skips non-visible frames
1207 if that is desired, under the control of frame_arg. */
1208 if (! MINI_WINDOW_P (XWINDOW (w
))
1209 || (mini
&& minibuf_level
> 0))
1212 case GET_BUFFER_WINDOW
:
1213 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1217 case GET_LRU_WINDOW
:
1218 /* t as arg means consider only full-width windows */
1219 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1220 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1222 /* Ignore dedicated windows and minibuffers. */
1223 if (MINI_WINDOW_P (XWINDOW (w
))
1224 || !NILP (XWINDOW (w
)->dedicated
))
1226 if (NILP (best_window
)
1227 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1228 > XFASTINT (XWINDOW (w
)->use_time
)))
1232 case DELETE_OTHER_WINDOWS
:
1233 if (XWINDOW (w
) != XWINDOW (obj
))
1237 case DELETE_BUFFER_WINDOWS
:
1238 if (EQ (XWINDOW (w
)->buffer
, obj
))
1240 /* If we're deleting the buffer displayed in the only window
1241 on the frame, find a new buffer to display there. */
1242 if (NILP (XWINDOW (w
)->parent
))
1244 Lisp_Object new_buffer
;
1245 new_buffer
= Fother_buffer (obj
, Qnil
);
1246 if (NILP (new_buffer
))
1248 = Fget_buffer_create (build_string ("*scratch*"));
1249 Fset_window_buffer (w
, new_buffer
);
1250 if (EQ (w
, selected_window
))
1251 Fset_buffer (XWINDOW (w
)->buffer
);
1258 case GET_LARGEST_WINDOW
:
1259 /* Ignore dedicated windows and minibuffers. */
1260 if (MINI_WINDOW_P (XWINDOW (w
))
1261 || !NILP (XWINDOW (w
)->dedicated
))
1264 struct window
*best_window_ptr
= XWINDOW (best_window
);
1265 struct window
*w_ptr
= XWINDOW (w
);
1266 if (NILP (best_window
)
1267 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1268 > (XFASTINT (best_window_ptr
->height
)
1269 * XFASTINT (best_window_ptr
->width
))))
1275 if (EQ (XWINDOW (w
)->buffer
, obj
))
1277 /* Find another buffer to show in this window. */
1278 Lisp_Object another_buffer
;
1279 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1280 another_buffer
= Fother_buffer (obj
, Qnil
);
1281 if (NILP (another_buffer
))
1283 = Fget_buffer_create (build_string ("*scratch*"));
1285 /* If this window is dedicated, and in a frame of its own,
1287 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1288 && !NILP (XWINDOW (w
)->dedicated
)
1289 && other_visible_frames (f
))
1290 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1294 /* Otherwise show a different buffer in the window. */
1295 XWINDOW (w
)->dedicated
= Qnil
;
1296 Fset_window_buffer (w
, another_buffer
);
1297 if (EQ (w
, selected_window
))
1298 Fset_buffer (XWINDOW (w
)->buffer
);
1304 if (EQ (w
, last_window
))
1313 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1314 "Return the window least recently selected or used for display.\n\
1315 If optional argument FRAME is `visible', search all visible frames.\n\
1316 If FRAME is 0, search all visible and iconified frames.\n\
1317 If FRAME is t, search all frames.\n\
1318 If FRAME is nil, search only the selected frame.\n\
1319 If FRAME is a frame, search only that frame.")
1323 register Lisp_Object w
;
1324 /* First try for a window that is full-width */
1325 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1326 if (!NILP (w
) && !EQ (w
, selected_window
))
1328 /* If none of them, try the rest */
1329 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1332 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1333 "Return the largest window in area.\n\
1334 If optional argument FRAME is `visible', search all visible frames.\n\
1335 If FRAME is 0, search all visible and iconified frames.\n\
1336 If FRAME is t, search all frames.\n\
1337 If FRAME is nil, search only the selected frame.\n\
1338 If FRAME is a frame, search only that frame.")
1342 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1346 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1347 "Return a window currently displaying BUFFER, or nil if none.\n\
1348 If optional argument FRAME is `visible', search all visible frames.\n\
1349 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1350 If FRAME is t, search all frames.\n\
1351 If FRAME is nil, search only the selected frame.\n\
1352 If FRAME is a frame, search only that frame.")
1354 Lisp_Object buffer
, frame
;
1356 buffer
= Fget_buffer (buffer
);
1357 if (XTYPE (buffer
) == Lisp_Buffer
)
1358 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1363 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1365 "Make WINDOW (or the selected window) fill its frame.\n\
1366 Only the frame WINDOW is on is affected.\n\
1367 This function tries to reduce display jumps\n\
1368 by keeping the text previously visible in WINDOW\n\
1369 in the same place on the frame. Doing this depends on\n\
1370 the value of (window-start WINDOW), so if calling this function\n\
1371 in a program gives strange scrolling, make sure the window-start\n\
1372 value is reasonable when this function is called.")
1381 window
= selected_window
;
1383 CHECK_LIVE_WINDOW (window
, 0);
1385 w
= XWINDOW (window
);
1386 startpos
= marker_position (w
->start
);
1387 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1389 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1391 /* Try to minimize scrolling, by setting the window start to the point
1392 will cause the text at the old window start to be at the same place
1393 on the frame. But don't try to do this if the window start is
1394 outside the visible portion (as might happen when the display is
1395 not current, due to typeahead). */
1396 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1397 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1399 struct position pos
;
1400 struct buffer
*obuf
= current_buffer
;
1402 Fset_buffer (w
->buffer
);
1403 /* This computation used to temporarily move point, but that can
1404 have unwanted side effects due to text properties. */
1405 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1406 XINT (w
->hscroll
), window
);
1407 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1408 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1409 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1412 set_buffer_internal (obuf
);
1417 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1418 1, 2, "bDelete windows on (buffer): ",
1419 "Delete all windows showing BUFFER.\n\
1420 Optional second argument FRAME controls which frames are affected.\n\
1421 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1422 If t, delete only windows showing BUFFER in the selected frame.\n\
1423 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1424 If a frame, delete only windows showing BUFFER in that frame.")
1426 Lisp_Object buffer
, frame
;
1429 /* FRAME uses t and nil to mean the opposite of what window_loop
1431 if (! FRAMEP (frame
))
1432 frame
= NILP (frame
) ? Qt
: Qnil
;
1439 buffer
= Fget_buffer (buffer
);
1440 CHECK_BUFFER (buffer
, 0);
1441 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1446 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1447 Sreplace_buffer_in_windows
,
1448 1, 1, "bReplace buffer in windows: ",
1449 "Replace BUFFER with some other buffer in all windows showing it.")
1455 buffer
= Fget_buffer (buffer
);
1456 CHECK_BUFFER (buffer
, 0);
1457 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1462 /* Set the height of WINDOW and all its inferiors. */
1464 /* The smallest acceptable dimensions for a window. Anything smaller
1465 might crash Emacs. */
1466 #define MIN_SAFE_WINDOW_WIDTH (2)
1467 #define MIN_SAFE_WINDOW_HEIGHT (2)
1469 /* Make sure that window_min_height and window_min_width are
1470 not too small; if they are, set them to safe minima. */
1473 check_min_window_sizes ()
1475 /* Smaller values might permit a crash. */
1476 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1477 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1478 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1479 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1482 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1483 minimum allowable size. */
1485 check_frame_size (frame
, rows
, cols
)
1489 /* For height, we have to see:
1490 whether the frame has a minibuffer,
1491 whether it wants a mode line, and
1492 whether it has a menu bar. */
1494 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1495 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1496 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1497 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1498 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1500 if (*rows
< min_height
)
1502 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1503 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1506 /* Normally the window is deleted if it gets too small.
1507 nodelete nonzero means do not do this.
1508 (The caller should check later and do so if appropriate) */
1510 set_window_height (window
, height
, nodelete
)
1515 register struct window
*w
= XWINDOW (window
);
1516 register struct window
*c
;
1517 int oheight
= XFASTINT (w
->height
);
1518 int top
, pos
, lastbot
, opos
, lastobot
;
1521 check_min_window_sizes ();
1524 && ! NILP (w
->parent
)
1525 && height
< window_min_height
)
1527 Fdelete_window (window
);
1531 XFASTINT (w
->last_modified
) = 0;
1532 windows_or_buffers_changed
++;
1533 XFASTINT (w
->height
) = height
;
1534 if (!NILP (w
->hchild
))
1536 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1538 XWINDOW (child
)->top
= w
->top
;
1539 set_window_height (child
, height
, nodelete
);
1542 else if (!NILP (w
->vchild
))
1544 lastbot
= top
= XFASTINT (w
->top
);
1546 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1548 c
= XWINDOW (child
);
1550 opos
= lastobot
+ XFASTINT (c
->height
);
1552 XFASTINT (c
->top
) = lastbot
;
1554 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1556 /* Avoid confusion: inhibit deletion of child if becomes too small */
1557 set_window_height (child
, pos
+ top
- lastbot
, 1);
1559 /* Now advance child to next window,
1560 and set lastbot if child was not just deleted. */
1561 lastbot
= pos
+ top
;
1564 /* Now delete any children that became too small. */
1566 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1568 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1573 /* Recursively set width of WINDOW and its inferiors. */
1575 set_window_width (window
, width
, nodelete
)
1580 register struct window
*w
= XWINDOW (window
);
1581 register struct window
*c
;
1582 int owidth
= XFASTINT (w
->width
);
1583 int left
, pos
, lastright
, opos
, lastoright
;
1586 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1588 Fdelete_window (window
);
1592 XFASTINT (w
->last_modified
) = 0;
1593 windows_or_buffers_changed
++;
1594 XFASTINT (w
->width
) = width
;
1595 if (!NILP (w
->vchild
))
1597 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1599 XWINDOW (child
)->left
= w
->left
;
1600 set_window_width (child
, width
, nodelete
);
1603 else if (!NILP (w
->hchild
))
1605 lastright
= left
= XFASTINT (w
->left
);
1607 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1609 c
= XWINDOW (child
);
1611 opos
= lastoright
+ XFASTINT (c
->width
);
1613 XFASTINT (c
->left
) = lastright
;
1615 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1617 /* Inhibit deletion for becoming too small */
1618 set_window_width (child
, pos
+ left
- lastright
, 1);
1620 /* Now advance child to next window,
1621 and set lastright if child was not just deleted. */
1622 lastright
= pos
+ left
, lastoright
= opos
;
1624 /* Delete children that became too small */
1626 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1628 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1633 int window_select_count
;
1635 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1636 "Make WINDOW display BUFFER as its contents.\n\
1637 BUFFER can be a buffer or buffer name.")
1639 register Lisp_Object window
, buffer
;
1641 register Lisp_Object tem
;
1642 register struct window
*w
= decode_window (window
);
1644 buffer
= Fget_buffer (buffer
);
1645 CHECK_BUFFER (buffer
, 1);
1647 if (NILP (XBUFFER (buffer
)->name
))
1648 error ("Attempt to display deleted buffer");
1652 error ("Window is deleted");
1653 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1654 is first being set up. */
1656 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1657 error ("Window is dedicated to `%s'",
1658 XSTRING (XBUFFER (tem
)->name
)->data
);
1664 w
->window_end_pos
= 0;
1665 w
->window_end_valid
= Qnil
;
1667 Fset_marker (w
->pointm
,
1668 make_number (BUF_PT (XBUFFER (buffer
))),
1670 set_marker_restricted (w
->start
,
1671 make_number (XBUFFER (buffer
)->last_window_start
),
1673 w
->start_at_line_beg
= Qnil
;
1674 w
->force_start
= Qnil
;
1675 XFASTINT (w
->last_modified
) = 0;
1676 windows_or_buffers_changed
++;
1677 if (EQ (window
, selected_window
))
1678 Fset_buffer (buffer
);
1683 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1684 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1685 The main editor command loop selects the buffer of the selected window\n\
1686 before each command.")
1688 register Lisp_Object window
;
1690 register struct window
*w
;
1691 register struct window
*ow
= XWINDOW (selected_window
);
1693 CHECK_LIVE_WINDOW (window
, 0);
1695 w
= XWINDOW (window
);
1697 if (NILP (w
->buffer
))
1698 error ("Trying to select deleted window or non-leaf window");
1700 XFASTINT (w
->use_time
) = ++window_select_count
;
1701 if (EQ (window
, selected_window
))
1704 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1707 selected_window
= window
;
1709 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1711 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1712 /* Use this rather than Fhandle_switch_frame
1713 so that FRAME_FOCUS_FRAME is moved appropriately as we
1714 move around in the state where a minibuffer in a separate
1716 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1719 selected_frame
->selected_window
= window
;
1722 record_buffer (w
->buffer
);
1723 Fset_buffer (w
->buffer
);
1725 /* Go to the point recorded in the window.
1726 This is important when the buffer is in more
1727 than one window. It also matters when
1728 redisplay_window has altered point after scrolling,
1729 because it makes the change only in the window. */
1731 register int new_point
= marker_position (w
->pointm
);
1732 if (new_point
< BEGV
)
1734 else if (new_point
> ZV
)
1740 windows_or_buffers_changed
++;
1744 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1745 "BDisplay buffer: \nP",
1746 "Make BUFFER appear in some window but don't select it.\n\
1747 BUFFER can be a buffer or a buffer name.\n\
1748 If BUFFER is shown already in some window, just use that one,\n\
1749 unless the window is the selected window and the optional second\n\
1750 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1751 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1752 Returns the window displaying BUFFER.")
1753 (buffer
, not_this_window
)
1754 register Lisp_Object buffer
, not_this_window
;
1756 register Lisp_Object window
, tem
;
1758 buffer
= Fget_buffer (buffer
);
1759 CHECK_BUFFER (buffer
, 0);
1761 if (!NILP (Vdisplay_buffer_function
))
1762 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1764 if (NILP (not_this_window
)
1765 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1766 return selected_window
;
1769 /* If pop_up_frames,
1770 look for a window showing BUFFER on any visible or iconified frame. */
1771 window
= Fget_buffer_window (buffer
, pop_up_frames
? make_number (0) : Qnil
);
1773 window
= Fget_buffer_window (buffer
, Qnil
);
1776 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1779 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1780 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1785 /* Certain buffer names get special handling. */
1786 if (! NILP (Vspecial_display_function
))
1788 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1790 return call1 (Vspecial_display_function
, buffer
);
1792 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1793 if (fast_string_match (XCONS (tem
)->car
, XBUFFER (buffer
)->name
) >= 0)
1794 return call1 (Vspecial_display_function
, buffer
);
1798 /* If there are no frames open that have more than a minibuffer,
1799 we need to create a new frame. */
1800 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1802 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1803 Fset_window_buffer (window
, buffer
);
1806 #endif /* MULTI_FRAME */
1810 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1811 /* If the current frame is a special display frame,
1812 don't try to reuse its windows. */
1813 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
1821 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1822 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1824 /* Don't try to create a window if would get an error */
1825 if (split_height_threshold
< window_min_height
<< 1)
1826 split_height_threshold
= window_min_height
<< 1;
1828 /* Note that both Fget_largest_window and Fget_lru_window
1829 ignore minibuffers and dedicated windows.
1830 This means they can return nil. */
1832 /* If the frame we would try to split cannot be split,
1833 try other frames. */
1834 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
1835 : last_nonminibuf_frame
))
1837 /* Try visible frames first. */
1838 window
= Fget_largest_window (Qvisible
);
1839 /* If that didn't work, try iconified frames. */
1841 window
= Fget_largest_window (make_number (0));
1843 window
= Fget_largest_window (Qt
);
1846 window
= Fget_largest_window (frames
);
1848 /* If we got a tall enough full-width window, split it. */
1850 && window_height (window
) >= split_height_threshold
1851 && (XFASTINT (XWINDOW (window
)->width
)
1852 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1853 window
= Fsplit_window (window
, Qnil
, Qnil
);
1856 window
= Fget_lru_window (frames
);
1857 /* If the LRU window is selected, and big enough, split it. */
1859 && (EQ (window
, selected_window
)
1860 || EQ (XWINDOW (window
)->parent
, Qnil
))
1861 && window_height (window
) >= window_min_height
<< 1)
1862 window
= Fsplit_window (window
, Qnil
, Qnil
);
1864 /* If Fget_lru_window returned nil, try other approaches. */
1865 /* Try visible frames first. */
1867 window
= Fget_largest_window (Qvisible
);
1868 /* If that didn't work, try iconified frames. */
1870 window
= Fget_largest_window (make_number (0));
1871 /* Try invisible frames. */
1873 window
= Fget_largest_window (Qt
);
1874 /* As a last resort, make a new frame. */
1876 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1878 /* As a last resort, use a non minibuffer window. */
1880 window
= Fframe_first_window (Fselected_frame ());
1885 window
= Fget_lru_window (Qnil
);
1887 Fset_window_buffer (window
, buffer
);
1892 temp_output_buffer_show (buf
)
1893 register Lisp_Object buf
;
1895 register struct buffer
*old
= current_buffer
;
1896 register Lisp_Object window
;
1897 register struct window
*w
;
1900 XBUFFER (buf
)->save_modified
= MODIFF
;
1905 set_buffer_internal (old
);
1907 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1908 call1 (Vtemp_buffer_show_function
, buf
);
1911 window
= Fdisplay_buffer (buf
, Qnil
);
1914 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1915 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1916 #endif /* MULTI_FRAME */
1917 Vminibuf_scroll_window
= window
;
1918 w
= XWINDOW (window
);
1919 XFASTINT (w
->hscroll
) = 0;
1920 set_marker_restricted (w
->start
, make_number (1), buf
);
1921 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1926 make_dummy_parent (window
)
1929 register Lisp_Object old
, new;
1930 register struct window
*o
, *p
;
1933 XSETTYPE (old
, Lisp_Vector
);
1934 new = Fcopy_sequence (old
);
1935 XSETTYPE (new, Lisp_Window
);
1939 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1941 /* Put new into window structure in place of window */
1942 replace_window (window
, new);
1955 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1956 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1957 WINDOW defaults to selected one and SIZE to half its size.\n\
1958 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1959 and put SIZE columns in the first of the pair.")
1960 (window
, chsize
, horflag
)
1961 Lisp_Object window
, chsize
, horflag
;
1963 register Lisp_Object
new;
1964 register struct window
*o
, *p
;
1968 window
= selected_window
;
1970 CHECK_LIVE_WINDOW (window
, 0);
1972 o
= XWINDOW (window
);
1976 if (!NILP (horflag
))
1977 /* Round odd size up, since this is for the left-hand window,
1978 and it will lose a column for the separators. */
1979 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1981 size
= XFASTINT (o
->height
) >> 1;
1985 CHECK_NUMBER (chsize
, 1);
1986 size
= XINT (chsize
);
1989 if (MINI_WINDOW_P (o
))
1990 error ("Attempt to split minibuffer window");
1991 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1992 error ("Attempt to split unsplittable frame");
1994 check_min_window_sizes ();
1998 if (size
< window_min_height
1999 || size
+ window_min_height
> XFASTINT (o
->height
))
2000 args_out_of_range_3 (window
, chsize
, horflag
);
2001 if (NILP (o
->parent
)
2002 || NILP (XWINDOW (o
->parent
)->vchild
))
2004 make_dummy_parent (window
);
2006 XWINDOW (new)->vchild
= window
;
2011 if (size
< window_min_width
2012 || size
+ window_min_width
> XFASTINT (o
->width
))
2013 args_out_of_range_3 (window
, chsize
, horflag
);
2014 if (NILP (o
->parent
)
2015 || NILP (XWINDOW (o
->parent
)->hchild
))
2017 make_dummy_parent (window
);
2019 XWINDOW (new)->hchild
= window
;
2023 /* Now we know that window's parent is a vertical combination
2024 if we are dividing vertically, or a horizontal combination
2025 if we are making side-by-side windows */
2027 windows_or_buffers_changed
++;
2028 new = make_window ();
2031 p
->frame
= o
->frame
;
2033 if (!NILP (p
->next
))
2034 XWINDOW (p
->next
)->prev
= new;
2037 p
->parent
= o
->parent
;
2040 Fset_window_buffer (new, o
->buffer
);
2042 /* Apportion the available frame space among the two new windows */
2044 if (!NILP (horflag
))
2046 p
->height
= o
->height
;
2048 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
2049 XFASTINT (o
->width
) = size
;
2050 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
2055 p
->width
= o
->width
;
2056 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
2057 XFASTINT (o
->height
) = size
;
2058 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
2064 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2065 "Make current window ARG lines bigger.\n\
2066 From program, optional second arg non-nil means grow sideways ARG columns.")
2068 register Lisp_Object n
, side
;
2070 CHECK_NUMBER (n
, 0);
2071 change_window_height (XINT (n
), !NILP (side
));
2075 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2076 "Make current window ARG lines smaller.\n\
2077 From program, optional second arg non-nil means shrink sideways ARG columns.")
2079 register Lisp_Object n
, side
;
2081 CHECK_NUMBER (n
, 0);
2082 change_window_height (-XINT (n
), !NILP (side
));
2087 window_height (window
)
2090 register struct window
*p
= XWINDOW (window
);
2091 return XFASTINT (p
->height
);
2095 window_width (window
)
2098 register struct window
*p
= XWINDOW (window
);
2099 return XFASTINT (p
->width
);
2102 #define MINSIZE(w) \
2104 ? window_min_width \
2105 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2108 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2110 #define CURSIZE(w) \
2111 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2113 /* Unlike set_window_height, this function
2114 also changes the heights of the siblings so as to
2115 keep everything consistent. */
2117 change_window_height (delta
, widthflag
)
2121 register Lisp_Object parent
;
2123 register struct window
*p
;
2125 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2126 register int (*setsizefun
) () = (widthflag
2128 : set_window_height
);
2130 check_min_window_sizes ();
2132 window
= selected_window
;
2135 p
= XWINDOW (window
);
2140 error ("No other window to side of this one");
2143 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2144 : !NILP (XWINDOW (parent
)->vchild
))
2149 sizep
= &CURSIZE (window
);
2152 register int maxdelta
;
2154 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2155 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2156 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2157 /* This is a frame with only one window, a minibuffer-only
2158 or a minibufferless frame. */
2161 if (delta
> maxdelta
)
2162 /* This case traps trying to make the minibuffer
2163 the full frame, or make the only window aside from the
2164 minibuffer the full frame. */
2168 if (*sizep
+ delta
< MINSIZE (window
))
2170 Fdelete_window (window
);
2178 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2180 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2181 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2182 CURBEG (p
->next
) += delta
;
2183 /* This does not change size of p->next,
2184 but it propagates the new top edge to its children */
2185 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2187 else if (!NILP (p
->prev
)
2188 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2190 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2191 CURBEG (window
) -= delta
;
2192 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2196 register int delta1
;
2197 register int opht
= (*sizefun
) (parent
);
2199 /* If trying to grow this window to or beyond size of the parent,
2200 make delta1 so big that, on shrinking back down,
2201 all the siblings end up with less than one line and are deleted. */
2202 if (opht
<= *sizep
+ delta
)
2203 delta1
= opht
* opht
* 2;
2204 /* Otherwise, make delta1 just right so that if we add delta1
2205 lines to this window and to the parent, and then shrink
2206 the parent back to its original size, the new proportional
2207 size of this window will increase by delta. */
2209 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2211 /* Add delta1 lines or columns to this window, and to the parent,
2212 keeping things consistent while not affecting siblings. */
2213 CURSIZE (parent
) = opht
+ delta1
;
2214 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2216 /* Squeeze out delta1 lines or columns from our parent,
2217 shriking this window and siblings proportionately.
2218 This brings parent back to correct size.
2219 Delta1 was calculated so this makes this window the desired size,
2220 taking it all out of the siblings. */
2221 (*setsizefun
) (parent
, opht
, 0);
2224 XFASTINT (p
->last_modified
) = 0;
2231 /* Return number of lines of text (not counting mode line) in W. */
2234 window_internal_height (w
)
2237 int ht
= XFASTINT (w
->height
);
2239 if (MINI_WINDOW_P (w
))
2242 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2243 || !NILP (w
->next
) || !NILP (w
->prev
)
2244 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2251 /* Return the number of columns in W.
2252 Don't count columns occupied by scroll bars or the vertical bar
2253 separating W from the sibling to its right. */
2255 window_internal_width (w
)
2258 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2259 int left
= XINT (w
->left
);
2260 int width
= XINT (w
->width
);
2262 /* If this window is flush against the right edge of the frame, its
2263 internal width is its full width. */
2264 if (left
+ width
>= FRAME_WIDTH (f
))
2267 /* If we are not flush right, then our rightmost columns are
2268 occupied by some sort of separator. */
2270 /* Scroll bars occupy a few columns. */
2271 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2272 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2274 /* The column of `|' characters separating side-by-side windows
2275 occupies one column only. */
2280 /* Scroll contents of window WINDOW up N lines. */
2283 window_scroll (window
, n
, noerror
)
2288 register struct window
*w
= XWINDOW (window
);
2289 register int opoint
= PT
;
2291 register int ht
= window_internal_height (w
);
2292 register Lisp_Object tem
;
2294 Lisp_Object bolp
, nmoved
;
2296 XFASTINT (tem
) = PT
;
2297 tem
= Fpos_visible_in_window_p (tem
, window
);
2301 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2302 XFASTINT (tem
) = PT
;
2303 Fset_marker (w
->start
, tem
, w
->buffer
);
2304 w
->force_start
= Qt
;
2307 SET_PT (marker_position (w
->start
));
2308 lose
= n
< 0 && PT
== BEGV
;
2309 Fvertical_motion (make_number (n
), window
);
2319 Fsignal (Qbeginning_of_buffer
, Qnil
);
2324 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2325 w
->start_at_line_beg
= bolp
;
2326 w
->update_mode_line
= Qt
;
2327 XFASTINT (w
->last_modified
) = 0;
2333 tem
= Fvertical_motion (make_number (ht
), window
);
2334 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2337 Fvertical_motion (make_number (-1), window
);
2345 Fsignal (Qend_of_buffer
, Qnil
);
2349 /* This is the guts of Fscroll_up and Fscroll_down. */
2352 scroll_command (n
, direction
)
2353 register Lisp_Object n
;
2356 register int defalt
;
2357 int count
= specpdl_ptr
- specpdl
;
2359 /* If selected window's buffer isn't current, make it current for the moment.
2360 But don't screw up if window_scroll gets an error. */
2361 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2363 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2364 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2367 defalt
= (window_internal_height (XWINDOW (selected_window
))
2368 - next_screen_context_lines
);
2369 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2372 window_scroll (selected_window
, defalt
, 0);
2373 else if (EQ (n
, Qminus
))
2374 window_scroll (selected_window
, - defalt
, 0);
2377 n
= Fprefix_numeric_value (n
);
2378 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2381 unbind_to (count
, Qnil
);
2384 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2385 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2386 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2387 Negative ARG means scroll downward.\n\
2388 When calling from a program, supply a number as argument or nil.")
2392 scroll_command (n
, 1);
2396 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2397 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2398 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2399 Negative ARG means scroll upward.\n\
2400 When calling from a program, supply a number as argument or nil.")
2404 scroll_command (n
, -1);
2408 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2409 "Return the other window for \"other window scroll\" commands.\n\
2410 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2411 specifies the window.\n\
2412 If `other-window-scroll-buffer' is non-nil, a window\n\
2413 showing that buffer is used.")
2418 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2419 && !NILP (Vminibuf_scroll_window
))
2420 window
= Vminibuf_scroll_window
;
2421 /* If buffer is specified, scroll that buffer. */
2422 else if (!NILP (Vother_window_scroll_buffer
))
2424 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2426 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2430 /* Nothing specified; look for a neighboring window on the same
2432 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2434 if (EQ (window
, selected_window
))
2435 /* That didn't get us anywhere; look for a window on another
2438 window
= Fnext_window (window
, Qnil
, Qt
);
2439 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2440 && ! EQ (window
, selected_window
));
2443 CHECK_LIVE_WINDOW (window
, 0);
2445 if (EQ (window
, selected_window
))
2446 error ("There is no other window");
2451 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2452 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2453 The next window is the one below the current one; or the one at the top\n\
2454 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2455 When calling from a program, supply a number as argument or nil.\n\
2457 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2458 specifies the window to scroll.\n\
2459 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2460 showing that buffer, popping the buffer up if necessary.")
2462 register Lisp_Object n
;
2464 register Lisp_Object window
;
2466 register struct window
*w
;
2467 register int count
= specpdl_ptr
- specpdl
;
2469 window
= Fother_window_for_scrolling ();
2471 w
= XWINDOW (window
);
2472 ht
= window_internal_height (w
);
2474 /* Don't screw up if window_scroll gets an error. */
2475 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2477 Fset_buffer (w
->buffer
);
2478 SET_PT (marker_position (w
->pointm
));
2481 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2482 else if (EQ (n
, Qminus
))
2483 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2486 if (XTYPE (n
) == Lisp_Cons
)
2488 CHECK_NUMBER (n
, 0);
2489 window_scroll (window
, XINT (n
), 1);
2492 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2493 unbind_to (count
, Qnil
);
2498 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2499 "Scroll selected window display ARG columns left.\n\
2500 Default for ARG is window width minus 2.")
2502 register Lisp_Object arg
;
2506 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2508 arg
= Fprefix_numeric_value (arg
);
2511 Fset_window_hscroll (selected_window
,
2512 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2516 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2517 "Scroll selected window display ARG columns right.\n\
2518 Default for ARG is window width minus 2.")
2520 register Lisp_Object arg
;
2523 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2525 arg
= Fprefix_numeric_value (arg
);
2528 Fset_window_hscroll (selected_window
,
2529 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2533 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2534 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2535 The desired position of point is always relative to the current window.\n\
2536 Just C-u as prefix means put point in the center of the window.\n\
2537 No arg (i.e., it is nil) erases the entire frame and then\n\
2538 redraws with point in the center of the current window.")
2540 register Lisp_Object n
;
2542 register struct window
*w
= XWINDOW (selected_window
);
2543 register int ht
= window_internal_height (w
);
2544 register int opoint
= PT
;
2549 extern int frame_garbaged
;
2551 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2552 XFASTINT (n
) = ht
/ 2;
2554 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2556 XFASTINT (n
) = ht
/ 2;
2560 n
= Fprefix_numeric_value (n
);
2561 CHECK_NUMBER (n
, 0);
2565 XSETINT (n
, XINT (n
) + ht
);
2567 XSETINT (n
, - XINT (n
));
2569 XSET (window
, Lisp_Window
, w
);
2570 Fvertical_motion (n
, window
);
2571 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2572 w
->start_at_line_beg
= Fbolp ();
2575 w
->force_start
= Qt
;
2580 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2582 "Position point relative to window.\n\
2583 With no argument, position text at center of window.\n\
2584 An argument specifies frame line; zero means top of window,\n\
2585 negative means relative to bottom of window.")
2587 register Lisp_Object arg
;
2589 register struct window
*w
= XWINDOW (selected_window
);
2590 register int height
= window_internal_height (w
);
2595 XFASTINT (arg
) = height
/ 2;
2598 arg
= Fprefix_numeric_value (arg
);
2600 XSETINT (arg
, XINT (arg
) + height
);
2603 start
= marker_position (w
->start
);
2604 XSET (window
, Lisp_Window
, w
);
2605 if (start
< BEGV
|| start
> ZV
)
2607 Fvertical_motion (make_number (- (height
/ 2)), window
);
2608 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2609 w
->start_at_line_beg
= Fbolp ();
2610 w
->force_start
= Qt
;
2615 return Fvertical_motion (arg
, window
);
2618 struct save_window_data
2620 int size_from_Lisp_Vector_struct
;
2621 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2622 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2623 Lisp_Object selected_frame
;
2624 Lisp_Object current_window
;
2625 Lisp_Object current_buffer
;
2626 Lisp_Object minibuf_scroll_window
;
2627 Lisp_Object root_window
;
2628 Lisp_Object focus_frame
;
2629 /* A vector, interpreted as a struct saved_window */
2630 Lisp_Object saved_windows
;
2633 /* Arg to Fmake_vector */
2634 #define SAVE_WINDOW_DATA_SIZE \
2635 ((sizeof (struct save_window_data) \
2636 - (sizeof (struct Lisp_Vector) \
2637 /* Don't count the contents member of the struct Lisp_Vector */ \
2638 - sizeof (Lisp_Object))) \
2639 / sizeof (Lisp_Object))
2641 /* This is saved as a Lisp_Vector */
2644 /* these first two must agree with struct Lisp_Vector in lisp.h */
2645 int size_from_Lisp_Vector_struct
;
2646 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2649 Lisp_Object buffer
, start
, pointm
, mark
;
2650 Lisp_Object left
, top
, width
, height
, hscroll
;
2651 Lisp_Object parent
, prev
;
2652 Lisp_Object start_at_line_beg
;
2653 Lisp_Object display_table
;
2655 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2657 #define SAVED_WINDOW_N(swv,n) \
2658 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2660 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2661 "T if OBJECT is a window-configration object.")
2665 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2671 DEFUN ("set-window-configuration", Fset_window_configuration
,
2672 Sset_window_configuration
, 1, 1, 0,
2673 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2674 CONFIGURATION must be a value previously returned\n\
2675 by `current-window-configuration' (which see).")
2677 Lisp_Object configuration
;
2679 register struct save_window_data
*data
;
2680 struct Lisp_Vector
*saved_windows
;
2681 Lisp_Object new_current_buffer
;
2685 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2687 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2691 data
= (struct save_window_data
*) XVECTOR (configuration
);
2692 saved_windows
= XVECTOR (data
->saved_windows
);
2694 new_current_buffer
= data
->current_buffer
;
2695 if (NILP (XBUFFER (new_current_buffer
)->name
))
2696 new_current_buffer
= Qnil
;
2698 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2701 /* If f is a dead frame, don't bother rebuilding its window tree.
2702 However, there is other stuff we should still try to do below. */
2703 if (FRAME_LIVE_P (f
))
2705 register struct window
*w
;
2706 register struct saved_window
*p
;
2709 /* If the frame has been resized since this window configuration was
2710 made, we change the frame to the size specified in the
2711 configuration, restore the configuration, and then resize it
2712 back. We keep track of the prevailing height in these variables. */
2713 int previous_frame_height
= FRAME_HEIGHT (f
);
2714 int previous_frame_width
= FRAME_WIDTH (f
);
2715 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2717 if (XFASTINT (data
->frame_height
) != previous_frame_height
2718 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2719 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2720 #ifdef HAVE_X_WINDOWS
2721 if (XFASTINT (data
->frame_menu_bar_lines
)
2722 != previous_frame_menu_bar_lines
)
2723 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2726 windows_or_buffers_changed
++;
2729 Mark all windows now on frame as "deleted".
2730 Restoring the new configuration "undeletes" any that are in it.
2732 Save their current buffers in their height fields, since we may
2733 need it later, if a buffer saved in the configuration is now
2735 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2737 for (k
= 0; k
< saved_windows
->size
; k
++)
2739 p
= SAVED_WINDOW_N (saved_windows
, k
);
2740 w
= XWINDOW (p
->window
);
2743 if (!NILP (p
->parent
))
2744 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2745 XFASTINT (p
->parent
))->window
;
2749 if (!NILP (p
->prev
))
2751 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2752 XFASTINT (p
->prev
))->window
;
2753 XWINDOW (w
->prev
)->next
= p
->window
;
2758 if (!NILP (w
->parent
))
2760 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2762 XWINDOW (w
->parent
)->vchild
= p
->window
;
2763 XWINDOW (w
->parent
)->hchild
= Qnil
;
2767 XWINDOW (w
->parent
)->hchild
= p
->window
;
2768 XWINDOW (w
->parent
)->vchild
= Qnil
;
2773 /* If we squirreled away the buffer in the window's height,
2775 if (XTYPE (w
->height
) == Lisp_Buffer
)
2776 w
->buffer
= w
->height
;
2779 w
->width
= p
->width
;
2780 w
->height
= p
->height
;
2781 w
->hscroll
= p
->hscroll
;
2782 w
->display_table
= p
->display_table
;
2783 XFASTINT (w
->last_modified
) = 0;
2785 /* Reinstall the saved buffer and pointers into it. */
2786 if (NILP (p
->buffer
))
2787 w
->buffer
= p
->buffer
;
2790 if (!NILP (XBUFFER (p
->buffer
)->name
))
2791 /* If saved buffer is alive, install it. */
2793 w
->buffer
= p
->buffer
;
2794 w
->start_at_line_beg
= p
->start_at_line_beg
;
2795 set_marker_restricted (w
->start
,
2796 Fmarker_position (p
->start
),
2798 set_marker_restricted (w
->pointm
,
2799 Fmarker_position (p
->pointm
),
2801 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2802 Fmarker_position (p
->mark
), w
->buffer
);
2804 /* As documented in Fcurrent_window_configuration, don't
2805 save the location of point in the buffer which was current
2806 when the window configuration was recorded. */
2807 if (!EQ (p
->buffer
, new_current_buffer
)
2808 && XBUFFER (p
->buffer
) == current_buffer
)
2809 Fgoto_char (w
->pointm
);
2811 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2812 /* Else unless window has a live buffer, get one. */
2814 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2815 /* This will set the markers to beginning of visible
2817 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2818 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2819 w
->start_at_line_beg
= Qt
;
2822 /* Keeping window's old buffer; make sure the markers
2825 /* Set window markers at start of visible range. */
2826 if (XMARKER (w
->start
)->buffer
== 0)
2827 set_marker_restricted (w
->start
, make_number (0),
2829 if (XMARKER (w
->pointm
)->buffer
== 0)
2830 set_marker_restricted (w
->pointm
,
2832 (BUF_PT (XBUFFER (w
->buffer
)))),
2834 w
->start_at_line_beg
= Qt
;
2839 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2840 Fselect_window (data
->current_window
);
2843 if (NILP (data
->focus_frame
)
2844 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2845 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2846 Fredirect_frame_focus (frame
, data
->focus_frame
);
2849 #if 0 /* I don't understand why this is needed, and it causes problems
2850 when the frame's old selected window has been deleted. */
2852 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2853 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2857 /* Set the screen height to the value it had before this function. */
2858 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2859 || previous_frame_width
!= FRAME_WIDTH (f
))
2860 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2862 #ifdef HAVE_X_WINDOWS
2863 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2864 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2869 /* Fselect_window will have made f the selected frame, so we
2870 reselect the proper frame here. Fhandle_switch_frame will change the
2871 selected window too, but that doesn't make the call to
2872 Fselect_window above totally superfluous; it still sets f's
2874 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2875 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2878 if (!NILP (new_current_buffer
))
2879 Fset_buffer (new_current_buffer
);
2881 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2885 /* Mark all windows now on frame as deleted
2886 by setting their buffers to nil. */
2889 delete_all_subwindows (w
)
2890 register struct window
*w
;
2892 if (!NILP (w
->next
))
2893 delete_all_subwindows (XWINDOW (w
->next
));
2894 if (!NILP (w
->vchild
))
2895 delete_all_subwindows (XWINDOW (w
->vchild
));
2896 if (!NILP (w
->hchild
))
2897 delete_all_subwindows (XWINDOW (w
->hchild
));
2899 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2901 /* We set all three of these fields to nil, to make sure that we can
2902 distinguish this dead window from any live window. Live leaf
2903 windows will have buffer set, and combination windows will have
2904 vchild or hchild set. */
2911 count_windows (window
)
2912 register struct window
*window
;
2914 register int count
= 1;
2915 if (!NILP (window
->next
))
2916 count
+= count_windows (XWINDOW (window
->next
));
2917 if (!NILP (window
->vchild
))
2918 count
+= count_windows (XWINDOW (window
->vchild
));
2919 if (!NILP (window
->hchild
))
2920 count
+= count_windows (XWINDOW (window
->hchild
));
2925 save_window_save (window
, vector
, i
)
2927 struct Lisp_Vector
*vector
;
2930 register struct saved_window
*p
;
2931 register struct window
*w
;
2932 register Lisp_Object tem
;
2934 for (;!NILP (window
); window
= w
->next
)
2936 p
= SAVED_WINDOW_N (vector
, i
);
2937 w
= XWINDOW (window
);
2939 XFASTINT (w
->temslot
) = i
++;
2941 p
->buffer
= w
->buffer
;
2944 p
->width
= w
->width
;
2945 p
->height
= w
->height
;
2946 p
->hscroll
= w
->hscroll
;
2947 p
->display_table
= w
->display_table
;
2948 if (!NILP (w
->buffer
))
2950 /* Save w's value of point in the window configuration.
2951 If w is the selected window, then get the value of point
2952 from the buffer; pointm is garbage in the selected window. */
2953 if (EQ (window
, selected_window
))
2955 p
->pointm
= Fmake_marker ();
2956 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2960 p
->pointm
= Fcopy_marker (w
->pointm
);
2962 p
->start
= Fcopy_marker (w
->start
);
2963 p
->start_at_line_beg
= w
->start_at_line_beg
;
2965 tem
= XBUFFER (w
->buffer
)->mark
;
2966 p
->mark
= Fcopy_marker (tem
);
2973 p
->start_at_line_beg
= Qnil
;
2976 if (NILP (w
->parent
))
2979 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2984 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2986 if (!NILP (w
->vchild
))
2987 i
= save_window_save (w
->vchild
, vector
, i
);
2988 if (!NILP (w
->hchild
))
2989 i
= save_window_save (w
->hchild
, vector
, i
);
2995 DEFUN ("current-window-configuration",
2996 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2997 "Return an object representing the current window configuration of FRAME.\n\
2998 If FRAME is nil or omitted, use the selected frame.\n\
2999 This describes the number of windows, their sizes and current buffers,\n\
3000 and for each displayed buffer, where display starts, and the positions of\n\
3001 point and mark. An exception is made for point in the current buffer:\n\
3002 its value is -not- saved.\n\
3003 This also records the currently selected frame, and FRAME's focus\n\
3004 redirection (see `redirect-frame-focus').")
3008 register Lisp_Object tem
;
3009 register int n_windows
;
3010 register struct save_window_data
*data
;
3018 CHECK_LIVE_FRAME (frame
, 0);
3022 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3023 data
= (struct save_window_data
*)
3024 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
3026 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
3027 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
3028 XFASTINT (data
->frame_menu_bar_lines
) = FRAME_MENU_BAR_LINES (f
);
3030 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
3032 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3033 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
3034 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3035 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3036 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3037 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3038 data
->saved_windows
= tem
;
3039 for (i
= 0; i
< n_windows
; i
++)
3040 XVECTOR (tem
)->contents
[i
]
3041 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3042 save_window_save (FRAME_ROOT_WINDOW (f
),
3044 XSET (tem
, Lisp_Window_Configuration
, data
);
3048 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3050 "Execute body, preserving window sizes and contents.\n\
3051 Restore which buffer appears in which window, where display starts,\n\
3052 and the value of point and mark for each window.\n\
3053 Also restore which buffer is current.\n\
3054 But do not preserve point in the current buffer.\n\
3055 Does not restore the value of point in current buffer.")
3059 register Lisp_Object val
;
3060 register int count
= specpdl_ptr
- specpdl
;
3062 record_unwind_protect (Fset_window_configuration
,
3063 Fcurrent_window_configuration (Qnil
));
3064 val
= Fprogn (args
);
3065 return unbind_to (count
, val
);
3071 selected_frame
= make_terminal_frame ();
3072 minibuf_window
= selected_frame
->minibuffer_window
;
3073 selected_window
= selected_frame
->selected_window
;
3074 last_nonminibuf_frame
= selected_frame
;
3075 #else /* not MULTI_FRAME */
3076 extern Lisp_Object
get_minibuffer ();
3078 minibuf_window
= make_window ();
3079 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3081 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3082 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3083 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3085 /* These values 9 and 10 are arbitrary,
3086 just so that there is "something there."
3087 Correct values are put in in init_xdisp */
3089 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
3090 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
3092 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
3093 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
3094 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
3096 /* Prevent error in Fset_window_buffer. */
3097 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3098 XWINDOW (minibuf_window
)->buffer
= Qt
;
3100 /* Now set them up for real. */
3101 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3102 Fcurrent_buffer ());
3103 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3105 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3106 /* Make sure this window seems more recently used than
3107 a newly-created, never-selected window. Increment
3108 window_select_count so the first selection ever will get
3109 something newer than this. */
3110 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
3111 #endif /* not MULTI_FRAME */
3116 Qwindowp
= intern ("windowp");
3117 staticpro (&Qwindowp
);
3119 Qwindow_live_p
= intern ("window-live-p");
3120 staticpro (&Qwindow_live_p
);
3123 /* Make sure all windows get marked */
3124 staticpro (&minibuf_window
);
3127 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3128 "Non-nil means call as function to display a help buffer.\n\
3129 Used by `with-output-to-temp-buffer'.");
3130 Vtemp_buffer_show_function
= Qnil
;
3132 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3133 "If non-nil, function to call to handle `display-buffer'.\n\
3134 It will receive two args, the buffer and a flag which if non-nil means\n\
3135 that the currently selected window is not acceptable.\n\
3136 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3137 work using this function.");
3138 Vdisplay_buffer_function
= Qnil
;
3140 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3141 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3142 Vminibuf_scroll_window
= Qnil
;
3144 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3145 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3146 Vother_window_scroll_buffer
= Qnil
;
3148 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3149 "*Non-nil means `display-buffer' should make a separate frame.");
3152 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3153 "Function to call to handle automatic new frame creation.\n\
3154 It is called with no arguments and should return a newly created frame.\n\
3156 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3157 where `pop-up-frame-alist' would hold the default frame parameters.");
3158 Vpop_up_frame_function
= Qnil
;
3160 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3161 "*List of buffer names that should have their own special frames.\n\
3162 Displaying a buffer whose name is in this list makes a special frame for it\n\
3163 using `special-display-function'. See also `special-display-regexps'.");
3164 Vspecial_display_buffer_names
= Qnil
;
3166 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3167 "*List of regexps saying which buffers should have their own special frames.\n\
3168 If a buffer name matches one of these regexps, it gets its own frame.\n\
3169 Displaying a buffer whose name is in this list makes a special frame for it\n\
3170 using `special-display-function'. See also `special-display-buffer-names'.");
3171 Vspecial_display_regexps
= Qnil
;
3173 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3174 "Function to call to make a new frame for a special buffer.\n\
3175 It is called with one argument, the buffer,\n\
3176 and should return a window displaying that buffer.\n\
3177 The default value makes a separate frame for the buffer,\n\
3178 using `special-display-alist' to specify the frame parameters.\n\
3180 A buffer is special if its is listed in `special-display-buffer-names'\n\
3181 or matches a regexp in `special-display-regexps'.");
3182 Vspecial_display_function
= Qnil
;
3184 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3185 "*Non-nil means display-buffer should make new windows.");
3188 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3189 "*Number of lines of continuity when scrolling by screenfuls.");
3190 next_screen_context_lines
= 2;
3192 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3193 "*display-buffer would prefer to split the largest window if this large.\n\
3194 If there is only one window, it is split regardless of this value.");
3195 split_height_threshold
= 500;
3197 DEFVAR_INT ("window-min-height", &window_min_height
,
3198 "*Delete any window less than this tall (including its mode line).");
3199 window_min_height
= 4;
3201 DEFVAR_INT ("window-min-width", &window_min_width
,
3202 "*Delete any window less than this wide.");
3203 window_min_width
= 10;
3205 defsubr (&Sselected_window
);
3206 defsubr (&Sminibuffer_window
);
3207 defsubr (&Swindow_minibuffer_p
);
3208 defsubr (&Swindowp
);
3209 defsubr (&Swindow_live_p
);
3210 defsubr (&Spos_visible_in_window_p
);
3211 defsubr (&Swindow_buffer
);
3212 defsubr (&Swindow_height
);
3213 defsubr (&Swindow_width
);
3214 defsubr (&Swindow_hscroll
);
3215 defsubr (&Sset_window_hscroll
);
3216 defsubr (&Swindow_edges
);
3217 defsubr (&Scoordinates_in_window_p
);
3218 defsubr (&Swindow_at
);
3219 defsubr (&Swindow_point
);
3220 defsubr (&Swindow_start
);
3221 defsubr (&Swindow_end
);
3222 defsubr (&Sset_window_point
);
3223 defsubr (&Sset_window_start
);
3224 defsubr (&Swindow_dedicated_p
);
3225 defsubr (&Sset_window_dedicated_p
);
3226 defsubr (&Swindow_display_table
);
3227 defsubr (&Sset_window_display_table
);
3228 defsubr (&Snext_window
);
3229 defsubr (&Sprevious_window
);
3230 defsubr (&Sother_window
);
3231 defsubr (&Sget_lru_window
);
3232 defsubr (&Sget_largest_window
);
3233 defsubr (&Sget_buffer_window
);
3234 defsubr (&Sdelete_other_windows
);
3235 defsubr (&Sdelete_windows_on
);
3236 defsubr (&Sreplace_buffer_in_windows
);
3237 defsubr (&Sdelete_window
);
3238 defsubr (&Sset_window_buffer
);
3239 defsubr (&Sselect_window
);
3240 defsubr (&Sdisplay_buffer
);
3241 defsubr (&Ssplit_window
);
3242 defsubr (&Senlarge_window
);
3243 defsubr (&Sshrink_window
);
3244 defsubr (&Sscroll_up
);
3245 defsubr (&Sscroll_down
);
3246 defsubr (&Sscroll_left
);
3247 defsubr (&Sscroll_right
);
3248 defsubr (&Sother_window_for_scrolling
);
3249 defsubr (&Sscroll_other_window
);
3250 defsubr (&Srecenter
);
3251 defsubr (&Smove_to_window_line
);
3252 defsubr (&Swindow_configuration_p
);
3253 defsubr (&Sset_window_configuration
);
3254 defsubr (&Scurrent_window_configuration
);
3255 defsubr (&Ssave_window_excursion
);
3260 initial_define_key (control_x_map
, '1', "delete-other-windows");
3261 initial_define_key (control_x_map
, '2', "split-window");
3262 initial_define_key (control_x_map
, '0', "delete-window");
3263 initial_define_key (control_x_map
, 'o', "other-window");
3264 initial_define_key (control_x_map
, '^', "enlarge-window");
3265 initial_define_key (control_x_map
, '<', "scroll-left");
3266 initial_define_key (control_x_map
, '>', "scroll-right");
3268 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3269 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3270 initial_define_key (meta_map
, 'v', "scroll-down");
3272 initial_define_key (global_map
, Ctl('L'), "recenter");
3273 initial_define_key (meta_map
, 'r', "move-to-window-line");