1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993 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 /* Fdisplay_buffer always splits the largest window
83 if that window is more than this high. */
84 int split_height_threshold
;
86 /* Number of lines of continuity in scrolling by screenfuls. */
87 int next_screen_context_lines
;
89 /* Incremented for each window created. */
90 static int sequence_number
;
92 #define min(a, b) ((a) < (b) ? (a) : (b))
94 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
95 "Returns t if OBJ is a window.")
99 return XTYPE (obj
) == Lisp_Window
? Qt
: Qnil
;
102 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
103 "Returns t if OBJ is a window which is currently visible.")
107 return ((XTYPE (obj
) == Lisp_Window
108 && ! NILP (XWINDOW (obj
)->buffer
))
115 register Lisp_Object val
;
116 register struct window
*p
;
118 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector)
119 includes the first element. */
121 make_number ((sizeof (struct window
) - sizeof (struct Lisp_Vector
)
122 + sizeof (Lisp_Object
))
123 / sizeof (Lisp_Object
)),
125 XSETTYPE (val
, Lisp_Window
);
127 XFASTINT (p
->sequence_number
) = ++sequence_number
;
128 XFASTINT (p
->left
) = XFASTINT (p
->top
)
129 = XFASTINT (p
->height
) = XFASTINT (p
->width
)
130 = XFASTINT (p
->hscroll
) = 0;
131 XFASTINT (p
->last_point_x
) = XFASTINT (p
->last_point_y
) = 0;
132 p
->start
= Fmake_marker ();
133 p
->pointm
= Fmake_marker ();
134 XFASTINT (p
->use_time
) = 0;
136 p
->display_table
= Qnil
;
141 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
142 "Return the window that the cursor now appears in and commands apply to.")
145 return selected_window
;
148 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
149 "Return the window used now for minibuffers.\n\
150 If the optional argument FRAME is specified, return the minibuffer window\n\
151 used by that frame.")
157 XSET (frame
, Lisp_Frame
, selected_frame
);
159 CHECK_LIVE_FRAME (frame
, 0);
162 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
165 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
166 "Returns non-nil if WINDOW is a minibuffer window.")
170 struct window
*w
= decode_window (window
);
171 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
174 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
175 Spos_visible_in_window_p
, 0, 2, 0,
176 "Return t if position POS is currently on the frame in WINDOW.\n\
177 Returns nil if that position is scrolled vertically out of view.\n\
178 POS defaults to point; WINDOW, to the selected window.")
180 Lisp_Object pos
, window
;
182 register struct window
*w
;
186 register struct buffer
*buf
;
187 struct position posval
;
193 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
197 w
= decode_window (window
);
198 top
= marker_position (w
->start
);
203 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
205 buf
= XBUFFER (w
->buffer
);
206 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
208 /* If frame is up to date,
209 use the info recorded about how much text fit on it. */
210 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
211 || (XFASTINT (w
->window_end_vpos
) < height
))
217 if (posint
> BUF_Z (buf
))
220 /* If that info is not correct, calculate afresh */
221 posval
= *compute_motion (top
, 0, 0, posint
, height
, 0,
222 window_internal_width (w
) - 1,
223 XINT (w
->hscroll
), 0);
225 return posval
.vpos
< height
? Qt
: Qnil
;
229 static struct window
*
230 decode_window (window
)
231 register Lisp_Object window
;
234 return XWINDOW (selected_window
);
236 CHECK_LIVE_WINDOW (window
, 0);
237 return XWINDOW (window
);
240 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
241 "Return the buffer that WINDOW is displaying.")
245 return decode_window (window
)->buffer
;
248 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
249 "Return the number of lines in WINDOW (including its mode line).")
253 return decode_window (window
)->height
;
256 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
257 "Return the number of columns in WINDOW.")
261 register struct window
*w
= decode_window (window
);
262 register int width
= XFASTINT (w
->width
);
264 return make_number (window_internal_width (w
));
267 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
268 "Return the number of columns by which WINDOW is scrolled from left margin.")
272 return decode_window (window
)->hscroll
;
275 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
276 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
277 NCOL should be zero or positive.")
279 register Lisp_Object window
, ncol
;
281 register struct window
*w
;
283 CHECK_NUMBER (ncol
, 1);
284 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
285 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
286 args_out_of_range (ncol
, Qnil
);
287 w
= decode_window (window
);
288 if (XINT (w
->hscroll
) != XINT (ncol
))
289 clip_changed
= 1; /* Prevent redisplay shortcuts */
294 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
295 "Return a list of the edge coordinates of WINDOW.\n\
296 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
297 RIGHT is one more than the rightmost column used by WINDOW,\n\
298 and BOTTOM is one more than the bottommost row used by WINDOW\n\
303 register struct window
*w
= decode_window (window
);
305 return Fcons (w
->left
, Fcons (w
->top
,
306 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
307 Fcons (make_number (XFASTINT (w
->top
)
308 + XFASTINT (w
->height
)),
312 /* Test if the character at column *x, row *y is within window *w.
313 If it is not, return 0;
314 if it is in the window's text area,
315 set *x and *y to its location relative to the upper left corner
318 if it is on the window's modeline, return 2;
319 if it is on the border between the window and its right sibling,
322 coordinates_in_window (w
, x
, y
)
323 register struct window
*w
;
326 register int left
= XINT (w
->left
);
327 register int width
= XINT (w
->width
);
328 register int window_height
= XINT (w
->height
);
329 register int top
= XFASTINT (w
->top
);
331 if ( *x
< left
|| *x
>= left
+ width
332 || *y
< top
|| *y
>= top
+ window_height
)
335 /* Is the character is the mode line? */
336 if (*y
== top
+ window_height
- 1
337 && ! MINI_WINDOW_P (w
))
340 /* Is the character in the right border? */
341 if (*x
== left
+ width
- 1
342 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
350 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
351 Scoordinates_in_window_p
, 2, 2, 0,
352 "Return non-nil if COORDINATES are in WINDOW.\n\
353 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
354 measured in characters from the upper-left corner of the frame.\n\
355 (0 . 0) denotes the character in the upper left corner of the\n\
357 If COORDINATES are in the text portion of WINDOW,\n\
358 the coordinates relative to the window are returned.\n\
359 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
360 If they are on the border between WINDOW and its right sibling,\n\
361 `vertical-line' is returned.")
362 (coordinates
, window
)
363 register Lisp_Object coordinates
, window
;
367 CHECK_LIVE_WINDOW (window
, 0);
368 CHECK_CONS (coordinates
, 1);
369 x
= XINT (Fcar (coordinates
));
370 y
= XINT (Fcdr (coordinates
));
372 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
374 case 0: /* NOT in window at all. */
377 case 1: /* In text part of window. */
380 case 2: /* In mode line of window. */
383 case 3: /* On right border of window. */
384 return Qvertical_line
;
391 /* Find the window containing column x, row y, and return it as a
392 Lisp_Object. If x, y is on the window's modeline, set *part
393 to 1; if it is on the separating line between the window and its
394 right sibling, set it to 2; otherwise set it to 0. If there is no
395 window under x, y return nil and leave *part unmodified. */
397 window_from_coordinates (frame
, x
, y
, part
)
402 register Lisp_Object tem
, first
;
404 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
408 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
416 tem
= Fnext_window (tem
, Qt
, Qlambda
);
418 while (! EQ (tem
, first
));
423 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
424 "Return window containing coordinates X and Y on FRAME.\n\
425 If omitted, FRAME defaults to the currently selected frame.\n\
426 The top left corner of the frame is considered to be row 0,\n\
429 Lisp_Object x
, y
, frame
;
435 XSET (frame
, Lisp_Frame
, selected_frame
);
437 CHECK_LIVE_FRAME (frame
, 2);
442 return window_from_coordinates (XFRAME (frame
),
447 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
448 "Return current value of point in WINDOW.\n\
449 For a nonselected window, this is the value point would have\n\
450 if that window were selected.\n\
452 Note that, when WINDOW is the selected window and its buffer\n\
453 is also currently selected, the value returned is the same as (point).\n\
454 It would be more strictly correct to return the `top-level' value\n\
455 of point, outside of any save-excursion forms.\n\
456 But that is hard to define.")
460 register struct window
*w
= decode_window (window
);
462 if (w
== XWINDOW (selected_window
)
463 && current_buffer
== XBUFFER (w
->buffer
))
465 return Fmarker_position (w
->pointm
);
468 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
469 "Return position at which display currently starts in WINDOW.")
473 return Fmarker_position (decode_window (window
)->start
);
476 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
477 "Return position at which display currently ends in WINDOW.")
482 struct window
*w
= decode_window (window
);
486 CHECK_BUFFER (buf
, 0);
488 XSET (value
, Lisp_Int
,
489 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
494 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
495 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
497 Lisp_Object window
, pos
;
499 register struct window
*w
= decode_window (window
);
501 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
502 if (w
== XWINDOW (selected_window
))
505 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
510 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
511 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
512 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
513 from overriding motion of point in order to display at this exact start.")
514 (window
, pos
, noforce
)
515 Lisp_Object window
, pos
, noforce
;
517 register struct window
*w
= decode_window (window
);
519 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
520 set_marker_restricted (w
->start
, pos
, w
->buffer
);
521 /* this is not right, but much easier than doing what is right. */
522 w
->start_at_line_beg
= Qnil
;
525 w
->update_mode_line
= Qt
;
526 XFASTINT (w
->last_modified
) = 0;
527 if (!EQ (window
, selected_window
))
528 windows_or_buffers_changed
++;
532 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
534 "Return WINDOW's dedicated object, usually t or nil.\n\
535 See also `set-window-dedicated-p'.")
539 return decode_window (window
)->dedicated
;
542 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
543 Sset_window_dedicated_p
, 2, 2, 0,
544 "Control whether WINDOW is dedicated to the buffer it displays.\n\
545 If it is dedicated, Emacs will not automatically change\n\
546 which buffer appears in it.\n\
547 The second argument is the new value for the dedication flag;\n\
550 Lisp_Object window
, arg
;
552 register struct window
*w
= decode_window (window
);
562 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
564 "Return the display-table that WINDOW is using.")
568 return decode_window (window
)->display_table
;
571 /* Get the display table for use currently on window W.
572 This is either W's display table or W's buffer's display table.
573 Ignore the specified tables if they are not valid;
574 if no valid table is specified, return 0. */
577 window_display_table (w
)
581 tem
= w
->display_table
;
582 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
583 return XVECTOR (tem
);
584 tem
= XBUFFER (w
->buffer
)->display_table
;
585 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
586 return XVECTOR (tem
);
587 tem
= Vstandard_display_table
;
588 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
589 return XVECTOR (tem
);
593 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
594 "Set WINDOW's display-table to TABLE.")
596 register Lisp_Object window
, table
;
598 register struct window
*w
;
599 register Lisp_Object z
; /* Return value. */
601 w
= decode_window (window
);
602 w
->display_table
= table
;
606 /* Record info on buffer window w is displaying
607 when it is about to cease to display that buffer. */
610 register struct window
*w
;
612 Lisp_Object buf
= w
->buffer
;
614 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
617 if (w
== XWINDOW (selected_window
)
618 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
619 /* Do this except when the selected window's buffer
620 is being removed from some other window. */
621 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
623 /* Point in the selected window's buffer
624 is actually stored in that buffer, and the window's pointm isn't used.
625 So don't clobber point in that buffer. */
626 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
627 BUF_PT (XBUFFER (buf
))
628 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
629 marker_position (w
->pointm
),
630 BUF_ZV (XBUFFER (buf
)));
633 /* Put replacement into the window structure in place of old. */
635 replace_window (old
, replacement
)
636 Lisp_Object old
, replacement
;
638 register Lisp_Object tem
;
639 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
641 /* If OLD is its frame's root_window, then replacement is the new
642 root_window for that frame. */
644 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
645 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
650 p
->height
= o
->height
;
652 p
->next
= tem
= o
->next
;
654 XWINDOW (tem
)->prev
= replacement
;
656 p
->prev
= tem
= o
->prev
;
658 XWINDOW (tem
)->next
= replacement
;
660 p
->parent
= tem
= o
->parent
;
663 if (EQ (XWINDOW (tem
)->vchild
, old
))
664 XWINDOW (tem
)->vchild
= replacement
;
665 if (EQ (XWINDOW (tem
)->hchild
, old
))
666 XWINDOW (tem
)->hchild
= replacement
;
669 /*** Here, if replacement is a vertical combination
670 and so is its new parent, we should make replacement's
671 children be children of that parent instead. ***/
674 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
675 "Remove WINDOW from the display. Default is selected window.")
677 register Lisp_Object window
;
679 register Lisp_Object tem
, parent
, sib
;
680 register struct window
*p
;
681 register struct window
*par
;
683 /* Because this function is called by other C code on non-leaf
684 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
685 so we can't decode_window here. */
687 window
= selected_window
;
689 CHECK_WINDOW (window
, 0);
690 p
= XWINDOW (window
);
692 /* It's okay to delete an already-deleted window. */
700 error ("Attempt to delete minibuffer or sole ordinary window");
701 par
= XWINDOW (parent
);
703 windows_or_buffers_changed
++;
705 /* Are we trying to delete any frame's selected window? */
707 Lisp_Object frame
, pwindow
;
709 /* See if the frame's selected window is either WINDOW
710 or any subwindow of it, by finding all that window's parents
711 and comparing each one with WINDOW. */
712 frame
= WINDOW_FRAME (XWINDOW (window
));
713 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
715 while (!NILP (pwindow
))
717 if (EQ (window
, pwindow
))
719 pwindow
= XWINDOW (pwindow
)->parent
;
722 if (EQ (window
, pwindow
))
724 Lisp_Object alternative
= Fnext_window (window
, Qlambda
, Qnil
);
726 /* If we're about to delete the selected window on the
727 selected frame, then we should use Fselect_window to select
728 the new window. On the other hand, if we're about to
729 delete the selected window on any other frame, we shouldn't do
730 anything but set the frame's selected_window slot. */
731 if (EQ (window
, selected_window
))
732 Fselect_window (alternative
);
734 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
739 /* tem is null for dummy parent windows
740 (which have inferiors but not any contents themselves) */
744 unchain_marker (p
->pointm
);
745 unchain_marker (p
->start
);
750 XWINDOW (tem
)->prev
= p
->prev
;
754 XWINDOW (tem
)->next
= p
->next
;
756 if (EQ (window
, par
->hchild
))
757 par
->hchild
= p
->next
;
758 if (EQ (window
, par
->vchild
))
759 par
->vchild
= p
->next
;
761 /* Find one of our siblings to give our space to. */
765 /* If p gives its space to its next sibling, that sibling needs
766 to have its top/left side pulled back to where p's is.
767 set_window_{height,width} will re-position the sibling's
770 XWINDOW (sib
)->top
= p
->top
;
771 XWINDOW (sib
)->left
= p
->left
;
774 /* Stretch that sibling. */
775 if (!NILP (par
->vchild
))
776 set_window_height (sib
,
777 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
779 if (!NILP (par
->hchild
))
780 set_window_width (sib
,
781 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
784 /* If parent now has only one child,
785 put the child into the parent's place. */
789 if (NILP (XWINDOW (tem
)->next
))
790 replace_window (parent
, tem
);
792 /* Since we may be deleting combination windows, we must make sure that
793 not only p but all its children have been marked as deleted. */
794 if (! NILP (p
->hchild
))
795 delete_all_subwindows (XWINDOW (p
->hchild
));
796 else if (! NILP (p
->vchild
))
797 delete_all_subwindows (XWINDOW (p
->vchild
));
799 /* Mark this window as deleted. */
800 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
806 extern Lisp_Object
next_frame (), prev_frame ();
808 /* This comment supplies the doc string for `next-window',
809 for make-docfile to see. We cannot put this in the real DEFUN
810 due to limits in the Unix cpp.
812 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
813 "Return next window after WINDOW in canonical ordering of windows.\n\
814 If omitted, WINDOW defaults to the selected window.\n\
816 Optional second arg MINIBUF t means count the minibuffer window even\n\
817 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
818 it is active. MINIBUF neither t nor nil means not to count the\n\
819 minibuffer even if it is active.\n\
821 Several frames may share a single minibuffer; if the minibuffer\n\
822 counts, all windows on all frames that share that minibuffer count\n\
823 too. This means that next-window may be used to iterate through the\n\
824 set of windows even when the minibuffer is on another frame. If the\n\
825 minibuffer does not count, only windows from WINDOW's frame count.\n\
827 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
828 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
829 above. If neither nil nor t, restrict to WINDOW's frame.\n\
831 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
832 `next-window' to iterate through the entire cycle of acceptable\n\
833 windows, eventually ending up back at the window you started with.\n\
834 `previous-window' traverses the same cycle, in the reverse order.")
835 (window, minibuf, all_frames) */
837 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
839 (window
, minibuf
, all_frames
)
840 register Lisp_Object window
, minibuf
, all_frames
;
842 register Lisp_Object tem
;
843 Lisp_Object start_window
;
846 window
= selected_window
;
848 CHECK_LIVE_WINDOW (window
, 0);
850 start_window
= window
;
852 /* minibuf == nil may or may not include minibuffers.
853 Decide if it does. */
855 minibuf
= (minibuf_level
? Qt
: Qlambda
);
857 /* all_frames == nil doesn't specify which frames to include.
858 Decide which frames it includes. */
859 if (NILP (all_frames
))
860 all_frames
= (EQ (minibuf
, Qt
)
861 ? (FRAME_MINIBUF_WINDOW
864 (XWINDOW (window
)))))
866 else if (! EQ (all_frames
, Qt
))
868 /* Now all_frames is t meaning search all frames,
869 nil meaning search just current frame,
870 or a window, meaning search the frame that window belongs to. */
872 /* Do this loop at least once, to get the next window, and perhaps
873 again, if we hit the minibuffer and that is not acceptable. */
876 /* Find a window that actually has a next one. This loop
877 climbs up the tree. */
878 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
879 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
883 /* We've reached the end of this frame.
884 Which other frames are acceptable? */
885 tem
= WINDOW_FRAME (XWINDOW (window
));
887 if (! NILP (all_frames
))
888 tem
= next_frame (tem
, all_frames
);
890 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
897 /* If we're in a combination window, find its first child and
898 recurse on that. Otherwise, we've found the window we want. */
901 if (!NILP (XWINDOW (window
)->hchild
))
902 window
= XWINDOW (window
)->hchild
;
903 else if (!NILP (XWINDOW (window
)->vchild
))
904 window
= XWINDOW (window
)->vchild
;
908 /* Which windows are acceptible?
909 Exit the loop and accept this window if
910 this isn't a minibuffer window, or
911 we're accepting minibuffer windows, or
912 we've come all the way around and we're back at the original window. */
913 while (MINI_WINDOW_P (XWINDOW (window
))
914 && ! EQ (minibuf
, Qt
)
915 && ! EQ (window
, start_window
));
920 /* This comment supplies the doc string for `previous-window',
921 for make-docfile to see. We cannot put this in the real DEFUN
922 due to limits in the Unix cpp.
924 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
925 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
926 If omitted, WINDOW defaults to the selected window.\n\
928 Optional second arg MINIBUF t means count the minibuffer window even\n\
929 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
930 it is active. MINIBUF neither t nor nil means not to count the\n\
931 minibuffer even if it is active.\n\
933 Several frames may share a single minibuffer; if the minibuffer\n\
934 counts, all windows on all frames that share that minibuffer count\n\
935 too. This means that previous-window may be used to iterate through\n\
936 the set of windows even when the minibuffer is on another frame. If\n\
937 the minibuffer does not count, only windows from WINDOW's frame\n\
940 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
941 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
942 above. If neither nil nor t, restrict to WINDOW's frame.\n\
944 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
945 `previous-window' to iterate through the entire cycle of acceptable\n\
946 windows, eventually ending up back at the window you started with.\n\
947 `next-window' traverses the same cycle, in the reverse order.")
948 (window, minibuf, all_frames) */
951 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
953 (window
, minibuf
, all_frames
)
954 register Lisp_Object window
, minibuf
, all_frames
;
956 register Lisp_Object tem
;
957 Lisp_Object start_window
;
960 window
= selected_window
;
962 CHECK_LIVE_WINDOW (window
, 0);
964 start_window
= window
;
966 /* minibuf == nil may or may not include minibuffers.
967 Decide if it does. */
969 minibuf
= (minibuf_level
? Qt
: Qlambda
);
971 /* all_frames == nil doesn't specify which frames to include.
972 Decide which frames it includes. */
973 if (NILP (all_frames
))
974 all_frames
= (EQ (minibuf
, Qt
)
975 ? (FRAME_MINIBUF_WINDOW
978 (XWINDOW (window
)))))
980 else if (! EQ (all_frames
, Qt
))
982 /* Now all_frames is t meaning search all frames,
983 nil meaning search just current frame,
984 or a window, meaning search the frame that window belongs to. */
986 /* Do this loop at least once, to get the previous window, and perhaps
987 again, if we hit the minibuffer and that is not acceptable. */
990 /* Find a window that actually has a previous one. This loop
991 climbs up the tree. */
992 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
993 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
997 /* We have found the top window on the frame.
998 Which frames are acceptable? */
999 tem
= WINDOW_FRAME (XWINDOW (window
));
1001 if (! NILP (all_frames
))
1002 /* It's actually important that we use prev_frame here,
1003 rather than next_frame. All the windows acceptable
1004 according to the given parameters should form a ring;
1005 Fnext_window and Fprevious_window should go back and
1006 forth around the ring. If we use next_frame here,
1007 then Fnext_window and Fprevious_window take different
1008 paths through the set of acceptable windows.
1009 window_loop assumes that these `ring' requirement are
1011 tem
= prev_frame (tem
, all_frames
);
1013 /* If this frame has a minibuffer, find that window first,
1014 because it is conceptually the last window in that frame. */
1015 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1016 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1018 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1024 /* If we're in a combination window, find its last child and
1025 recurse on that. Otherwise, we've found the window we want. */
1028 if (!NILP (XWINDOW (window
)->hchild
))
1029 window
= XWINDOW (window
)->hchild
;
1030 else if (!NILP (XWINDOW (window
)->vchild
))
1031 window
= XWINDOW (window
)->vchild
;
1033 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1037 /* Which windows are acceptable?
1038 Exit the loop and accept this window if
1039 this isn't a minibuffer window, or
1040 we're accepting minibuffer windows, or
1041 we've come all the way around and we're back at the original window. */
1042 while (MINI_WINDOW_P (XWINDOW (window
))
1043 && !EQ (minibuf
, Qt
)
1044 && !EQ (window
, start_window
));
1049 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1050 "Select the ARG'th different window on this frame.\n\
1051 All windows on current frame are arranged in a cyclic order.\n\
1052 This command selects the window ARG steps away in that order.\n\
1053 A negative ARG moves in the opposite order. If the optional second\n\
1054 argument ALL_FRAMES is non-nil, cycle through all frames.")
1056 register Lisp_Object n
, all_frames
;
1059 register Lisp_Object w
;
1061 CHECK_NUMBER (n
, 0);
1062 w
= selected_window
;
1067 w
= Fnext_window (w
, Qnil
, all_frames
);
1072 w
= Fprevious_window (w
, Qnil
, all_frames
);
1079 /* Look at all windows, performing an operation specified by TYPE
1081 If FRAMES is Qt, look at all frames;
1082 Qnil, look at just the selected frame;
1083 a frame, just look at windows on that frame.
1084 If MINI is non-zero, perform the operation on minibuffer windows too.
1090 GET_BUFFER_WINDOW
, /* Arg is buffer */
1091 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1092 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1093 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1095 UNSHOW_BUFFER
/* Arg is buffer */
1099 window_loop (type
, obj
, mini
, frames
)
1100 enum window_loop type
;
1101 register Lisp_Object obj
, frames
;
1104 register Lisp_Object w
;
1105 register Lisp_Object best_window
;
1106 register Lisp_Object next_window
;
1107 register Lisp_Object last_window
;
1111 /* If we're only looping through windows on a particular frame,
1112 frame points to that frame. If we're looping through windows
1113 on all frames, frame is 0. */
1114 if (FRAMEP (frames
))
1115 frame
= XFRAME (frames
);
1116 else if (NILP (frames
))
1117 frame
= selected_frame
;
1124 /* Pick a window to start with. */
1125 if (XTYPE (obj
) == Lisp_Window
)
1128 w
= FRAME_SELECTED_WINDOW (frame
);
1130 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1132 /* Figure out the last window we're going to mess with. Since
1133 Fnext_window, given the same options, is guaranteed to go in a
1134 ring, we can just use Fprevious_window to find the last one.
1136 We can't just wait until we hit the first window again, because
1137 it might be deleted. */
1141 last_window
= Fprevious_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1143 #endif /* MULTI_FRAME */
1144 /* We know frame is 0, so we're looping through all frames.
1145 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1146 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, Qt
);
1151 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1153 /* Pick the next window now, since some operations will delete
1154 the current window. */
1157 next_window
= Fnext_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1159 #endif /* MULTI_FRAME */
1160 /* We know frame is 0, so we're looping through all frames.
1161 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1162 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, Qt
);
1164 if (! MINI_WINDOW_P (XWINDOW (w
))
1165 || (mini
&& minibuf_level
> 0))
1168 case GET_BUFFER_WINDOW
:
1169 /* Ignore invisible and iconified frames. */
1170 if (! FRAME_VISIBLE_P (w_frame
)
1171 || FRAME_ICONIFIED_P (w_frame
))
1173 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1177 case GET_LRU_WINDOW
:
1178 /* t as arg means consider only full-width windows */
1179 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1180 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1183 /* Ignore invisible and iconified frames. */
1184 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1185 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1188 /* Ignore dedicated windows and minibuffers. */
1189 if (MINI_WINDOW_P (XWINDOW (w
))
1190 || !NILP (XWINDOW (w
)->dedicated
))
1192 if (NILP (best_window
)
1193 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1194 > XFASTINT (XWINDOW (w
)->use_time
)))
1198 case DELETE_OTHER_WINDOWS
:
1199 if (XWINDOW (w
) != XWINDOW (obj
))
1203 case DELETE_BUFFER_WINDOWS
:
1204 if (EQ (XWINDOW (w
)->buffer
, obj
))
1206 /* If we're deleting the buffer displayed in the only window
1207 on the frame, find a new buffer to display there. */
1208 if (NILP (XWINDOW (w
)->parent
))
1210 Lisp_Object new_buffer
= Fother_buffer (obj
, Qnil
);
1211 if (NILP (new_buffer
))
1213 = Fget_buffer_create (build_string ("*scratch*"));
1214 Fset_window_buffer (w
, new_buffer
);
1215 if (EQ (w
, selected_window
))
1216 Fset_buffer (XWINDOW (w
)->buffer
);
1223 case GET_LARGEST_WINDOW
:
1225 /* Ignore invisible and iconified frames. */
1226 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1227 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1230 /* Ignore dedicated windows and minibuffers. */
1231 if (MINI_WINDOW_P (XWINDOW (w
))
1232 || !NILP (XWINDOW (w
)->dedicated
))
1235 struct window
*best_window_ptr
= XWINDOW (best_window
);
1236 struct window
*w_ptr
= XWINDOW (w
);
1237 if (NILP (best_window
) ||
1238 (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
))
1239 > (XFASTINT (best_window_ptr
->height
)
1240 * XFASTINT (best_window_ptr
->width
)))
1246 if (EQ (XWINDOW (w
)->buffer
, obj
))
1248 /* Find another buffer to show in this window. */
1249 Lisp_Object another_buffer
= Fother_buffer (obj
, Qnil
);
1250 if (NILP (another_buffer
))
1252 = Fget_buffer_create (build_string ("*scratch*"));
1253 Fset_window_buffer (w
, another_buffer
);
1254 if (EQ (w
, selected_window
))
1255 Fset_buffer (XWINDOW (w
)->buffer
);
1260 if (EQ (w
, last_window
))
1269 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1270 "Return the window least recently selected or used for display.\n\
1271 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1272 frame, search only that frame.\n")
1276 register Lisp_Object w
;
1277 /* First try for a window that is full-width */
1278 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frames
);
1279 if (!NILP (w
) && !EQ (w
, selected_window
))
1281 /* If none of them, try the rest */
1282 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frames
);
1285 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1286 "Return the largest window in area.\n\
1287 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1288 frame, search only that frame.\n")
1292 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1296 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1297 "Return a window currently displaying BUFFER, or nil if none.\n\
1298 If optional argument FRAME is t, search all visible frames.\n\
1299 If FRAME is nil, search only the selected frame.\n\
1300 If FRAME is a frame, search only that frame.\n")
1302 Lisp_Object buffer
, frame
;
1304 buffer
= Fget_buffer (buffer
);
1305 if (XTYPE (buffer
) == Lisp_Buffer
)
1306 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1311 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1313 "Make WINDOW (or the selected window) fill its frame.\n\
1314 Only the frame WINDOW is on is affected.\n\
1315 This function tries to reduce display jumps\n\
1316 by keeping the text previously visible in WINDOW\n\
1317 in the same place on the frame. Doing this depends on\n\
1318 the value of (window-start WINDOW), so if calling this function\n\
1319 in a program gives strange scrolling, make sure the window-start\n\
1320 value is reasonable when this function is called.")
1325 struct buffer
*obuf
= current_buffer
;
1330 window
= selected_window
;
1332 CHECK_LIVE_WINDOW (window
, 0);
1334 w
= XWINDOW (window
);
1335 top
= XFASTINT (w
->top
);
1337 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1339 Fset_buffer (w
->buffer
);
1341 SET_PT (marker_position (w
->start
));
1342 Frecenter (make_number (top
- FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)))));
1345 set_buffer_internal (obuf
);
1349 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1350 1, 2, "bDelete windows on (buffer): ",
1351 "Delete all windows showing BUFFER.\n\
1352 Optional second argument FRAME controls which frames are affected.\n\
1353 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1354 If t, delete only windows showing BUFFER in the selected frame.\n\
1355 If a frame, delete only windows showing BUFFER in that frame.")
1357 Lisp_Object buffer
, frame
;
1360 /* FRAME uses t and nil to mean the opposite of what window_loop
1362 if (! FRAMEP (frame
))
1363 frame
= NILP (frame
) ? Qt
: Qnil
;
1370 buffer
= Fget_buffer (buffer
);
1371 CHECK_BUFFER (buffer
, 0);
1372 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1377 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1378 Sreplace_buffer_in_windows
,
1379 1, 1, "bReplace buffer in windows: ",
1380 "Replace BUFFER with some other buffer in all windows showing it.")
1386 buffer
= Fget_buffer (buffer
);
1387 CHECK_BUFFER (buffer
, 0);
1388 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1393 /* Set the height of WINDOW and all its inferiors. */
1395 /* The smallest acceptable dimensions for a window. Anything smaller
1396 might crash Emacs. */
1397 #define MIN_SAFE_WINDOW_WIDTH (2)
1398 #define MIN_SAFE_WINDOW_HEIGHT (2)
1400 /* Make sure that window_min_height and window_min_width are
1401 not too small; if they are, set them to safe minima. */
1404 check_min_window_sizes ()
1406 /* Smaller values might permit a crash. */
1407 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1408 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1409 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1410 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1413 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1414 minimum allowable size. */
1416 check_frame_size (frame
, rows
, cols
)
1420 /* For height, we have to see:
1421 whether the frame has a minibuffer,
1422 whether it wants a mode line, and
1423 whether it has a menu bar. */
1425 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1426 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1427 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1428 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1429 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1431 if (*rows
< min_height
)
1433 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1434 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1437 /* Normally the window is deleted if it gets too small.
1438 nodelete nonzero means do not do this.
1439 (The caller should check later and do so if appropriate) */
1441 set_window_height (window
, height
, nodelete
)
1446 register struct window
*w
= XWINDOW (window
);
1447 register struct window
*c
;
1448 int oheight
= XFASTINT (w
->height
);
1449 int top
, pos
, lastbot
, opos
, lastobot
;
1452 check_min_window_sizes ();
1455 && ! NILP (w
->parent
)
1456 && height
< window_min_height
)
1458 Fdelete_window (window
);
1462 XFASTINT (w
->last_modified
) = 0;
1463 windows_or_buffers_changed
++;
1464 XFASTINT (w
->height
) = height
;
1465 if (!NILP (w
->hchild
))
1467 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1469 XWINDOW (child
)->top
= w
->top
;
1470 set_window_height (child
, height
, nodelete
);
1473 else if (!NILP (w
->vchild
))
1475 lastbot
= top
= XFASTINT (w
->top
);
1477 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1479 c
= XWINDOW (child
);
1481 opos
= lastobot
+ XFASTINT (c
->height
);
1483 XFASTINT (c
->top
) = lastbot
;
1485 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1487 /* Avoid confusion: inhibit deletion of child if becomes too small */
1488 set_window_height (child
, pos
+ top
- lastbot
, 1);
1490 /* Now advance child to next window,
1491 and set lastbot if child was not just deleted. */
1492 lastbot
= pos
+ top
;
1495 /* Now delete any children that became too small. */
1497 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1499 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1504 /* Recursively set width of WINDOW and its inferiors. */
1506 set_window_width (window
, width
, nodelete
)
1511 register struct window
*w
= XWINDOW (window
);
1512 register struct window
*c
;
1513 int owidth
= XFASTINT (w
->width
);
1514 int left
, pos
, lastright
, opos
, lastoright
;
1517 if (!nodelete
&& width
< window_min_width
)
1519 Fdelete_window (window
);
1523 XFASTINT (w
->last_modified
) = 0;
1524 windows_or_buffers_changed
++;
1525 XFASTINT (w
->width
) = width
;
1526 if (!NILP (w
->vchild
))
1528 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1530 XWINDOW (child
)->left
= w
->left
;
1531 set_window_width (child
, width
, nodelete
);
1534 else if (!NILP (w
->hchild
))
1536 lastright
= left
= XFASTINT (w
->left
);
1538 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1540 c
= XWINDOW (child
);
1542 opos
= lastoright
+ XFASTINT (c
->width
);
1544 XFASTINT (c
->left
) = lastright
;
1546 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1548 /* Inhibit deletion for becoming too small */
1549 set_window_width (child
, pos
+ left
- lastright
, 1);
1551 /* Now advance child to next window,
1552 and set lastright if child was not just deleted. */
1553 lastright
= pos
+ left
, lastoright
= opos
;
1555 /* Delete children that became too small */
1557 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1559 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1564 int window_select_count
;
1566 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1567 "Make WINDOW display BUFFER as its contents.\n\
1568 BUFFER can be a buffer or buffer name.")
1570 register Lisp_Object window
, buffer
;
1572 register Lisp_Object tem
;
1573 register struct window
*w
= decode_window (window
);
1575 buffer
= Fget_buffer (buffer
);
1576 CHECK_BUFFER (buffer
, 1);
1578 if (NILP (XBUFFER (buffer
)->name
))
1579 error ("Attempt to display deleted buffer");
1583 error ("Window is deleted");
1584 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1585 is first being set up. */
1587 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1588 error ("Window is dedicated to %s\n", tem
);
1594 w
->window_end_pos
= 0;
1595 w
->window_end_valid
= Qnil
;
1597 Fset_marker (w
->pointm
,
1598 make_number (BUF_PT (XBUFFER (buffer
))),
1600 set_marker_restricted (w
->start
,
1601 make_number (XBUFFER (buffer
)->last_window_start
),
1603 w
->start_at_line_beg
= Qnil
;
1604 w
->force_start
= Qnil
;
1605 XFASTINT (w
->last_modified
) = 0;
1606 windows_or_buffers_changed
++;
1607 if (EQ (window
, selected_window
))
1608 Fset_buffer (buffer
);
1613 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1614 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1615 The main editor command loop selects the buffer of the selected window\n\
1616 before each command.")
1618 register Lisp_Object window
;
1620 register struct window
*w
;
1621 register struct window
*ow
= XWINDOW (selected_window
);
1623 CHECK_LIVE_WINDOW (window
, 0);
1625 w
= XWINDOW (window
);
1627 if (NILP (w
->buffer
))
1628 error ("Trying to select deleted window or non-leaf window");
1630 XFASTINT (w
->use_time
) = ++window_select_count
;
1631 if (EQ (window
, selected_window
))
1634 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1637 selected_window
= window
;
1639 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1641 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1642 Fhandle_switch_frame (WINDOW_FRAME (w
), Qnil
);
1645 selected_frame
->selected_window
= window
;
1648 record_buffer (w
->buffer
);
1649 Fset_buffer (w
->buffer
);
1651 /* Go to the point recorded in the window.
1652 This is important when the buffer is in more
1653 than one window. It also matters when
1654 redisplay_window has altered point after scrolling,
1655 because it makes the change only in the window. */
1657 register int new_point
= marker_position (w
->pointm
);
1658 if (new_point
< BEGV
)
1666 windows_or_buffers_changed
++;
1670 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1671 "BDisplay buffer: \nP",
1672 "Make BUFFER appear in some window but don't select it.\n\
1673 BUFFER can be a buffer or a buffer name.\n\
1674 If BUFFER is shown already in some window, just use that one,\n\
1675 unless the window is the selected window and the optional second\n\
1676 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1677 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1678 Returns the window displaying BUFFER.")
1679 (buffer
, not_this_window
)
1680 register Lisp_Object buffer
, not_this_window
;
1682 register Lisp_Object window
;
1684 buffer
= Fget_buffer (buffer
);
1685 CHECK_BUFFER (buffer
, 0);
1687 if (!NILP (Vdisplay_buffer_function
))
1688 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1690 if (NILP (not_this_window
)
1691 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1692 return selected_window
;
1694 /* If pop_up_frames, look for a window on any frame, showing BUFFER. */
1695 window
= Fget_buffer_window (buffer
, pop_up_frames
? Qt
: Qnil
);
1697 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1701 /* If there are no frames open that have more than a minibuffer,
1702 we need to create a new frame. */
1703 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1706 = Fframe_selected_window (call0 (Vpop_up_frame_function
));
1707 Fset_window_buffer (window
, buffer
);
1709 Fhandle_switch_frame (XWINDOW (window
)->frame
, Qnil
);
1713 #endif /* MULTI_FRAME */
1717 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1721 Lisp_Object frames
= Qnil
;
1724 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1725 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1727 /* Don't try to create a window if would get an error */
1728 if (split_height_threshold
< window_min_height
<< 1)
1729 split_height_threshold
= window_min_height
<< 1;
1731 window
= Fget_largest_window (frames
);
1734 && window_height (window
) >= split_height_threshold
1735 && (XFASTINT (XWINDOW (window
)->width
)
1736 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1737 window
= Fsplit_window (window
, Qnil
, Qnil
);
1740 window
= Fget_lru_window (frames
);
1741 if ((EQ (window
, selected_window
)
1742 || EQ (XWINDOW (window
)->parent
, Qnil
))
1743 && window_height (window
) >= window_min_height
<< 1)
1744 window
= Fsplit_window (window
, Qnil
, Qnil
);
1748 window
= Fget_lru_window (Qnil
);
1750 Fset_window_buffer (window
, buffer
);
1755 temp_output_buffer_show (buf
)
1756 register Lisp_Object buf
;
1758 register struct buffer
*old
= current_buffer
;
1759 register Lisp_Object window
;
1760 register struct window
*w
;
1763 XBUFFER (buf
)->save_modified
= MODIFF
;
1768 set_buffer_internal (old
);
1770 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1771 call1 (Vtemp_buffer_show_function
, buf
);
1774 window
= Fdisplay_buffer (buf
, Qnil
);
1777 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1778 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1779 #endif /* MULTI_FRAME */
1780 Vminibuf_scroll_window
= window
;
1781 w
= XWINDOW (window
);
1782 XFASTINT (w
->hscroll
) = 0;
1783 set_marker_restricted (w
->start
, make_number (1), buf
);
1784 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1789 make_dummy_parent (window
)
1792 register Lisp_Object old
, new;
1793 register struct window
*o
, *p
;
1796 XSETTYPE (old
, Lisp_Vector
);
1797 new = Fcopy_sequence (old
);
1798 XSETTYPE (new, Lisp_Window
);
1802 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1804 /* Put new into window structure in place of window */
1805 replace_window (window
, new);
1818 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1819 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1820 WINDOW defaults to selected one and SIZE to half its size.\n\
1821 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1822 and put SIZE columns in the first of the pair.")
1823 (window
, chsize
, horflag
)
1824 Lisp_Object window
, chsize
, horflag
;
1826 register Lisp_Object
new;
1827 register struct window
*o
, *p
;
1831 window
= selected_window
;
1833 CHECK_LIVE_WINDOW (window
, 0);
1835 o
= XWINDOW (window
);
1839 if (!NILP (horflag
))
1840 /* Round odd size up, since this is for the left-hand window,
1841 and it will lose a column for the separators. */
1842 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1844 size
= XFASTINT (o
->height
) >> 1;
1848 CHECK_NUMBER (chsize
, 1);
1849 size
= XINT (chsize
);
1852 if (MINI_WINDOW_P (o
))
1853 error ("Attempt to split minibuffer window");
1854 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1855 error ("Attempt to split unsplittable frame");
1857 check_min_window_sizes ();
1861 if (size
< window_min_height
1862 || size
+ window_min_height
> XFASTINT (o
->height
))
1863 args_out_of_range_3 (window
, chsize
, horflag
);
1864 if (NILP (o
->parent
)
1865 || NILP (XWINDOW (o
->parent
)->vchild
))
1867 make_dummy_parent (window
);
1869 XWINDOW (new)->vchild
= window
;
1874 if (size
< window_min_width
1875 || size
+ window_min_width
> XFASTINT (o
->width
))
1876 args_out_of_range_3 (window
, chsize
, horflag
);
1877 if (NILP (o
->parent
)
1878 || NILP (XWINDOW (o
->parent
)->hchild
))
1880 make_dummy_parent (window
);
1882 XWINDOW (new)->hchild
= window
;
1886 /* Now we know that window's parent is a vertical combination
1887 if we are dividing vertically, or a horizontal combination
1888 if we are making side-by-side windows */
1890 windows_or_buffers_changed
++;
1891 new = make_window ();
1894 p
->frame
= o
->frame
;
1896 if (!NILP (p
->next
))
1897 XWINDOW (p
->next
)->prev
= new;
1900 p
->parent
= o
->parent
;
1903 Fset_window_buffer (new, o
->buffer
);
1905 /* Apportion the available frame space among the two new windows */
1907 if (!NILP (horflag
))
1909 p
->height
= o
->height
;
1911 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1912 XFASTINT (o
->width
) = size
;
1913 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1918 p
->width
= o
->width
;
1919 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1920 XFASTINT (o
->height
) = size
;
1921 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
1927 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
1928 "Make current window ARG lines bigger.\n\
1929 From program, optional second arg non-nil means grow sideways ARG columns.")
1931 register Lisp_Object n
, side
;
1933 CHECK_NUMBER (n
, 0);
1934 change_window_height (XINT (n
), !NILP (side
));
1938 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
1939 "Make current window ARG lines smaller.\n\
1940 From program, optional second arg non-nil means shrink sideways ARG columns.")
1942 register Lisp_Object n
, side
;
1944 CHECK_NUMBER (n
, 0);
1945 change_window_height (-XINT (n
), !NILP (side
));
1950 window_height (window
)
1953 register struct window
*p
= XWINDOW (window
);
1954 return XFASTINT (p
->height
);
1958 window_width (window
)
1961 register struct window
*p
= XWINDOW (window
);
1962 return XFASTINT (p
->width
);
1965 #define MINSIZE(w) \
1967 ? window_min_width \
1968 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
1971 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
1973 #define CURSIZE(w) \
1974 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
1976 /* Unlike set_window_height, this function
1977 also changes the heights of the siblings so as to
1978 keep everything consistent. */
1980 change_window_height (delta
, widthflag
)
1984 register Lisp_Object parent
;
1986 register struct window
*p
;
1988 int (*sizefun
) () = widthflag
? window_width
: window_height
;
1989 register int (*setsizefun
) () = (widthflag
1991 : set_window_height
);
1993 check_min_window_sizes ();
1995 window
= selected_window
;
1998 p
= XWINDOW (window
);
2003 error ("No other window to side of this one");
2006 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2007 : !NILP (XWINDOW (parent
)->vchild
))
2012 sizep
= &CURSIZE (window
);
2014 if (*sizep
+ delta
< MINSIZE (window
))
2016 Fdelete_window (window
);
2021 register int maxdelta
;
2023 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2024 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2025 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2026 /* This is a frame with only one window, a minibuffer-only
2027 or a minibufferless frame. */
2030 if (delta
> maxdelta
)
2031 /* This case traps trying to make the minibuffer
2032 the full frame, or make the only window aside from the
2033 minibuffer the full frame. */
2040 if (!NILP (p
->next
) &&
2041 (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2043 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2044 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2045 CURBEG (p
->next
) += delta
;
2046 /* This does not change size of p->next,
2047 but it propagates the new top edge to its children */
2048 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2050 else if (!NILP (p
->prev
) &&
2051 (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2053 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2054 CURBEG (window
) -= delta
;
2055 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2059 register int delta1
;
2060 register int opht
= (*sizefun
) (parent
);
2062 /* If trying to grow this window to or beyond size of the parent,
2063 make delta1 so big that, on shrinking back down,
2064 all the siblings end up with less than one line and are deleted. */
2065 if (opht
<= *sizep
+ delta
)
2066 delta1
= opht
* opht
* 2;
2067 /* Otherwise, make delta1 just right so that if we add delta1
2068 lines to this window and to the parent, and then shrink
2069 the parent back to its original size, the new proportional
2070 size of this window will increase by delta. */
2072 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2074 /* Add delta1 lines or columns to this window, and to the parent,
2075 keeping things consistent while not affecting siblings. */
2076 CURSIZE (parent
) = opht
+ delta1
;
2077 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2079 /* Squeeze out delta1 lines or columns from our parent,
2080 shriking this window and siblings proportionately.
2081 This brings parent back to correct size.
2082 Delta1 was calculated so this makes this window the desired size,
2083 taking it all out of the siblings. */
2084 (*setsizefun
) (parent
, opht
, 0);
2087 XFASTINT (p
->last_modified
) = 0;
2094 /* Return number of lines of text (not counting mode line) in W. */
2097 window_internal_height (w
)
2100 int ht
= XFASTINT (w
->height
);
2102 if (MINI_WINDOW_P (w
))
2105 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2106 || !NILP (w
->next
) || !NILP (w
->prev
)
2107 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2114 /* Return the number of columns in W.
2115 Don't count columns occupied by scroll bars or the vertical bar
2116 separating W from the sibling to its right. */
2118 window_internal_width (w
)
2121 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2122 int left
= XINT (w
->left
);
2123 int width
= XINT (w
->width
);
2125 /* If this window is flush against the right edge of the frame, its
2126 internal width is its full width. */
2127 if (left
+ width
>= FRAME_WIDTH (f
))
2130 /* If we are not flush right, then our rightmost columns are
2131 occupied by some sort of separator. */
2133 /* Scroll bars occupy a few columns. */
2134 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2135 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2137 /* The column of `|' characters separating side-by-side windows
2138 occupies one column only. */
2143 /* Scroll contents of window WINDOW up N lines. */
2146 window_scroll (window
, n
, noerror
)
2151 register struct window
*w
= XWINDOW (window
);
2152 register int opoint
= point
;
2154 register int ht
= window_internal_height (w
);
2155 register Lisp_Object tem
;
2157 Lisp_Object bolp
, nmoved
;
2159 XFASTINT (tem
) = point
;
2160 tem
= Fpos_visible_in_window_p (tem
, window
);
2164 Fvertical_motion (make_number (- ht
/ 2));
2165 XFASTINT (tem
) = point
;
2166 Fset_marker (w
->start
, tem
, w
->buffer
);
2167 w
->force_start
= Qt
;
2170 SET_PT (marker_position (w
->start
));
2171 lose
= n
< 0 && point
== BEGV
;
2172 Fvertical_motion (make_number (n
));
2182 Fsignal (Qbeginning_of_buffer
, Qnil
);
2187 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2188 w
->start_at_line_beg
= bolp
;
2189 w
->update_mode_line
= Qt
;
2190 XFASTINT (w
->last_modified
) = 0;
2196 tem
= Fvertical_motion (make_number (ht
));
2197 if (point
> opoint
|| XFASTINT (tem
) < ht
)
2200 Fvertical_motion (make_number (-1));
2208 Fsignal (Qend_of_buffer
, Qnil
);
2212 /* This is the guts of Fscroll_up and Fscroll_down. */
2215 scroll_command (n
, direction
)
2216 register Lisp_Object n
;
2219 register int defalt
;
2220 int count
= specpdl_ptr
- specpdl
;
2222 /* If selected window's buffer isn't current, make it current for the moment.
2223 But don't screw up if window_scroll gets an error. */
2224 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2226 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2227 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2230 defalt
= (window_internal_height (XWINDOW (selected_window
))
2231 - next_screen_context_lines
);
2232 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2235 window_scroll (selected_window
, defalt
, 0);
2236 else if (EQ (n
, Qminus
))
2237 window_scroll (selected_window
, - defalt
, 0);
2240 n
= Fprefix_numeric_value (n
);
2241 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2244 unbind_to (count
, Qnil
);
2247 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2248 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2249 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2250 When calling from a program, supply a number as argument or nil.")
2254 scroll_command (n
, 1);
2258 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2259 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2260 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2261 When calling from a program, supply a number as argument or nil.")
2265 scroll_command (n
, -1);
2269 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2270 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2271 The next window is the one below the current one; or the one at the top\n\
2272 if the current one is at the bottom.\n\
2273 When calling from a program, supply a number as argument or nil.\n\
2275 If in the minibuffer, `minibuf-scroll-window' if non-nil\n\
2276 specifies the window to scroll.\n\
2277 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2278 showing that buffer, popping the buffer up if necessary.")
2280 register Lisp_Object n
;
2282 register Lisp_Object window
;
2284 register struct window
*w
;
2285 register int count
= specpdl_ptr
- specpdl
;
2287 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2288 && !NILP (Vminibuf_scroll_window
))
2289 window
= Vminibuf_scroll_window
;
2290 /* If buffer is specified, scroll that buffer. */
2291 else if (!NILP (Vother_window_scroll_buffer
))
2293 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2295 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2299 /* Nothing specified; look for a neighboring window on the same
2301 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2303 if (EQ (window
, selected_window
))
2304 /* That didn't get us anywhere; look for a window on another
2307 window
= Fnext_window (window
, Qnil
, Qt
);
2308 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2309 && ! EQ (window
, selected_window
));
2312 CHECK_LIVE_WINDOW (window
, 0);
2314 if (EQ (window
, selected_window
))
2315 error ("There is no other window");
2317 w
= XWINDOW (window
);
2318 ht
= window_internal_height (w
);
2320 /* Don't screw up if window_scroll gets an error. */
2321 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2323 Fset_buffer (w
->buffer
);
2324 SET_PT (marker_position (w
->pointm
));
2327 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2328 else if (EQ (n
, Qminus
))
2329 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2332 if (XTYPE (n
) == Lisp_Cons
)
2334 CHECK_NUMBER (n
, 0);
2335 window_scroll (window
, XINT (n
), 1);
2338 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
2339 unbind_to (count
, Qnil
);
2344 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2345 "Scroll selected window display ARG columns left.\n\
2346 Default for ARG is window width minus 2.")
2348 register Lisp_Object arg
;
2352 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2354 arg
= Fprefix_numeric_value (arg
);
2357 Fset_window_hscroll (selected_window
,
2358 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2362 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2363 "Scroll selected window display ARG columns right.\n\
2364 Default for ARG is window width minus 2.")
2366 register Lisp_Object arg
;
2369 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2371 arg
= Fprefix_numeric_value (arg
);
2374 Fset_window_hscroll (selected_window
,
2375 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2379 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2380 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2381 The desired position of point is always relative to the current window.\n\
2382 Just C-u as prefix means put point in the center of the window.\n\
2383 No arg (i.e., it is nil) erases the entire frame and then\n\
2384 redraws with point in the center of the current window.")
2386 register Lisp_Object n
;
2388 register struct window
*w
= XWINDOW (selected_window
);
2389 register int ht
= window_internal_height (w
);
2390 register int opoint
= point
;
2394 extern int frame_garbaged
;
2396 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2397 XFASTINT (n
) = ht
/ 2;
2399 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2401 XFASTINT (n
) = ht
/ 2;
2405 n
= Fprefix_numeric_value (n
);
2406 CHECK_NUMBER (n
, 0);
2410 XSETINT (n
, XINT (n
) + ht
);
2412 XSETINT (n
, - XINT (n
));
2414 Fvertical_motion (n
);
2415 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2416 w
->start_at_line_beg
= Fbolp ();
2419 w
->force_start
= Qt
;
2424 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2426 "Position point relative to window.\n\
2427 With no argument, position text at center of window.\n\
2428 An argument specifies frame line; zero means top of window,\n\
2429 negative means relative to bottom of window.")
2431 register Lisp_Object arg
;
2433 register struct window
*w
= XWINDOW (selected_window
);
2434 register int height
= window_internal_height (w
);
2438 XFASTINT (arg
) = height
/ 2;
2441 arg
= Fprefix_numeric_value (arg
);
2443 XSETINT (arg
, XINT (arg
) + height
);
2446 start
= marker_position (w
->start
);
2447 if (start
< BEGV
|| start
> ZV
)
2449 Fvertical_motion (make_number (- height
/ 2));
2450 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2451 w
->start_at_line_beg
= Fbolp ();
2452 w
->force_start
= Qt
;
2457 return Fvertical_motion (arg
);
2460 struct save_window_data
2462 int size_from_Lisp_Vector_struct
;
2463 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2464 Lisp_Object frame_width
, frame_height
;
2465 Lisp_Object selected_frame
;
2466 Lisp_Object current_window
;
2467 Lisp_Object current_buffer
;
2468 Lisp_Object minibuf_scroll_window
;
2469 Lisp_Object root_window
;
2470 Lisp_Object focus_frame
;
2471 /* A vector, interpreted as a struct saved_window */
2472 Lisp_Object saved_windows
;
2475 /* Arg to Fmake_vector */
2476 #define SAVE_WINDOW_DATA_SIZE \
2477 ((sizeof (struct save_window_data) \
2478 - (sizeof (struct Lisp_Vector) \
2479 /* Don't count the contents member of the struct Lisp_Vector */ \
2480 - sizeof (Lisp_Object))) \
2481 / sizeof (Lisp_Object))
2483 /* This is saved as a Lisp_Vector */
2486 /* these first two must agree with struct Lisp_Vector in lisp.h */
2487 int size_from_Lisp_Vector_struct
;
2488 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2491 Lisp_Object buffer
, start
, pointm
, mark
;
2492 Lisp_Object left
, top
, width
, height
, hscroll
;
2493 Lisp_Object parent
, prev
;
2494 Lisp_Object start_at_line_beg
;
2495 Lisp_Object display_table
;
2497 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2499 #define SAVED_WINDOW_N(swv,n) \
2500 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2502 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2503 "T if OBJECT is a window-configration object.")
2507 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2513 DEFUN ("set-window-configuration", Fset_window_configuration
,
2514 Sset_window_configuration
, 1, 1, 0,
2515 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2516 CONFIGURATION must be a value previously returned\n\
2517 by `current-window-configuration' (which see).")
2519 Lisp_Object configuration
;
2521 register struct save_window_data
*data
;
2522 struct Lisp_Vector
*saved_windows
;
2523 Lisp_Object new_current_buffer
;
2527 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2529 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2533 data
= (struct save_window_data
*) XVECTOR (configuration
);
2534 saved_windows
= XVECTOR (data
->saved_windows
);
2536 new_current_buffer
= data
->current_buffer
;
2537 if (NILP (XBUFFER (new_current_buffer
)->name
))
2538 new_current_buffer
= Qnil
;
2540 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2543 /* If f is a dead frame, don't bother rebuilding its window tree.
2544 However, there is other stuff we should still try to do below. */
2545 if (FRAME_LIVE_P (f
))
2547 register struct window
*w
;
2548 register struct saved_window
*p
;
2551 /* If the frame has been resized since this window configuration was
2552 made, we change the frame to the size specified in the
2553 configuration, restore the configuration, and then resize it
2554 back. We keep track of the prevailing height in these variables. */
2555 int previous_frame_height
= FRAME_HEIGHT (f
);
2556 int previous_frame_width
= FRAME_WIDTH (f
);
2558 if (XFASTINT (data
->frame_height
) != previous_frame_height
2559 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2560 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2562 windows_or_buffers_changed
++;
2565 Mark all windows now on frame as "deleted".
2566 Restoring the new configuration "undeletes" any that are in it.
2568 Save their current buffers in their height fields, since we may
2569 need it later, if a buffer saved in the configuration is now
2571 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2573 for (k
= 0; k
< saved_windows
->size
; k
++)
2575 p
= SAVED_WINDOW_N (saved_windows
, k
);
2576 w
= XWINDOW (p
->window
);
2579 if (!NILP (p
->parent
))
2580 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2581 XFASTINT (p
->parent
))->window
;
2585 if (!NILP (p
->prev
))
2587 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2588 XFASTINT (p
->prev
))->window
;
2589 XWINDOW (w
->prev
)->next
= p
->window
;
2594 if (!NILP (w
->parent
))
2596 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2598 XWINDOW (w
->parent
)->vchild
= p
->window
;
2599 XWINDOW (w
->parent
)->hchild
= Qnil
;
2603 XWINDOW (w
->parent
)->hchild
= p
->window
;
2604 XWINDOW (w
->parent
)->vchild
= Qnil
;
2609 /* If we squirreled away the buffer in the window's height,
2611 if (XTYPE (w
->height
) == Lisp_Buffer
)
2612 w
->buffer
= w
->height
;
2615 w
->width
= p
->width
;
2616 w
->height
= p
->height
;
2617 w
->hscroll
= p
->hscroll
;
2618 w
->display_table
= p
->display_table
;
2619 XFASTINT (w
->last_modified
) = 0;
2621 /* Reinstall the saved buffer and pointers into it. */
2622 if (NILP (p
->buffer
))
2623 w
->buffer
= p
->buffer
;
2626 if (!NILP (XBUFFER (p
->buffer
)->name
))
2627 /* If saved buffer is alive, install it. */
2629 w
->buffer
= p
->buffer
;
2630 w
->start_at_line_beg
= p
->start_at_line_beg
;
2631 set_marker_restricted (w
->start
,
2632 Fmarker_position (p
->start
),
2634 set_marker_restricted (w
->pointm
,
2635 Fmarker_position (p
->pointm
),
2637 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2638 Fmarker_position (p
->mark
), w
->buffer
);
2640 /* As documented in Fcurrent_window_configuration, don't
2641 save the location of point in the buffer which was current
2642 when the window configuration was recorded. */
2643 if (!EQ (p
->buffer
, new_current_buffer
) &&
2644 XBUFFER (p
->buffer
) == current_buffer
)
2645 Fgoto_char (w
->pointm
);
2647 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2648 /* Else unless window has a live buffer, get one. */
2650 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2651 /* This will set the markers to beginning of visible
2653 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2654 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2655 w
->start_at_line_beg
= Qt
;
2658 /* Keeping window's old buffer; make sure the markers
2661 /* Set window markers at start of visible range. */
2662 if (XMARKER (w
->start
)->buffer
== 0)
2663 set_marker_restricted (w
->start
, make_number (0),
2665 if (XMARKER (w
->pointm
)->buffer
== 0)
2666 set_marker_restricted (w
->pointm
,
2668 (BUF_PT (XBUFFER (w
->buffer
)))),
2670 w
->start_at_line_beg
= Qt
;
2675 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2676 Fselect_window (data
->current_window
);
2679 if (NILP (data
->focus_frame
)
2680 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2681 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2682 Fredirect_frame_focus (frame
, data
->focus_frame
);
2685 #if 0 /* I don't understand why this is needed, and it causes problems
2686 when the frame's old selected window has been deleted. */
2688 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2689 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2693 /* Set the screen height to the value it had before this function. */
2694 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2695 || previous_frame_width
!= FRAME_WIDTH (f
))
2696 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2701 /* Fselect_window will have made f the selected frame, so we
2702 reselect the proper frame here. Fhandle_switch_frame will change the
2703 selected window too, but that doesn't make the call to
2704 Fselect_window above totally superfluous; it still sets f's
2706 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2707 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2710 if (!NILP (new_current_buffer
))
2711 Fset_buffer (new_current_buffer
);
2713 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2717 /* Mark all windows now on frame as deleted
2718 by setting their buffers to nil. */
2721 delete_all_subwindows (w
)
2722 register struct window
*w
;
2724 if (!NILP (w
->next
))
2725 delete_all_subwindows (XWINDOW (w
->next
));
2726 if (!NILP (w
->vchild
))
2727 delete_all_subwindows (XWINDOW (w
->vchild
));
2728 if (!NILP (w
->hchild
))
2729 delete_all_subwindows (XWINDOW (w
->hchild
));
2731 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2733 /* We set all three of these fields to nil, to make sure that we can
2734 distinguish this dead window from any live window. Live leaf
2735 windows will have buffer set, and combination windows will have
2736 vchild or hchild set. */
2743 count_windows (window
)
2744 register struct window
*window
;
2746 register int count
= 1;
2747 if (!NILP (window
->next
))
2748 count
+= count_windows (XWINDOW (window
->next
));
2749 if (!NILP (window
->vchild
))
2750 count
+= count_windows (XWINDOW (window
->vchild
));
2751 if (!NILP (window
->hchild
))
2752 count
+= count_windows (XWINDOW (window
->hchild
));
2757 save_window_save (window
, vector
, i
)
2759 struct Lisp_Vector
*vector
;
2762 register struct saved_window
*p
;
2763 register struct window
*w
;
2764 register Lisp_Object tem
;
2766 for (;!NILP (window
); window
= w
->next
)
2768 p
= SAVED_WINDOW_N (vector
, i
);
2769 w
= XWINDOW (window
);
2771 XFASTINT (w
->temslot
) = i
++;
2773 p
->buffer
= w
->buffer
;
2776 p
->width
= w
->width
;
2777 p
->height
= w
->height
;
2778 p
->hscroll
= w
->hscroll
;
2779 p
->display_table
= w
->display_table
;
2780 if (!NILP (w
->buffer
))
2782 /* Save w's value of point in the window configuration.
2783 If w is the selected window, then get the value of point
2784 from the buffer; pointm is garbage in the selected window. */
2785 if (EQ (window
, selected_window
))
2787 p
->pointm
= Fmake_marker ();
2788 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2792 p
->pointm
= Fcopy_marker (w
->pointm
);
2794 p
->start
= Fcopy_marker (w
->start
);
2795 p
->start_at_line_beg
= w
->start_at_line_beg
;
2797 tem
= XBUFFER (w
->buffer
)->mark
;
2798 p
->mark
= Fcopy_marker (tem
);
2805 p
->start_at_line_beg
= Qnil
;
2808 if (NILP (w
->parent
))
2811 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2816 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2818 if (!NILP (w
->vchild
))
2819 i
= save_window_save (w
->vchild
, vector
, i
);
2820 if (!NILP (w
->hchild
))
2821 i
= save_window_save (w
->hchild
, vector
, i
);
2827 DEFUN ("current-window-configuration",
2828 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2829 "Return an object representing the current window configuration of FRAME.\n\
2830 If FRAME is nil or omitted, use the selected frame.\n\
2831 This describes the number of windows, their sizes and current buffers,\n\
2832 and for each displayed buffer, where display starts, and the positions of\n\
2833 point and mark. An exception is made for point in the current buffer:\n\
2834 its value is -not- saved.\n\
2835 This also records the currently selected frame, and FRAME's focus\n\
2836 redirection (see `redirect-frame-focus').")
2840 register Lisp_Object tem
;
2841 register int n_windows
;
2842 register struct save_window_data
*data
;
2850 CHECK_LIVE_FRAME (frame
, 0);
2854 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2855 data
= (struct save_window_data
*)
2856 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2858 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2859 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2861 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2863 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2864 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2865 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2866 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2867 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2868 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2869 data
->saved_windows
= tem
;
2870 for (i
= 0; i
< n_windows
; i
++)
2871 XVECTOR (tem
)->contents
[i
]
2872 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2873 save_window_save (FRAME_ROOT_WINDOW (f
),
2875 XSET (tem
, Lisp_Window_Configuration
, data
);
2879 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2881 "Execute body, preserving window sizes and contents.\n\
2882 Restores which buffer appears in which window, where display starts,\n\
2883 as well as the current buffer.\n\
2884 Does not restore the value of point in current buffer.")
2888 register Lisp_Object val
;
2889 register int count
= specpdl_ptr
- specpdl
;
2891 record_unwind_protect (Fset_window_configuration
,
2892 Fcurrent_window_configuration (Qnil
));
2893 val
= Fprogn (args
);
2894 return unbind_to (count
, val
);
2900 selected_frame
= make_terminal_frame ();
2901 minibuf_window
= selected_frame
->minibuffer_window
;
2902 selected_window
= selected_frame
->selected_window
;
2903 last_nonminibuf_frame
= selected_frame
;
2904 #else /* not MULTI_FRAME */
2905 extern Lisp_Object
get_minibuffer ();
2907 minibuf_window
= make_window ();
2908 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
2910 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
2911 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
2912 XWINDOW (minibuf_window
)->mini_p
= Qt
;
2914 /* These values 9 and 10 are arbitrary,
2915 just so that there is "something there."
2916 Correct values are put in in init_xdisp */
2918 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
2919 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
2921 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
2922 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
2923 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
2925 /* Prevent error in Fset_window_buffer. */
2926 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
2927 XWINDOW (minibuf_window
)->buffer
= Qt
;
2929 /* Now set them up for real. */
2930 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
2931 Fcurrent_buffer ());
2932 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
2934 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
2935 /* Make sure this window seems more recently used than
2936 a newly-created, never-selected window. Increment
2937 window_select_count so the first selection ever will get
2938 something newer than this. */
2939 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
2940 #endif /* not MULTI_FRAME */
2945 Qwindowp
= intern ("windowp");
2946 staticpro (&Qwindowp
);
2948 Qwindow_live_p
= intern ("window-live-p");
2949 staticpro (&Qwindow_live_p
);
2952 /* Make sure all windows get marked */
2953 staticpro (&minibuf_window
);
2956 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
2957 "Non-nil means call as function to display a help buffer.\n\
2958 Used by `with-output-to-temp-buffer'.");
2959 Vtemp_buffer_show_function
= Qnil
;
2961 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
2962 "If non-nil, function to call to handle `display-buffer'.\n\
2963 It will receive two args, the buffer and a flag which if non-nil means\n\
2964 that the currently selected window is not acceptable.\n\
2965 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
2966 work using this function.");
2967 Vdisplay_buffer_function
= Qnil
;
2969 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
2970 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
2971 Vminibuf_scroll_window
= Qnil
;
2973 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
2974 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
2975 Vother_window_scroll_buffer
= Qnil
;
2977 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
2978 "*Non-nil means `display-buffer' should make a separate frame.");
2981 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
2982 "*If non-nil, function to call to handle automatic new frame creation.\n\
2983 It is called with no arguments and should return a newly created frame.\n\
2985 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
2986 where `pop-up-frame-alist' would hold the default frame parameters.");
2987 Vpop_up_frame_function
= Qnil
;
2989 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
2990 "*Non-nil means display-buffer should make new windows.");
2993 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
2994 "*Number of lines of continuity when scrolling by screenfuls.");
2995 next_screen_context_lines
= 2;
2997 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
2998 "*display-buffer would prefer to split the largest window if this large.\n\
2999 If there is only one window, it is split regardless of this value.");
3000 split_height_threshold
= 500;
3002 DEFVAR_INT ("window-min-height", &window_min_height
,
3003 "*Delete any window less than this tall (including its mode line).");
3004 window_min_height
= 4;
3006 DEFVAR_INT ("window-min-width", &window_min_width
,
3007 "*Delete any window less than this wide.");
3008 window_min_width
= 10;
3010 defsubr (&Sselected_window
);
3011 defsubr (&Sminibuffer_window
);
3012 defsubr (&Swindow_minibuffer_p
);
3013 defsubr (&Swindowp
);
3014 defsubr (&Swindow_live_p
);
3015 defsubr (&Spos_visible_in_window_p
);
3016 defsubr (&Swindow_buffer
);
3017 defsubr (&Swindow_height
);
3018 defsubr (&Swindow_width
);
3019 defsubr (&Swindow_hscroll
);
3020 defsubr (&Sset_window_hscroll
);
3021 defsubr (&Swindow_edges
);
3022 defsubr (&Scoordinates_in_window_p
);
3023 defsubr (&Swindow_at
);
3024 defsubr (&Swindow_point
);
3025 defsubr (&Swindow_start
);
3026 defsubr (&Swindow_end
);
3027 defsubr (&Sset_window_point
);
3028 defsubr (&Sset_window_start
);
3029 defsubr (&Swindow_dedicated_p
);
3030 defsubr (&Sset_window_dedicated_p
);
3031 defsubr (&Swindow_display_table
);
3032 defsubr (&Sset_window_display_table
);
3033 defsubr (&Snext_window
);
3034 defsubr (&Sprevious_window
);
3035 defsubr (&Sother_window
);
3036 defsubr (&Sget_lru_window
);
3037 defsubr (&Sget_largest_window
);
3038 defsubr (&Sget_buffer_window
);
3039 defsubr (&Sdelete_other_windows
);
3040 defsubr (&Sdelete_windows_on
);
3041 defsubr (&Sreplace_buffer_in_windows
);
3042 defsubr (&Sdelete_window
);
3043 defsubr (&Sset_window_buffer
);
3044 defsubr (&Sselect_window
);
3045 defsubr (&Sdisplay_buffer
);
3046 defsubr (&Ssplit_window
);
3047 defsubr (&Senlarge_window
);
3048 defsubr (&Sshrink_window
);
3049 defsubr (&Sscroll_up
);
3050 defsubr (&Sscroll_down
);
3051 defsubr (&Sscroll_left
);
3052 defsubr (&Sscroll_right
);
3053 defsubr (&Sscroll_other_window
);
3054 defsubr (&Srecenter
);
3055 defsubr (&Smove_to_window_line
);
3056 defsubr (&Swindow_configuration_p
);
3057 defsubr (&Sset_window_configuration
);
3058 defsubr (&Scurrent_window_configuration
);
3059 defsubr (&Ssave_window_excursion
);
3064 initial_define_key (control_x_map
, '1', "delete-other-windows");
3065 initial_define_key (control_x_map
, '2', "split-window");
3066 initial_define_key (control_x_map
, '0', "delete-window");
3067 initial_define_key (control_x_map
, 'o', "other-window");
3068 initial_define_key (control_x_map
, '^', "enlarge-window");
3069 initial_define_key (control_x_map
, '<', "scroll-left");
3070 initial_define_key (control_x_map
, '>', "scroll-right");
3072 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3073 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3074 initial_define_key (meta_map
, 'v', "scroll-down");
3076 initial_define_key (global_map
, Ctl('L'), "recenter");
3077 initial_define_key (meta_map
, 'r', "move-to-window-line");