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. This means that next-window may 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 Anything else means restrict to WINDOW's frame.\n\
855 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
856 `next-window' to iterate through the entire cycle of acceptable\n\
857 windows, eventually ending up back at the window you started with.\n\
858 `previous-window' traverses the same cycle, in the reverse order.")
859 (window, minibuf, all_frames) */
861 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
863 (window
, minibuf
, all_frames
)
864 register Lisp_Object window
, minibuf
, all_frames
;
866 register Lisp_Object tem
;
867 Lisp_Object start_window
;
870 window
= selected_window
;
872 CHECK_LIVE_WINDOW (window
, 0);
874 start_window
= window
;
876 /* minibuf == nil may or may not include minibuffers.
877 Decide if it does. */
879 minibuf
= (minibuf_level
? Qt
: Qlambda
);
882 /* all_frames == nil doesn't specify which frames to include.
883 Decide which frames it includes. */
884 if (NILP (all_frames
))
885 all_frames
= (EQ (minibuf
, Qt
)
886 ? (FRAME_MINIBUF_WINDOW
889 (XWINDOW (window
)))))
891 else if (EQ (all_frames
, Qvisible
))
893 else if (! EQ (all_frames
, Qt
))
895 /* Now all_frames is t meaning search all frames,
896 nil meaning search just current frame,
897 or a window, meaning search the frame that window belongs to. */
900 /* Do this loop at least once, to get the next window, and perhaps
901 again, if we hit the minibuffer and that is not acceptable. */
904 /* Find a window that actually has a next one. This loop
905 climbs up the tree. */
906 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
907 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
911 /* We've reached the end of this frame.
912 Which other frames are acceptable? */
913 tem
= WINDOW_FRAME (XWINDOW (window
));
915 if (! NILP (all_frames
))
916 tem
= next_frame (tem
, all_frames
);
918 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
925 /* If we're in a combination window, find its first child and
926 recurse on that. Otherwise, we've found the window we want. */
929 if (!NILP (XWINDOW (window
)->hchild
))
930 window
= XWINDOW (window
)->hchild
;
931 else if (!NILP (XWINDOW (window
)->vchild
))
932 window
= XWINDOW (window
)->vchild
;
936 /* Which windows are acceptible?
937 Exit the loop and accept this window if
938 this isn't a minibuffer window, or
939 we're accepting minibuffer windows, or
940 we've come all the way around and we're back at the original window. */
941 while (MINI_WINDOW_P (XWINDOW (window
))
942 && ! EQ (minibuf
, Qt
)
943 && ! EQ (window
, start_window
));
948 /* This comment supplies the doc string for `previous-window',
949 for make-docfile to see. We cannot put this in the real DEFUN
950 due to limits in the Unix cpp.
952 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
953 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
954 If omitted, WINDOW defaults to the selected window.\n\
956 Optional second arg MINIBUF t means count the minibuffer window even\n\
957 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
958 it is active. MINIBUF neither t nor nil means not to count the\n\
959 minibuffer even if it is active.\n\
961 Several frames may share a single minibuffer; if the minibuffer\n\
962 counts, all windows on all frames that share that minibuffer count\n\
963 too. This means that previous-window may be used to iterate through\n\
964 the set of windows even when the minibuffer is on another frame. If\n\
965 the minibuffer does not count, only windows from WINDOW's frame\n\
968 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
969 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
970 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
971 Anything else means restrict to WINDOW's frame.\n\
973 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
974 `previous-window' to iterate through the entire cycle of acceptable\n\
975 windows, eventually ending up back at the window you started with.\n\
976 `next-window' traverses the same cycle, in the reverse order.")
977 (window, minibuf, all_frames) */
980 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
982 (window
, minibuf
, all_frames
)
983 register Lisp_Object window
, minibuf
, all_frames
;
985 register Lisp_Object tem
;
986 Lisp_Object start_window
;
989 window
= selected_window
;
991 CHECK_LIVE_WINDOW (window
, 0);
993 start_window
= window
;
995 /* minibuf == nil may or may not include minibuffers.
996 Decide if it does. */
998 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1001 /* all_frames == nil doesn't specify which frames to include.
1002 Decide which frames it includes. */
1003 if (NILP (all_frames
))
1004 all_frames
= (EQ (minibuf
, Qt
)
1005 ? (FRAME_MINIBUF_WINDOW
1008 (XWINDOW (window
)))))
1010 else if (EQ (all_frames
, Qvisible
))
1012 else if (! EQ (all_frames
, Qt
))
1014 /* Now all_frames is t meaning search all frames,
1015 nil meaning search just current frame,
1016 or a window, meaning search the frame that window belongs to. */
1019 /* Do this loop at least once, to get the previous window, and perhaps
1020 again, if we hit the minibuffer and that is not acceptable. */
1023 /* Find a window that actually has a previous one. This loop
1024 climbs up the tree. */
1025 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1026 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1030 /* We have found the top window on the frame.
1031 Which frames are acceptable? */
1032 tem
= WINDOW_FRAME (XWINDOW (window
));
1034 if (! NILP (all_frames
))
1035 /* It's actually important that we use prev_frame here,
1036 rather than next_frame. All the windows acceptable
1037 according to the given parameters should form a ring;
1038 Fnext_window and Fprevious_window should go back and
1039 forth around the ring. If we use next_frame here,
1040 then Fnext_window and Fprevious_window take different
1041 paths through the set of acceptable windows.
1042 window_loop assumes that these `ring' requirement are
1044 tem
= prev_frame (tem
, all_frames
);
1046 /* If this frame has a minibuffer, find that window first,
1047 because it is conceptually the last window in that frame. */
1048 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1049 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1051 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1057 /* If we're in a combination window, find its last child and
1058 recurse on that. Otherwise, we've found the window we want. */
1061 if (!NILP (XWINDOW (window
)->hchild
))
1062 window
= XWINDOW (window
)->hchild
;
1063 else if (!NILP (XWINDOW (window
)->vchild
))
1064 window
= XWINDOW (window
)->vchild
;
1066 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1070 /* Which windows are acceptable?
1071 Exit the loop and accept this window if
1072 this isn't a minibuffer window, or
1073 we're accepting minibuffer windows, or
1074 we've come all the way around and we're back at the original window. */
1075 while (MINI_WINDOW_P (XWINDOW (window
))
1076 && !EQ (minibuf
, Qt
)
1077 && !EQ (window
, start_window
));
1082 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1083 "Select the ARG'th different window on this frame.\n\
1084 All windows on current frame are arranged in a cyclic order.\n\
1085 This command selects the window ARG steps away in that order.\n\
1086 A negative ARG moves in the opposite order. If the optional second\n\
1087 argument ALL_FRAMES is non-nil, cycle through all frames.")
1089 register Lisp_Object n
, all_frames
;
1092 register Lisp_Object w
;
1094 CHECK_NUMBER (n
, 0);
1095 w
= selected_window
;
1100 w
= Fnext_window (w
, Qnil
, all_frames
);
1105 w
= Fprevious_window (w
, Qnil
, all_frames
);
1112 /* Look at all windows, performing an operation specified by TYPE
1114 If FRAMES is Qt, look at all frames;
1115 Qnil, look at just the selected frame;
1116 Qvisible, look at visible frames;
1117 a frame, just look at windows on that frame.
1118 If MINI is non-zero, perform the operation on minibuffer windows too.
1124 GET_BUFFER_WINDOW
, /* Arg is buffer */
1125 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1126 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1127 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1129 UNSHOW_BUFFER
/* Arg is buffer */
1133 window_loop (type
, obj
, mini
, frames
)
1134 enum window_loop type
;
1135 register Lisp_Object obj
, frames
;
1138 register Lisp_Object w
;
1139 register Lisp_Object best_window
;
1140 register Lisp_Object next_window
;
1141 register Lisp_Object last_window
;
1143 Lisp_Object frame_arg
;
1147 /* If we're only looping through windows on a particular frame,
1148 frame points to that frame. If we're looping through windows
1149 on all frames, frame is 0. */
1150 if (FRAMEP (frames
))
1151 frame
= XFRAME (frames
);
1152 else if (NILP (frames
))
1153 frame
= selected_frame
;
1157 frame_arg
= Qlambda
;
1158 else if (EQ (frames
, Qvisible
))
1164 /* frame_arg is Qlambda to stick to one frame,
1165 Qvisible to consider all visible frames,
1168 /* Pick a window to start with. */
1169 if (XTYPE (obj
) == Lisp_Window
)
1172 w
= FRAME_SELECTED_WINDOW (frame
);
1174 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1176 /* Figure out the last window we're going to mess with. Since
1177 Fnext_window, given the same options, is guaranteed to go in a
1178 ring, we can just use Fprevious_window to find the last one.
1180 We can't just wait until we hit the first window again, because
1181 it might be deleted. */
1183 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1188 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1190 /* Pick the next window now, since some operations will delete
1191 the current window. */
1192 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1194 /* Note that we do not pay attention here to whether
1195 the frame is visible, since Fnext_window skips non-visible frames
1196 if that is desired, under the control of frame_arg. */
1197 if (! MINI_WINDOW_P (XWINDOW (w
))
1198 || (mini
&& minibuf_level
> 0))
1201 case GET_BUFFER_WINDOW
:
1202 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1206 case GET_LRU_WINDOW
:
1207 /* t as arg means consider only full-width windows */
1208 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1209 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1211 /* Ignore dedicated windows and minibuffers. */
1212 if (MINI_WINDOW_P (XWINDOW (w
))
1213 || !NILP (XWINDOW (w
)->dedicated
))
1215 if (NILP (best_window
)
1216 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1217 > XFASTINT (XWINDOW (w
)->use_time
)))
1221 case DELETE_OTHER_WINDOWS
:
1222 if (XWINDOW (w
) != XWINDOW (obj
))
1226 case DELETE_BUFFER_WINDOWS
:
1227 if (EQ (XWINDOW (w
)->buffer
, obj
))
1229 /* If we're deleting the buffer displayed in the only window
1230 on the frame, find a new buffer to display there. */
1231 if (NILP (XWINDOW (w
)->parent
))
1233 Lisp_Object new_buffer
;
1234 new_buffer
= Fother_buffer (obj
, Qnil
);
1235 if (NILP (new_buffer
))
1237 = Fget_buffer_create (build_string ("*scratch*"));
1238 Fset_window_buffer (w
, new_buffer
);
1239 if (EQ (w
, selected_window
))
1240 Fset_buffer (XWINDOW (w
)->buffer
);
1247 case GET_LARGEST_WINDOW
:
1248 /* Ignore dedicated windows and minibuffers. */
1249 if (MINI_WINDOW_P (XWINDOW (w
))
1250 || !NILP (XWINDOW (w
)->dedicated
))
1253 struct window
*best_window_ptr
= XWINDOW (best_window
);
1254 struct window
*w_ptr
= XWINDOW (w
);
1255 if (NILP (best_window
)
1256 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1257 > (XFASTINT (best_window_ptr
->height
)
1258 * XFASTINT (best_window_ptr
->width
))))
1264 if (EQ (XWINDOW (w
)->buffer
, obj
))
1266 /* Find another buffer to show in this window. */
1267 Lisp_Object another_buffer
;
1268 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1269 another_buffer
= Fother_buffer (obj
, Qnil
);
1270 if (NILP (another_buffer
))
1272 = Fget_buffer_create (build_string ("*scratch*"));
1274 /* If this window is dedicated, and in a frame of its own,
1276 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1277 && !NILP (XWINDOW (w
)->dedicated
)
1278 && other_visible_frames (f
))
1279 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1283 /* Otherwise show a different buffer in the window. */
1284 XWINDOW (w
)->dedicated
= Qnil
;
1285 Fset_window_buffer (w
, another_buffer
);
1286 if (EQ (w
, selected_window
))
1287 Fset_buffer (XWINDOW (w
)->buffer
);
1293 if (EQ (w
, last_window
))
1302 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1303 "Return the window least recently selected or used for display.\n\
1304 If optional argument FRAME is `visible', search all visible frames.\n\
1305 If FRAME is t, search all frames.\n\
1306 If FRAME is nil, search only the selected frame.\n\
1307 If FRAME is a frame, search only that frame.")
1311 register Lisp_Object w
;
1312 /* First try for a window that is full-width */
1313 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1314 if (!NILP (w
) && !EQ (w
, selected_window
))
1316 /* If none of them, try the rest */
1317 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1320 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1321 "Return the largest window in area.\n\
1322 If optional argument FRAME is `visible', search all visible frames.\n\
1323 If FRAME is t, search all frames.\n\
1324 If FRAME is nil, search only the selected frame.\n\
1325 If FRAME is a frame, search only that frame.")
1329 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1333 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1334 "Return a window currently displaying BUFFER, or nil if none.\n\
1335 If optional argument FRAME is `visible', search all visible 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.")
1340 Lisp_Object buffer
, frame
;
1342 buffer
= Fget_buffer (buffer
);
1343 if (XTYPE (buffer
) == Lisp_Buffer
)
1344 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1349 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1351 "Make WINDOW (or the selected window) fill its frame.\n\
1352 Only the frame WINDOW is on is affected.\n\
1353 This function tries to reduce display jumps\n\
1354 by keeping the text previously visible in WINDOW\n\
1355 in the same place on the frame. Doing this depends on\n\
1356 the value of (window-start WINDOW), so if calling this function\n\
1357 in a program gives strange scrolling, make sure the window-start\n\
1358 value is reasonable when this function is called.")
1367 window
= selected_window
;
1369 CHECK_LIVE_WINDOW (window
, 0);
1371 w
= XWINDOW (window
);
1372 startpos
= marker_position (w
->start
);
1373 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1375 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1377 /* Try to minimize scrolling, by setting the window start to the point
1378 will cause the text at the old window start to be at the same place
1379 on the frame. But don't try to do this if the window start is
1380 outside the visible portion (as might happen when the display is
1381 not current, due to typeahead). */
1382 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1383 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1385 struct position pos
;
1386 struct buffer
*obuf
= current_buffer
;
1388 Fset_buffer (w
->buffer
);
1389 /* This computation used to temporarily move point, but that can
1390 have unwanted side effects due to text properties. */
1391 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1392 XINT (w
->hscroll
), window
);
1393 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1394 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1395 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1398 set_buffer_internal (obuf
);
1403 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1404 1, 2, "bDelete windows on (buffer): ",
1405 "Delete all windows showing BUFFER.\n\
1406 Optional second argument FRAME controls which frames are affected.\n\
1407 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1408 If t, delete only windows showing BUFFER in the selected frame.\n\
1409 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1410 If a frame, delete only windows showing BUFFER in that frame.")
1412 Lisp_Object buffer
, frame
;
1415 /* FRAME uses t and nil to mean the opposite of what window_loop
1417 if (! FRAMEP (frame
))
1418 frame
= NILP (frame
) ? Qt
: Qnil
;
1425 buffer
= Fget_buffer (buffer
);
1426 CHECK_BUFFER (buffer
, 0);
1427 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1432 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1433 Sreplace_buffer_in_windows
,
1434 1, 1, "bReplace buffer in windows: ",
1435 "Replace BUFFER with some other buffer in all windows showing it.")
1441 buffer
= Fget_buffer (buffer
);
1442 CHECK_BUFFER (buffer
, 0);
1443 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1448 /* Set the height of WINDOW and all its inferiors. */
1450 /* The smallest acceptable dimensions for a window. Anything smaller
1451 might crash Emacs. */
1452 #define MIN_SAFE_WINDOW_WIDTH (2)
1453 #define MIN_SAFE_WINDOW_HEIGHT (2)
1455 /* Make sure that window_min_height and window_min_width are
1456 not too small; if they are, set them to safe minima. */
1459 check_min_window_sizes ()
1461 /* Smaller values might permit a crash. */
1462 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1463 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1464 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1465 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1468 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1469 minimum allowable size. */
1471 check_frame_size (frame
, rows
, cols
)
1475 /* For height, we have to see:
1476 whether the frame has a minibuffer,
1477 whether it wants a mode line, and
1478 whether it has a menu bar. */
1480 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1481 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1482 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1483 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1484 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1486 if (*rows
< min_height
)
1488 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1489 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1492 /* Normally the window is deleted if it gets too small.
1493 nodelete nonzero means do not do this.
1494 (The caller should check later and do so if appropriate) */
1496 set_window_height (window
, height
, nodelete
)
1501 register struct window
*w
= XWINDOW (window
);
1502 register struct window
*c
;
1503 int oheight
= XFASTINT (w
->height
);
1504 int top
, pos
, lastbot
, opos
, lastobot
;
1507 check_min_window_sizes ();
1510 && ! NILP (w
->parent
)
1511 && height
< window_min_height
)
1513 Fdelete_window (window
);
1517 XFASTINT (w
->last_modified
) = 0;
1518 windows_or_buffers_changed
++;
1519 XFASTINT (w
->height
) = height
;
1520 if (!NILP (w
->hchild
))
1522 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1524 XWINDOW (child
)->top
= w
->top
;
1525 set_window_height (child
, height
, nodelete
);
1528 else if (!NILP (w
->vchild
))
1530 lastbot
= top
= XFASTINT (w
->top
);
1532 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1534 c
= XWINDOW (child
);
1536 opos
= lastobot
+ XFASTINT (c
->height
);
1538 XFASTINT (c
->top
) = lastbot
;
1540 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1542 /* Avoid confusion: inhibit deletion of child if becomes too small */
1543 set_window_height (child
, pos
+ top
- lastbot
, 1);
1545 /* Now advance child to next window,
1546 and set lastbot if child was not just deleted. */
1547 lastbot
= pos
+ top
;
1550 /* Now delete any children that became too small. */
1552 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1554 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1559 /* Recursively set width of WINDOW and its inferiors. */
1561 set_window_width (window
, width
, nodelete
)
1566 register struct window
*w
= XWINDOW (window
);
1567 register struct window
*c
;
1568 int owidth
= XFASTINT (w
->width
);
1569 int left
, pos
, lastright
, opos
, lastoright
;
1572 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1574 Fdelete_window (window
);
1578 XFASTINT (w
->last_modified
) = 0;
1579 windows_or_buffers_changed
++;
1580 XFASTINT (w
->width
) = width
;
1581 if (!NILP (w
->vchild
))
1583 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1585 XWINDOW (child
)->left
= w
->left
;
1586 set_window_width (child
, width
, nodelete
);
1589 else if (!NILP (w
->hchild
))
1591 lastright
= left
= XFASTINT (w
->left
);
1593 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1595 c
= XWINDOW (child
);
1597 opos
= lastoright
+ XFASTINT (c
->width
);
1599 XFASTINT (c
->left
) = lastright
;
1601 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1603 /* Inhibit deletion for becoming too small */
1604 set_window_width (child
, pos
+ left
- lastright
, 1);
1606 /* Now advance child to next window,
1607 and set lastright if child was not just deleted. */
1608 lastright
= pos
+ left
, lastoright
= opos
;
1610 /* Delete children that became too small */
1612 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1614 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1619 int window_select_count
;
1621 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1622 "Make WINDOW display BUFFER as its contents.\n\
1623 BUFFER can be a buffer or buffer name.")
1625 register Lisp_Object window
, buffer
;
1627 register Lisp_Object tem
;
1628 register struct window
*w
= decode_window (window
);
1630 buffer
= Fget_buffer (buffer
);
1631 CHECK_BUFFER (buffer
, 1);
1633 if (NILP (XBUFFER (buffer
)->name
))
1634 error ("Attempt to display deleted buffer");
1638 error ("Window is deleted");
1639 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1640 is first being set up. */
1642 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1643 error ("Window is dedicated to `%s'",
1644 XSTRING (XBUFFER (tem
)->name
)->data
);
1650 w
->window_end_pos
= 0;
1651 w
->window_end_valid
= Qnil
;
1653 Fset_marker (w
->pointm
,
1654 make_number (BUF_PT (XBUFFER (buffer
))),
1656 set_marker_restricted (w
->start
,
1657 make_number (XBUFFER (buffer
)->last_window_start
),
1659 w
->start_at_line_beg
= Qnil
;
1660 w
->force_start
= Qnil
;
1661 XFASTINT (w
->last_modified
) = 0;
1662 windows_or_buffers_changed
++;
1663 if (EQ (window
, selected_window
))
1664 Fset_buffer (buffer
);
1669 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1670 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1671 The main editor command loop selects the buffer of the selected window\n\
1672 before each command.")
1674 register Lisp_Object window
;
1676 register struct window
*w
;
1677 register struct window
*ow
= XWINDOW (selected_window
);
1679 CHECK_LIVE_WINDOW (window
, 0);
1681 w
= XWINDOW (window
);
1683 if (NILP (w
->buffer
))
1684 error ("Trying to select deleted window or non-leaf window");
1686 XFASTINT (w
->use_time
) = ++window_select_count
;
1687 if (EQ (window
, selected_window
))
1690 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1693 selected_window
= window
;
1695 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1697 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1698 /* Use this rather than Fhandle_switch_frame
1699 so that FRAME_FOCUS_FRAME is moved appropriately as we
1700 move around in the state where a minibuffer in a separate
1702 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1705 selected_frame
->selected_window
= window
;
1708 record_buffer (w
->buffer
);
1709 Fset_buffer (w
->buffer
);
1711 /* Go to the point recorded in the window.
1712 This is important when the buffer is in more
1713 than one window. It also matters when
1714 redisplay_window has altered point after scrolling,
1715 because it makes the change only in the window. */
1717 register int new_point
= marker_position (w
->pointm
);
1718 if (new_point
< BEGV
)
1726 windows_or_buffers_changed
++;
1730 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1731 "BDisplay buffer: \nP",
1732 "Make BUFFER appear in some window but don't select it.\n\
1733 BUFFER can be a buffer or a buffer name.\n\
1734 If BUFFER is shown already in some window, just use that one,\n\
1735 unless the window is the selected window and the optional second\n\
1736 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1737 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1738 Returns the window displaying BUFFER.")
1739 (buffer
, not_this_window
)
1740 register Lisp_Object buffer
, not_this_window
;
1742 register Lisp_Object window
, tem
;
1744 buffer
= Fget_buffer (buffer
);
1745 CHECK_BUFFER (buffer
, 0);
1747 if (!NILP (Vdisplay_buffer_function
))
1748 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1750 if (NILP (not_this_window
)
1751 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1752 return selected_window
;
1755 /* If pop_up_frames,
1756 look for a window showing BUFFER on any visible frame. */
1757 window
= Fget_buffer_window (buffer
, pop_up_frames
? Qvisible
: Qnil
);
1759 window
= Fget_buffer_window (buffer
, Qnil
);
1762 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1765 /* Certain buffer names get special handling. */
1766 if (! NILP (Vspecial_display_function
))
1768 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1770 return call1 (Vspecial_display_function
, buffer
);
1772 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1773 if (fast_string_match (XCONS (tem
)->car
, XBUFFER (buffer
)->name
) >= 0)
1774 return call1 (Vspecial_display_function
, buffer
);
1778 /* If there are no frames open that have more than a minibuffer,
1779 we need to create a new frame. */
1780 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1782 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1783 Fset_window_buffer (window
, buffer
);
1786 #endif /* MULTI_FRAME */
1790 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1798 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1799 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1801 /* Don't try to create a window if would get an error */
1802 if (split_height_threshold
< window_min_height
<< 1)
1803 split_height_threshold
= window_min_height
<< 1;
1805 window
= Fget_largest_window (frames
);
1808 && window_height (window
) >= split_height_threshold
1809 && (XFASTINT (XWINDOW (window
)->width
)
1810 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1811 window
= Fsplit_window (window
, Qnil
, Qnil
);
1814 window
= Fget_lru_window (frames
);
1815 if ((EQ (window
, selected_window
)
1816 || EQ (XWINDOW (window
)->parent
, Qnil
))
1817 && window_height (window
) >= window_min_height
<< 1)
1818 window
= Fsplit_window (window
, Qnil
, Qnil
);
1822 window
= Fget_lru_window (Qnil
);
1824 Fset_window_buffer (window
, buffer
);
1829 temp_output_buffer_show (buf
)
1830 register Lisp_Object buf
;
1832 register struct buffer
*old
= current_buffer
;
1833 register Lisp_Object window
;
1834 register struct window
*w
;
1837 XBUFFER (buf
)->save_modified
= MODIFF
;
1842 set_buffer_internal (old
);
1844 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1845 call1 (Vtemp_buffer_show_function
, buf
);
1848 window
= Fdisplay_buffer (buf
, Qnil
);
1851 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1852 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1853 #endif /* MULTI_FRAME */
1854 Vminibuf_scroll_window
= window
;
1855 w
= XWINDOW (window
);
1856 XFASTINT (w
->hscroll
) = 0;
1857 set_marker_restricted (w
->start
, make_number (1), buf
);
1858 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1863 make_dummy_parent (window
)
1866 register Lisp_Object old
, new;
1867 register struct window
*o
, *p
;
1870 XSETTYPE (old
, Lisp_Vector
);
1871 new = Fcopy_sequence (old
);
1872 XSETTYPE (new, Lisp_Window
);
1876 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1878 /* Put new into window structure in place of window */
1879 replace_window (window
, new);
1892 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1893 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1894 WINDOW defaults to selected one and SIZE to half its size.\n\
1895 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1896 and put SIZE columns in the first of the pair.")
1897 (window
, chsize
, horflag
)
1898 Lisp_Object window
, chsize
, horflag
;
1900 register Lisp_Object
new;
1901 register struct window
*o
, *p
;
1905 window
= selected_window
;
1907 CHECK_LIVE_WINDOW (window
, 0);
1909 o
= XWINDOW (window
);
1913 if (!NILP (horflag
))
1914 /* Round odd size up, since this is for the left-hand window,
1915 and it will lose a column for the separators. */
1916 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1918 size
= XFASTINT (o
->height
) >> 1;
1922 CHECK_NUMBER (chsize
, 1);
1923 size
= XINT (chsize
);
1926 if (MINI_WINDOW_P (o
))
1927 error ("Attempt to split minibuffer window");
1928 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1929 error ("Attempt to split unsplittable frame");
1931 check_min_window_sizes ();
1935 if (size
< window_min_height
1936 || size
+ window_min_height
> XFASTINT (o
->height
))
1937 args_out_of_range_3 (window
, chsize
, horflag
);
1938 if (NILP (o
->parent
)
1939 || NILP (XWINDOW (o
->parent
)->vchild
))
1941 make_dummy_parent (window
);
1943 XWINDOW (new)->vchild
= window
;
1948 if (size
< window_min_width
1949 || size
+ window_min_width
> XFASTINT (o
->width
))
1950 args_out_of_range_3 (window
, chsize
, horflag
);
1951 if (NILP (o
->parent
)
1952 || NILP (XWINDOW (o
->parent
)->hchild
))
1954 make_dummy_parent (window
);
1956 XWINDOW (new)->hchild
= window
;
1960 /* Now we know that window's parent is a vertical combination
1961 if we are dividing vertically, or a horizontal combination
1962 if we are making side-by-side windows */
1964 windows_or_buffers_changed
++;
1965 new = make_window ();
1968 p
->frame
= o
->frame
;
1970 if (!NILP (p
->next
))
1971 XWINDOW (p
->next
)->prev
= new;
1974 p
->parent
= o
->parent
;
1977 Fset_window_buffer (new, o
->buffer
);
1979 /* Apportion the available frame space among the two new windows */
1981 if (!NILP (horflag
))
1983 p
->height
= o
->height
;
1985 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1986 XFASTINT (o
->width
) = size
;
1987 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1992 p
->width
= o
->width
;
1993 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1994 XFASTINT (o
->height
) = size
;
1995 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
2001 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2002 "Make current window ARG lines bigger.\n\
2003 From program, optional second arg non-nil means grow sideways ARG columns.")
2005 register Lisp_Object n
, side
;
2007 CHECK_NUMBER (n
, 0);
2008 change_window_height (XINT (n
), !NILP (side
));
2012 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2013 "Make current window ARG lines smaller.\n\
2014 From program, optional second arg non-nil means shrink sideways ARG columns.")
2016 register Lisp_Object n
, side
;
2018 CHECK_NUMBER (n
, 0);
2019 change_window_height (-XINT (n
), !NILP (side
));
2024 window_height (window
)
2027 register struct window
*p
= XWINDOW (window
);
2028 return XFASTINT (p
->height
);
2032 window_width (window
)
2035 register struct window
*p
= XWINDOW (window
);
2036 return XFASTINT (p
->width
);
2039 #define MINSIZE(w) \
2041 ? window_min_width \
2042 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2045 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2047 #define CURSIZE(w) \
2048 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2050 /* Unlike set_window_height, this function
2051 also changes the heights of the siblings so as to
2052 keep everything consistent. */
2054 change_window_height (delta
, widthflag
)
2058 register Lisp_Object parent
;
2060 register struct window
*p
;
2062 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2063 register int (*setsizefun
) () = (widthflag
2065 : set_window_height
);
2067 check_min_window_sizes ();
2069 window
= selected_window
;
2072 p
= XWINDOW (window
);
2077 error ("No other window to side of this one");
2080 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2081 : !NILP (XWINDOW (parent
)->vchild
))
2086 sizep
= &CURSIZE (window
);
2089 register int maxdelta
;
2091 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2092 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2093 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2094 /* This is a frame with only one window, a minibuffer-only
2095 or a minibufferless frame. */
2098 if (delta
> maxdelta
)
2099 /* This case traps trying to make the minibuffer
2100 the full frame, or make the only window aside from the
2101 minibuffer the full frame. */
2105 if (*sizep
+ delta
< MINSIZE (window
))
2107 Fdelete_window (window
);
2115 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2117 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2118 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2119 CURBEG (p
->next
) += delta
;
2120 /* This does not change size of p->next,
2121 but it propagates the new top edge to its children */
2122 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2124 else if (!NILP (p
->prev
)
2125 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2127 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2128 CURBEG (window
) -= delta
;
2129 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2133 register int delta1
;
2134 register int opht
= (*sizefun
) (parent
);
2136 /* If trying to grow this window to or beyond size of the parent,
2137 make delta1 so big that, on shrinking back down,
2138 all the siblings end up with less than one line and are deleted. */
2139 if (opht
<= *sizep
+ delta
)
2140 delta1
= opht
* opht
* 2;
2141 /* Otherwise, make delta1 just right so that if we add delta1
2142 lines to this window and to the parent, and then shrink
2143 the parent back to its original size, the new proportional
2144 size of this window will increase by delta. */
2146 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2148 /* Add delta1 lines or columns to this window, and to the parent,
2149 keeping things consistent while not affecting siblings. */
2150 CURSIZE (parent
) = opht
+ delta1
;
2151 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2153 /* Squeeze out delta1 lines or columns from our parent,
2154 shriking this window and siblings proportionately.
2155 This brings parent back to correct size.
2156 Delta1 was calculated so this makes this window the desired size,
2157 taking it all out of the siblings. */
2158 (*setsizefun
) (parent
, opht
, 0);
2161 XFASTINT (p
->last_modified
) = 0;
2168 /* Return number of lines of text (not counting mode line) in W. */
2171 window_internal_height (w
)
2174 int ht
= XFASTINT (w
->height
);
2176 if (MINI_WINDOW_P (w
))
2179 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2180 || !NILP (w
->next
) || !NILP (w
->prev
)
2181 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2188 /* Return the number of columns in W.
2189 Don't count columns occupied by scroll bars or the vertical bar
2190 separating W from the sibling to its right. */
2192 window_internal_width (w
)
2195 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2196 int left
= XINT (w
->left
);
2197 int width
= XINT (w
->width
);
2199 /* If this window is flush against the right edge of the frame, its
2200 internal width is its full width. */
2201 if (left
+ width
>= FRAME_WIDTH (f
))
2204 /* If we are not flush right, then our rightmost columns are
2205 occupied by some sort of separator. */
2207 /* Scroll bars occupy a few columns. */
2208 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2209 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2211 /* The column of `|' characters separating side-by-side windows
2212 occupies one column only. */
2217 /* Scroll contents of window WINDOW up N lines. */
2220 window_scroll (window
, n
, noerror
)
2225 register struct window
*w
= XWINDOW (window
);
2226 register int opoint
= PT
;
2228 register int ht
= window_internal_height (w
);
2229 register Lisp_Object tem
;
2231 Lisp_Object bolp
, nmoved
;
2233 XFASTINT (tem
) = PT
;
2234 tem
= Fpos_visible_in_window_p (tem
, window
);
2238 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2239 XFASTINT (tem
) = PT
;
2240 Fset_marker (w
->start
, tem
, w
->buffer
);
2241 w
->force_start
= Qt
;
2244 SET_PT (marker_position (w
->start
));
2245 lose
= n
< 0 && PT
== BEGV
;
2246 Fvertical_motion (make_number (n
), window
);
2256 Fsignal (Qbeginning_of_buffer
, Qnil
);
2261 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2262 w
->start_at_line_beg
= bolp
;
2263 w
->update_mode_line
= Qt
;
2264 XFASTINT (w
->last_modified
) = 0;
2270 tem
= Fvertical_motion (make_number (ht
), window
);
2271 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2274 Fvertical_motion (make_number (-1), window
);
2282 Fsignal (Qend_of_buffer
, Qnil
);
2286 /* This is the guts of Fscroll_up and Fscroll_down. */
2289 scroll_command (n
, direction
)
2290 register Lisp_Object n
;
2293 register int defalt
;
2294 int count
= specpdl_ptr
- specpdl
;
2296 /* If selected window's buffer isn't current, make it current for the moment.
2297 But don't screw up if window_scroll gets an error. */
2298 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2300 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2301 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2304 defalt
= (window_internal_height (XWINDOW (selected_window
))
2305 - next_screen_context_lines
);
2306 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2309 window_scroll (selected_window
, defalt
, 0);
2310 else if (EQ (n
, Qminus
))
2311 window_scroll (selected_window
, - defalt
, 0);
2314 n
= Fprefix_numeric_value (n
);
2315 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2318 unbind_to (count
, Qnil
);
2321 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2322 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2323 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2324 Negative ARG means scroll downward.\n\
2325 When calling from a program, supply a number as argument or nil.")
2329 scroll_command (n
, 1);
2333 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2334 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2335 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2336 Negative ARG means scroll upward.\n\
2337 When calling from a program, supply a number as argument or nil.")
2341 scroll_command (n
, -1);
2345 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2346 "Return the other window for \"other window scroll\" commands.\n\
2347 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2348 specifies the window.\n\
2349 If `other-window-scroll-buffer' is non-nil, a window\n\
2350 showing that buffer is used.")
2355 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2356 && !NILP (Vminibuf_scroll_window
))
2357 window
= Vminibuf_scroll_window
;
2358 /* If buffer is specified, scroll that buffer. */
2359 else if (!NILP (Vother_window_scroll_buffer
))
2361 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2363 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2367 /* Nothing specified; look for a neighboring window on the same
2369 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2371 if (EQ (window
, selected_window
))
2372 /* That didn't get us anywhere; look for a window on another
2375 window
= Fnext_window (window
, Qnil
, Qt
);
2376 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2377 && ! EQ (window
, selected_window
));
2380 CHECK_LIVE_WINDOW (window
, 0);
2382 if (EQ (window
, selected_window
))
2383 error ("There is no other window");
2388 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2389 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2390 The next window is the one below the current one; or the one at the top\n\
2391 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2392 When calling from a program, supply a number as argument or nil.\n\
2394 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2395 specifies the window to scroll.\n\
2396 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2397 showing that buffer, popping the buffer up if necessary.")
2399 register Lisp_Object n
;
2401 register Lisp_Object window
;
2403 register struct window
*w
;
2404 register int count
= specpdl_ptr
- specpdl
;
2406 window
= Fother_window_for_scrolling ();
2408 w
= XWINDOW (window
);
2409 ht
= window_internal_height (w
);
2411 /* Don't screw up if window_scroll gets an error. */
2412 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2414 Fset_buffer (w
->buffer
);
2415 SET_PT (marker_position (w
->pointm
));
2418 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2419 else if (EQ (n
, Qminus
))
2420 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2423 if (XTYPE (n
) == Lisp_Cons
)
2425 CHECK_NUMBER (n
, 0);
2426 window_scroll (window
, XINT (n
), 1);
2429 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2430 unbind_to (count
, Qnil
);
2435 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2436 "Scroll selected window display ARG columns left.\n\
2437 Default for ARG is window width minus 2.")
2439 register Lisp_Object arg
;
2443 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2445 arg
= Fprefix_numeric_value (arg
);
2448 Fset_window_hscroll (selected_window
,
2449 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2453 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2454 "Scroll selected window display ARG columns right.\n\
2455 Default for ARG is window width minus 2.")
2457 register Lisp_Object arg
;
2460 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2462 arg
= Fprefix_numeric_value (arg
);
2465 Fset_window_hscroll (selected_window
,
2466 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2470 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2471 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2472 The desired position of point is always relative to the current window.\n\
2473 Just C-u as prefix means put point in the center of the window.\n\
2474 No arg (i.e., it is nil) erases the entire frame and then\n\
2475 redraws with point in the center of the current window.")
2477 register Lisp_Object n
;
2479 register struct window
*w
= XWINDOW (selected_window
);
2480 register int ht
= window_internal_height (w
);
2481 register int opoint
= PT
;
2486 extern int frame_garbaged
;
2488 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2489 XFASTINT (n
) = ht
/ 2;
2491 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2493 XFASTINT (n
) = ht
/ 2;
2497 n
= Fprefix_numeric_value (n
);
2498 CHECK_NUMBER (n
, 0);
2502 XSETINT (n
, XINT (n
) + ht
);
2504 XSETINT (n
, - XINT (n
));
2506 XSET (window
, Lisp_Window
, w
);
2507 Fvertical_motion (n
, window
);
2508 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2509 w
->start_at_line_beg
= Fbolp ();
2512 w
->force_start
= Qt
;
2517 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2519 "Position point relative to window.\n\
2520 With no argument, position text at center of window.\n\
2521 An argument specifies frame line; zero means top of window,\n\
2522 negative means relative to bottom of window.")
2524 register Lisp_Object arg
;
2526 register struct window
*w
= XWINDOW (selected_window
);
2527 register int height
= window_internal_height (w
);
2532 XFASTINT (arg
) = height
/ 2;
2535 arg
= Fprefix_numeric_value (arg
);
2537 XSETINT (arg
, XINT (arg
) + height
);
2540 start
= marker_position (w
->start
);
2541 XSET (window
, Lisp_Window
, w
);
2542 if (start
< BEGV
|| start
> ZV
)
2544 Fvertical_motion (make_number (- (height
/ 2)), window
);
2545 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2546 w
->start_at_line_beg
= Fbolp ();
2547 w
->force_start
= Qt
;
2552 return Fvertical_motion (arg
, window
);
2555 struct save_window_data
2557 int size_from_Lisp_Vector_struct
;
2558 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2559 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2560 Lisp_Object selected_frame
;
2561 Lisp_Object current_window
;
2562 Lisp_Object current_buffer
;
2563 Lisp_Object minibuf_scroll_window
;
2564 Lisp_Object root_window
;
2565 Lisp_Object focus_frame
;
2566 /* A vector, interpreted as a struct saved_window */
2567 Lisp_Object saved_windows
;
2570 /* Arg to Fmake_vector */
2571 #define SAVE_WINDOW_DATA_SIZE \
2572 ((sizeof (struct save_window_data) \
2573 - (sizeof (struct Lisp_Vector) \
2574 /* Don't count the contents member of the struct Lisp_Vector */ \
2575 - sizeof (Lisp_Object))) \
2576 / sizeof (Lisp_Object))
2578 /* This is saved as a Lisp_Vector */
2581 /* these first two must agree with struct Lisp_Vector in lisp.h */
2582 int size_from_Lisp_Vector_struct
;
2583 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2586 Lisp_Object buffer
, start
, pointm
, mark
;
2587 Lisp_Object left
, top
, width
, height
, hscroll
;
2588 Lisp_Object parent
, prev
;
2589 Lisp_Object start_at_line_beg
;
2590 Lisp_Object display_table
;
2592 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2594 #define SAVED_WINDOW_N(swv,n) \
2595 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2597 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2598 "T if OBJECT is a window-configration object.")
2602 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2608 DEFUN ("set-window-configuration", Fset_window_configuration
,
2609 Sset_window_configuration
, 1, 1, 0,
2610 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2611 CONFIGURATION must be a value previously returned\n\
2612 by `current-window-configuration' (which see).")
2614 Lisp_Object configuration
;
2616 register struct save_window_data
*data
;
2617 struct Lisp_Vector
*saved_windows
;
2618 Lisp_Object new_current_buffer
;
2622 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2624 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2628 data
= (struct save_window_data
*) XVECTOR (configuration
);
2629 saved_windows
= XVECTOR (data
->saved_windows
);
2631 new_current_buffer
= data
->current_buffer
;
2632 if (NILP (XBUFFER (new_current_buffer
)->name
))
2633 new_current_buffer
= Qnil
;
2635 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2638 /* If f is a dead frame, don't bother rebuilding its window tree.
2639 However, there is other stuff we should still try to do below. */
2640 if (FRAME_LIVE_P (f
))
2642 register struct window
*w
;
2643 register struct saved_window
*p
;
2646 /* If the frame has been resized since this window configuration was
2647 made, we change the frame to the size specified in the
2648 configuration, restore the configuration, and then resize it
2649 back. We keep track of the prevailing height in these variables. */
2650 int previous_frame_height
= FRAME_HEIGHT (f
);
2651 int previous_frame_width
= FRAME_WIDTH (f
);
2652 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2654 if (XFASTINT (data
->frame_height
) != previous_frame_height
2655 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2656 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2657 #ifdef HAVE_X_WINDOWS
2658 if (XFASTINT (data
->frame_menu_bar_lines
)
2659 != previous_frame_menu_bar_lines
)
2660 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2663 windows_or_buffers_changed
++;
2666 Mark all windows now on frame as "deleted".
2667 Restoring the new configuration "undeletes" any that are in it.
2669 Save their current buffers in their height fields, since we may
2670 need it later, if a buffer saved in the configuration is now
2672 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2674 for (k
= 0; k
< saved_windows
->size
; k
++)
2676 p
= SAVED_WINDOW_N (saved_windows
, k
);
2677 w
= XWINDOW (p
->window
);
2680 if (!NILP (p
->parent
))
2681 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2682 XFASTINT (p
->parent
))->window
;
2686 if (!NILP (p
->prev
))
2688 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2689 XFASTINT (p
->prev
))->window
;
2690 XWINDOW (w
->prev
)->next
= p
->window
;
2695 if (!NILP (w
->parent
))
2697 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2699 XWINDOW (w
->parent
)->vchild
= p
->window
;
2700 XWINDOW (w
->parent
)->hchild
= Qnil
;
2704 XWINDOW (w
->parent
)->hchild
= p
->window
;
2705 XWINDOW (w
->parent
)->vchild
= Qnil
;
2710 /* If we squirreled away the buffer in the window's height,
2712 if (XTYPE (w
->height
) == Lisp_Buffer
)
2713 w
->buffer
= w
->height
;
2716 w
->width
= p
->width
;
2717 w
->height
= p
->height
;
2718 w
->hscroll
= p
->hscroll
;
2719 w
->display_table
= p
->display_table
;
2720 XFASTINT (w
->last_modified
) = 0;
2722 /* Reinstall the saved buffer and pointers into it. */
2723 if (NILP (p
->buffer
))
2724 w
->buffer
= p
->buffer
;
2727 if (!NILP (XBUFFER (p
->buffer
)->name
))
2728 /* If saved buffer is alive, install it. */
2730 w
->buffer
= p
->buffer
;
2731 w
->start_at_line_beg
= p
->start_at_line_beg
;
2732 set_marker_restricted (w
->start
,
2733 Fmarker_position (p
->start
),
2735 set_marker_restricted (w
->pointm
,
2736 Fmarker_position (p
->pointm
),
2738 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2739 Fmarker_position (p
->mark
), w
->buffer
);
2741 /* As documented in Fcurrent_window_configuration, don't
2742 save the location of point in the buffer which was current
2743 when the window configuration was recorded. */
2744 if (!EQ (p
->buffer
, new_current_buffer
)
2745 && XBUFFER (p
->buffer
) == current_buffer
)
2746 Fgoto_char (w
->pointm
);
2748 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2749 /* Else unless window has a live buffer, get one. */
2751 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2752 /* This will set the markers to beginning of visible
2754 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2755 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2756 w
->start_at_line_beg
= Qt
;
2759 /* Keeping window's old buffer; make sure the markers
2762 /* Set window markers at start of visible range. */
2763 if (XMARKER (w
->start
)->buffer
== 0)
2764 set_marker_restricted (w
->start
, make_number (0),
2766 if (XMARKER (w
->pointm
)->buffer
== 0)
2767 set_marker_restricted (w
->pointm
,
2769 (BUF_PT (XBUFFER (w
->buffer
)))),
2771 w
->start_at_line_beg
= Qt
;
2776 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2777 Fselect_window (data
->current_window
);
2780 if (NILP (data
->focus_frame
)
2781 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2782 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2783 Fredirect_frame_focus (frame
, data
->focus_frame
);
2786 #if 0 /* I don't understand why this is needed, and it causes problems
2787 when the frame's old selected window has been deleted. */
2789 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2790 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2794 /* Set the screen height to the value it had before this function. */
2795 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2796 || previous_frame_width
!= FRAME_WIDTH (f
))
2797 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2799 #ifdef HAVE_X_WINDOWS
2800 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2801 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2806 /* Fselect_window will have made f the selected frame, so we
2807 reselect the proper frame here. Fhandle_switch_frame will change the
2808 selected window too, but that doesn't make the call to
2809 Fselect_window above totally superfluous; it still sets f's
2811 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2812 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2815 if (!NILP (new_current_buffer
))
2816 Fset_buffer (new_current_buffer
);
2818 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2822 /* Mark all windows now on frame as deleted
2823 by setting their buffers to nil. */
2826 delete_all_subwindows (w
)
2827 register struct window
*w
;
2829 if (!NILP (w
->next
))
2830 delete_all_subwindows (XWINDOW (w
->next
));
2831 if (!NILP (w
->vchild
))
2832 delete_all_subwindows (XWINDOW (w
->vchild
));
2833 if (!NILP (w
->hchild
))
2834 delete_all_subwindows (XWINDOW (w
->hchild
));
2836 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2838 /* We set all three of these fields to nil, to make sure that we can
2839 distinguish this dead window from any live window. Live leaf
2840 windows will have buffer set, and combination windows will have
2841 vchild or hchild set. */
2848 count_windows (window
)
2849 register struct window
*window
;
2851 register int count
= 1;
2852 if (!NILP (window
->next
))
2853 count
+= count_windows (XWINDOW (window
->next
));
2854 if (!NILP (window
->vchild
))
2855 count
+= count_windows (XWINDOW (window
->vchild
));
2856 if (!NILP (window
->hchild
))
2857 count
+= count_windows (XWINDOW (window
->hchild
));
2862 save_window_save (window
, vector
, i
)
2864 struct Lisp_Vector
*vector
;
2867 register struct saved_window
*p
;
2868 register struct window
*w
;
2869 register Lisp_Object tem
;
2871 for (;!NILP (window
); window
= w
->next
)
2873 p
= SAVED_WINDOW_N (vector
, i
);
2874 w
= XWINDOW (window
);
2876 XFASTINT (w
->temslot
) = i
++;
2878 p
->buffer
= w
->buffer
;
2881 p
->width
= w
->width
;
2882 p
->height
= w
->height
;
2883 p
->hscroll
= w
->hscroll
;
2884 p
->display_table
= w
->display_table
;
2885 if (!NILP (w
->buffer
))
2887 /* Save w's value of point in the window configuration.
2888 If w is the selected window, then get the value of point
2889 from the buffer; pointm is garbage in the selected window. */
2890 if (EQ (window
, selected_window
))
2892 p
->pointm
= Fmake_marker ();
2893 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2897 p
->pointm
= Fcopy_marker (w
->pointm
);
2899 p
->start
= Fcopy_marker (w
->start
);
2900 p
->start_at_line_beg
= w
->start_at_line_beg
;
2902 tem
= XBUFFER (w
->buffer
)->mark
;
2903 p
->mark
= Fcopy_marker (tem
);
2910 p
->start_at_line_beg
= Qnil
;
2913 if (NILP (w
->parent
))
2916 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2921 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2923 if (!NILP (w
->vchild
))
2924 i
= save_window_save (w
->vchild
, vector
, i
);
2925 if (!NILP (w
->hchild
))
2926 i
= save_window_save (w
->hchild
, vector
, i
);
2932 DEFUN ("current-window-configuration",
2933 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2934 "Return an object representing the current window configuration of FRAME.\n\
2935 If FRAME is nil or omitted, use the selected frame.\n\
2936 This describes the number of windows, their sizes and current buffers,\n\
2937 and for each displayed buffer, where display starts, and the positions of\n\
2938 point and mark. An exception is made for point in the current buffer:\n\
2939 its value is -not- saved.\n\
2940 This also records the currently selected frame, and FRAME's focus\n\
2941 redirection (see `redirect-frame-focus').")
2945 register Lisp_Object tem
;
2946 register int n_windows
;
2947 register struct save_window_data
*data
;
2955 CHECK_LIVE_FRAME (frame
, 0);
2959 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2960 data
= (struct save_window_data
*)
2961 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2963 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2964 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2965 XFASTINT (data
->frame_menu_bar_lines
) = FRAME_MENU_BAR_LINES (f
);
2967 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2969 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2970 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2971 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2972 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2973 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2974 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2975 data
->saved_windows
= tem
;
2976 for (i
= 0; i
< n_windows
; i
++)
2977 XVECTOR (tem
)->contents
[i
]
2978 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2979 save_window_save (FRAME_ROOT_WINDOW (f
),
2981 XSET (tem
, Lisp_Window_Configuration
, data
);
2985 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2987 "Execute body, preserving window sizes and contents.\n\
2988 Restore which buffer appears in which window, where display starts,\n\
2989 and the value of point and mark for each window.\n\
2990 Also restore which buffer is current.\n\
2991 But do not preserve point in the current buffer.\n\
2992 Does not restore the value of point in current buffer.")
2996 register Lisp_Object val
;
2997 register int count
= specpdl_ptr
- specpdl
;
2999 record_unwind_protect (Fset_window_configuration
,
3000 Fcurrent_window_configuration (Qnil
));
3001 val
= Fprogn (args
);
3002 return unbind_to (count
, val
);
3008 selected_frame
= make_terminal_frame ();
3009 minibuf_window
= selected_frame
->minibuffer_window
;
3010 selected_window
= selected_frame
->selected_window
;
3011 last_nonminibuf_frame
= selected_frame
;
3012 #else /* not MULTI_FRAME */
3013 extern Lisp_Object
get_minibuffer ();
3015 minibuf_window
= make_window ();
3016 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3018 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3019 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3020 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3022 /* These values 9 and 10 are arbitrary,
3023 just so that there is "something there."
3024 Correct values are put in in init_xdisp */
3026 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
3027 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
3029 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
3030 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
3031 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
3033 /* Prevent error in Fset_window_buffer. */
3034 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3035 XWINDOW (minibuf_window
)->buffer
= Qt
;
3037 /* Now set them up for real. */
3038 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3039 Fcurrent_buffer ());
3040 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3042 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3043 /* Make sure this window seems more recently used than
3044 a newly-created, never-selected window. Increment
3045 window_select_count so the first selection ever will get
3046 something newer than this. */
3047 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
3048 #endif /* not MULTI_FRAME */
3053 Qwindowp
= intern ("windowp");
3054 staticpro (&Qwindowp
);
3056 Qwindow_live_p
= intern ("window-live-p");
3057 staticpro (&Qwindow_live_p
);
3060 /* Make sure all windows get marked */
3061 staticpro (&minibuf_window
);
3064 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3065 "Non-nil means call as function to display a help buffer.\n\
3066 Used by `with-output-to-temp-buffer'.");
3067 Vtemp_buffer_show_function
= Qnil
;
3069 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3070 "If non-nil, function to call to handle `display-buffer'.\n\
3071 It will receive two args, the buffer and a flag which if non-nil means\n\
3072 that the currently selected window is not acceptable.\n\
3073 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3074 work using this function.");
3075 Vdisplay_buffer_function
= Qnil
;
3077 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3078 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3079 Vminibuf_scroll_window
= Qnil
;
3081 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3082 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3083 Vother_window_scroll_buffer
= Qnil
;
3085 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3086 "*Non-nil means `display-buffer' should make a separate frame.");
3089 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3090 "Function to call to handle automatic new frame creation.\n\
3091 It is called with no arguments and should return a newly created frame.\n\
3093 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3094 where `pop-up-frame-alist' would hold the default frame parameters.");
3095 Vpop_up_frame_function
= Qnil
;
3097 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3098 "*List of buffer names that should have their own special frames.\n\
3099 Displaying a buffer whose name is in this list makes a special frame for it\n\
3100 using `special-display-function'. See also `special-display-regexps'.");
3101 Vspecial_display_buffer_names
= Qnil
;
3103 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3104 "*List of regexps saying which buffers should have their own special frames.\n\
3105 If a buffer name matches one of these regexps, it gets its own frame.\n\
3106 Displaying a buffer whose name is in this list makes a special frame for it\n\
3107 using `special-display-function'. See also `special-display-buffer-names'.");
3108 Vspecial_display_regexps
= Qnil
;
3110 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3111 "Function to call to make a new frame for a special buffer.\n\
3112 It is called with one argument, the buffer,\n\
3113 and should return a window displaying that buffer.\n\
3114 The default value makes a separate frame for the buffer,\n\
3115 using `special-display-alist' to specify the frame parameters.\n\
3117 A buffer is special if its is listed in `special-display-buffer-names'\n\
3118 or matches a regexp in `special-display-regexps'.");
3119 Vspecial_display_function
= Qnil
;
3121 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3122 "*Non-nil means display-buffer should make new windows.");
3125 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3126 "*Number of lines of continuity when scrolling by screenfuls.");
3127 next_screen_context_lines
= 2;
3129 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3130 "*display-buffer would prefer to split the largest window if this large.\n\
3131 If there is only one window, it is split regardless of this value.");
3132 split_height_threshold
= 500;
3134 DEFVAR_INT ("window-min-height", &window_min_height
,
3135 "*Delete any window less than this tall (including its mode line).");
3136 window_min_height
= 4;
3138 DEFVAR_INT ("window-min-width", &window_min_width
,
3139 "*Delete any window less than this wide.");
3140 window_min_width
= 10;
3142 defsubr (&Sselected_window
);
3143 defsubr (&Sminibuffer_window
);
3144 defsubr (&Swindow_minibuffer_p
);
3145 defsubr (&Swindowp
);
3146 defsubr (&Swindow_live_p
);
3147 defsubr (&Spos_visible_in_window_p
);
3148 defsubr (&Swindow_buffer
);
3149 defsubr (&Swindow_height
);
3150 defsubr (&Swindow_width
);
3151 defsubr (&Swindow_hscroll
);
3152 defsubr (&Sset_window_hscroll
);
3153 defsubr (&Swindow_edges
);
3154 defsubr (&Scoordinates_in_window_p
);
3155 defsubr (&Swindow_at
);
3156 defsubr (&Swindow_point
);
3157 defsubr (&Swindow_start
);
3158 defsubr (&Swindow_end
);
3159 defsubr (&Sset_window_point
);
3160 defsubr (&Sset_window_start
);
3161 defsubr (&Swindow_dedicated_p
);
3162 defsubr (&Sset_window_dedicated_p
);
3163 defsubr (&Swindow_display_table
);
3164 defsubr (&Sset_window_display_table
);
3165 defsubr (&Snext_window
);
3166 defsubr (&Sprevious_window
);
3167 defsubr (&Sother_window
);
3168 defsubr (&Sget_lru_window
);
3169 defsubr (&Sget_largest_window
);
3170 defsubr (&Sget_buffer_window
);
3171 defsubr (&Sdelete_other_windows
);
3172 defsubr (&Sdelete_windows_on
);
3173 defsubr (&Sreplace_buffer_in_windows
);
3174 defsubr (&Sdelete_window
);
3175 defsubr (&Sset_window_buffer
);
3176 defsubr (&Sselect_window
);
3177 defsubr (&Sdisplay_buffer
);
3178 defsubr (&Ssplit_window
);
3179 defsubr (&Senlarge_window
);
3180 defsubr (&Sshrink_window
);
3181 defsubr (&Sscroll_up
);
3182 defsubr (&Sscroll_down
);
3183 defsubr (&Sscroll_left
);
3184 defsubr (&Sscroll_right
);
3185 defsubr (&Sother_window_for_scrolling
);
3186 defsubr (&Sscroll_other_window
);
3187 defsubr (&Srecenter
);
3188 defsubr (&Smove_to_window_line
);
3189 defsubr (&Swindow_configuration_p
);
3190 defsubr (&Sset_window_configuration
);
3191 defsubr (&Scurrent_window_configuration
);
3192 defsubr (&Ssave_window_excursion
);
3197 initial_define_key (control_x_map
, '1', "delete-other-windows");
3198 initial_define_key (control_x_map
, '2', "split-window");
3199 initial_define_key (control_x_map
, '0', "delete-window");
3200 initial_define_key (control_x_map
, 'o', "other-window");
3201 initial_define_key (control_x_map
, '^', "enlarge-window");
3202 initial_define_key (control_x_map
, '<', "scroll-left");
3203 initial_define_key (control_x_map
, '>', "scroll-right");
3205 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3206 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3207 initial_define_key (meta_map
, 'v', "scroll-down");
3209 initial_define_key (global_map
, Ctl('L'), "recenter");
3210 initial_define_key (meta_map
, 'r', "move-to-window-line");