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
;
194 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
198 w
= decode_window (window
);
199 top
= marker_position (w
->start
);
200 hscroll
= XINT (w
->hscroll
);
205 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
207 buf
= XBUFFER (w
->buffer
);
208 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
210 /* If frame is up to date,
211 use the info recorded about how much text fit on it. */
212 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
213 || (XFASTINT (w
->window_end_vpos
) < height
))
219 if (posint
> BUF_ZV (buf
))
222 /* If that info is not correct, calculate afresh */
223 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
225 window_internal_width (w
) - 1,
228 return posval
.vpos
< height
? Qt
: Qnil
;
232 static struct window
*
233 decode_window (window
)
234 register Lisp_Object window
;
237 return XWINDOW (selected_window
);
239 CHECK_LIVE_WINDOW (window
, 0);
240 return XWINDOW (window
);
243 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
244 "Return the buffer that WINDOW is displaying.")
248 return decode_window (window
)->buffer
;
251 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
252 "Return the number of lines in WINDOW (including its mode line).")
256 return decode_window (window
)->height
;
259 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
260 "Return the number of columns in WINDOW.")
264 register struct window
*w
= decode_window (window
);
265 register int width
= XFASTINT (w
->width
);
267 return make_number (window_internal_width (w
));
270 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
271 "Return the number of columns by which WINDOW is scrolled from left margin.")
275 return decode_window (window
)->hscroll
;
278 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
279 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
280 NCOL should be zero or positive.")
282 register Lisp_Object window
, ncol
;
284 register struct window
*w
;
286 CHECK_NUMBER (ncol
, 1);
287 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
288 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
289 args_out_of_range (ncol
, Qnil
);
290 w
= decode_window (window
);
291 if (XINT (w
->hscroll
) != XINT (ncol
))
292 clip_changed
= 1; /* Prevent redisplay shortcuts */
297 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
298 "Return a list of the edge coordinates of WINDOW.\n\
299 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
300 RIGHT is one more than the rightmost column used by WINDOW,\n\
301 and BOTTOM is one more than the bottommost row used by WINDOW\n\
306 register struct window
*w
= decode_window (window
);
308 return Fcons (w
->left
, Fcons (w
->top
,
309 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
310 Fcons (make_number (XFASTINT (w
->top
)
311 + XFASTINT (w
->height
)),
315 /* Test if the character at column *x, row *y is within window *w.
316 If it is not, return 0;
317 if it is in the window's text area,
318 set *x and *y to its location relative to the upper left corner
321 if it is on the window's modeline, return 2;
322 if it is on the border between the window and its right sibling,
325 coordinates_in_window (w
, x
, y
)
326 register struct window
*w
;
329 register int left
= XINT (w
->left
);
330 register int width
= XINT (w
->width
);
331 register int window_height
= XINT (w
->height
);
332 register int top
= XFASTINT (w
->top
);
334 if ( *x
< left
|| *x
>= left
+ width
335 || *y
< top
|| *y
>= top
+ window_height
)
338 /* Is the character is the mode line? */
339 if (*y
== top
+ window_height
- 1
340 && ! MINI_WINDOW_P (w
))
343 /* Is the character in the right border? */
344 if (*x
== left
+ width
- 1
345 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
353 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
354 Scoordinates_in_window_p
, 2, 2, 0,
355 "Return non-nil if COORDINATES are in WINDOW.\n\
356 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
357 measured in characters from the upper-left corner of the frame.\n\
358 (0 . 0) denotes the character in the upper left corner of the\n\
360 If COORDINATES are in the text portion of WINDOW,\n\
361 the coordinates relative to the window are returned.\n\
362 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
363 If they are on the border between WINDOW and its right sibling,\n\
364 `vertical-line' is returned.")
365 (coordinates
, window
)
366 register Lisp_Object coordinates
, window
;
370 CHECK_LIVE_WINDOW (window
, 0);
371 CHECK_CONS (coordinates
, 1);
372 x
= XINT (Fcar (coordinates
));
373 y
= XINT (Fcdr (coordinates
));
375 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
377 case 0: /* NOT in window at all. */
380 case 1: /* In text part of window. */
383 case 2: /* In mode line of window. */
386 case 3: /* On right border of window. */
387 return Qvertical_line
;
394 /* Find the window containing column x, row y, and return it as a
395 Lisp_Object. If x, y is on the window's modeline, set *part
396 to 1; if it is on the separating line between the window and its
397 right sibling, set it to 2; otherwise set it to 0. If there is no
398 window under x, y return nil and leave *part unmodified. */
400 window_from_coordinates (frame
, x
, y
, part
)
405 register Lisp_Object tem
, first
;
407 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
411 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
419 tem
= Fnext_window (tem
, Qt
, Qlambda
);
421 while (! EQ (tem
, first
));
426 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
427 "Return window containing coordinates X and Y on FRAME.\n\
428 If omitted, FRAME defaults to the currently selected frame.\n\
429 The top left corner of the frame is considered to be row 0,\n\
432 Lisp_Object x
, y
, frame
;
438 XSET (frame
, Lisp_Frame
, selected_frame
);
440 CHECK_LIVE_FRAME (frame
, 2);
445 return window_from_coordinates (XFRAME (frame
),
450 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
451 "Return current value of point in WINDOW.\n\
452 For a nonselected window, this is the value point would have\n\
453 if that window were selected.\n\
455 Note that, when WINDOW is the selected window and its buffer\n\
456 is also currently selected, the value returned is the same as (point).\n\
457 It would be more strictly correct to return the `top-level' value\n\
458 of point, outside of any save-excursion forms.\n\
459 But that is hard to define.")
463 register struct window
*w
= decode_window (window
);
465 if (w
== XWINDOW (selected_window
)
466 && current_buffer
== XBUFFER (w
->buffer
))
468 return Fmarker_position (w
->pointm
);
471 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
472 "Return position at which display currently starts in WINDOW.")
476 return Fmarker_position (decode_window (window
)->start
);
479 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
480 "Return position at which display currently ends in WINDOW.")
485 struct window
*w
= decode_window (window
);
489 CHECK_BUFFER (buf
, 0);
491 XSET (value
, Lisp_Int
,
492 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
497 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
498 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
500 Lisp_Object window
, pos
;
502 register struct window
*w
= decode_window (window
);
504 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
505 if (w
== XWINDOW (selected_window
))
508 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
513 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
514 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
515 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
516 from overriding motion of point in order to display at this exact start.")
517 (window
, pos
, noforce
)
518 Lisp_Object window
, pos
, noforce
;
520 register struct window
*w
= decode_window (window
);
522 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
523 set_marker_restricted (w
->start
, pos
, w
->buffer
);
524 /* this is not right, but much easier than doing what is right. */
525 w
->start_at_line_beg
= Qnil
;
528 w
->update_mode_line
= Qt
;
529 XFASTINT (w
->last_modified
) = 0;
530 if (!EQ (window
, selected_window
))
531 windows_or_buffers_changed
++;
535 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
537 "Return WINDOW's dedicated object, usually t or nil.\n\
538 See also `set-window-dedicated-p'.")
542 return decode_window (window
)->dedicated
;
545 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
546 Sset_window_dedicated_p
, 2, 2, 0,
547 "Control whether WINDOW is dedicated to the buffer it displays.\n\
548 If it is dedicated, Emacs will not automatically change\n\
549 which buffer appears in it.\n\
550 The second argument is the new value for the dedication flag;\n\
553 Lisp_Object window
, arg
;
555 register struct window
*w
= decode_window (window
);
565 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
567 "Return the display-table that WINDOW is using.")
571 return decode_window (window
)->display_table
;
574 /* Get the display table for use currently on window W.
575 This is either W's display table or W's buffer's display table.
576 Ignore the specified tables if they are not valid;
577 if no valid table is specified, return 0. */
580 window_display_table (w
)
584 tem
= w
->display_table
;
585 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
586 return XVECTOR (tem
);
587 tem
= XBUFFER (w
->buffer
)->display_table
;
588 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
589 return XVECTOR (tem
);
590 tem
= Vstandard_display_table
;
591 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
592 return XVECTOR (tem
);
596 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
597 "Set WINDOW's display-table to TABLE.")
599 register Lisp_Object window
, table
;
601 register struct window
*w
;
602 register Lisp_Object z
; /* Return value. */
604 w
= decode_window (window
);
605 w
->display_table
= table
;
609 /* Record info on buffer window w is displaying
610 when it is about to cease to display that buffer. */
613 register struct window
*w
;
615 Lisp_Object buf
= w
->buffer
;
617 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
620 if (w
== XWINDOW (selected_window
)
621 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
622 /* Do this except when the selected window's buffer
623 is being removed from some other window. */
624 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
626 /* Point in the selected window's buffer
627 is actually stored in that buffer, and the window's pointm isn't used.
628 So don't clobber point in that buffer. */
629 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
630 BUF_PT (XBUFFER (buf
))
631 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
632 marker_position (w
->pointm
),
633 BUF_ZV (XBUFFER (buf
)));
636 /* Put replacement into the window structure in place of old. */
638 replace_window (old
, replacement
)
639 Lisp_Object old
, replacement
;
641 register Lisp_Object tem
;
642 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
644 /* If OLD is its frame's root_window, then replacement is the new
645 root_window for that frame. */
647 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
648 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
653 p
->height
= o
->height
;
655 p
->next
= tem
= o
->next
;
657 XWINDOW (tem
)->prev
= replacement
;
659 p
->prev
= tem
= o
->prev
;
661 XWINDOW (tem
)->next
= replacement
;
663 p
->parent
= tem
= o
->parent
;
666 if (EQ (XWINDOW (tem
)->vchild
, old
))
667 XWINDOW (tem
)->vchild
= replacement
;
668 if (EQ (XWINDOW (tem
)->hchild
, old
))
669 XWINDOW (tem
)->hchild
= replacement
;
672 /*** Here, if replacement is a vertical combination
673 and so is its new parent, we should make replacement's
674 children be children of that parent instead. ***/
677 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
678 "Remove WINDOW from the display. Default is selected window.")
680 register Lisp_Object window
;
682 register Lisp_Object tem
, parent
, sib
;
683 register struct window
*p
;
684 register struct window
*par
;
686 /* Because this function is called by other C code on non-leaf
687 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
688 so we can't decode_window here. */
690 window
= selected_window
;
692 CHECK_WINDOW (window
, 0);
693 p
= XWINDOW (window
);
695 /* It's okay to delete an already-deleted window. */
703 error ("Attempt to delete minibuffer or sole ordinary window");
704 par
= XWINDOW (parent
);
706 windows_or_buffers_changed
++;
708 /* Are we trying to delete any frame's selected window? */
710 Lisp_Object frame
, pwindow
;
712 /* See if the frame's selected window is either WINDOW
713 or any subwindow of it, by finding all that window's parents
714 and comparing each one with WINDOW. */
715 frame
= WINDOW_FRAME (XWINDOW (window
));
716 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
718 while (!NILP (pwindow
))
720 if (EQ (window
, pwindow
))
722 pwindow
= XWINDOW (pwindow
)->parent
;
725 if (EQ (window
, pwindow
))
727 Lisp_Object alternative
= Fnext_window (window
, Qlambda
, Qnil
);
729 /* If we're about to delete the selected window on the
730 selected frame, then we should use Fselect_window to select
731 the new window. On the other hand, if we're about to
732 delete the selected window on any other frame, we shouldn't do
733 anything but set the frame's selected_window slot. */
734 if (EQ (window
, selected_window
))
735 Fselect_window (alternative
);
737 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
742 /* tem is null for dummy parent windows
743 (which have inferiors but not any contents themselves) */
747 unchain_marker (p
->pointm
);
748 unchain_marker (p
->start
);
753 XWINDOW (tem
)->prev
= p
->prev
;
757 XWINDOW (tem
)->next
= p
->next
;
759 if (EQ (window
, par
->hchild
))
760 par
->hchild
= p
->next
;
761 if (EQ (window
, par
->vchild
))
762 par
->vchild
= p
->next
;
764 /* Find one of our siblings to give our space to. */
768 /* If p gives its space to its next sibling, that sibling needs
769 to have its top/left side pulled back to where p's is.
770 set_window_{height,width} will re-position the sibling's
773 XWINDOW (sib
)->top
= p
->top
;
774 XWINDOW (sib
)->left
= p
->left
;
777 /* Stretch that sibling. */
778 if (!NILP (par
->vchild
))
779 set_window_height (sib
,
780 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
782 if (!NILP (par
->hchild
))
783 set_window_width (sib
,
784 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
787 /* If parent now has only one child,
788 put the child into the parent's place. */
792 if (NILP (XWINDOW (tem
)->next
))
793 replace_window (parent
, tem
);
795 /* Since we may be deleting combination windows, we must make sure that
796 not only p but all its children have been marked as deleted. */
797 if (! NILP (p
->hchild
))
798 delete_all_subwindows (XWINDOW (p
->hchild
));
799 else if (! NILP (p
->vchild
))
800 delete_all_subwindows (XWINDOW (p
->vchild
));
802 /* Mark this window as deleted. */
803 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
809 extern Lisp_Object
next_frame (), prev_frame ();
811 /* This comment supplies the doc string for `next-window',
812 for make-docfile to see. We cannot put this in the real DEFUN
813 due to limits in the Unix cpp.
815 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
816 "Return next window after WINDOW in canonical ordering of windows.\n\
817 If omitted, WINDOW defaults to the selected window.\n\
819 Optional second arg MINIBUF t means count the minibuffer window even\n\
820 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
821 it is active. MINIBUF neither t nor nil means not to count the\n\
822 minibuffer even if it is active.\n\
824 Several frames may share a single minibuffer; if the minibuffer\n\
825 counts, all windows on all frames that share that minibuffer count\n\
826 too. This means that next-window may be used to iterate through the\n\
827 set of windows even when the minibuffer is on another frame. If the\n\
828 minibuffer does not count, only windows from WINDOW's frame count.\n\
830 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
831 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
832 above. If neither nil nor t, restrict to WINDOW's frame.\n\
834 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
835 `next-window' to iterate through the entire cycle of acceptable\n\
836 windows, eventually ending up back at the window you started with.\n\
837 `previous-window' traverses the same cycle, in the reverse order.")
838 (window, minibuf, all_frames) */
840 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
842 (window
, minibuf
, all_frames
)
843 register Lisp_Object window
, minibuf
, all_frames
;
845 register Lisp_Object tem
;
846 Lisp_Object start_window
;
849 window
= selected_window
;
851 CHECK_LIVE_WINDOW (window
, 0);
853 start_window
= window
;
855 /* minibuf == nil may or may not include minibuffers.
856 Decide if it does. */
858 minibuf
= (minibuf_level
? Qt
: Qlambda
);
860 /* all_frames == nil doesn't specify which frames to include.
861 Decide which frames it includes. */
862 if (NILP (all_frames
))
863 all_frames
= (EQ (minibuf
, Qt
)
864 ? (FRAME_MINIBUF_WINDOW
867 (XWINDOW (window
)))))
869 else if (! EQ (all_frames
, Qt
))
871 /* Now all_frames is t meaning search all frames,
872 nil meaning search just current frame,
873 or a window, meaning search the frame that window belongs to. */
875 /* Do this loop at least once, to get the next window, and perhaps
876 again, if we hit the minibuffer and that is not acceptable. */
879 /* Find a window that actually has a next one. This loop
880 climbs up the tree. */
881 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
882 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
886 /* We've reached the end of this frame.
887 Which other frames are acceptable? */
888 tem
= WINDOW_FRAME (XWINDOW (window
));
890 if (! NILP (all_frames
))
891 tem
= next_frame (tem
, all_frames
);
893 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
900 /* If we're in a combination window, find its first child and
901 recurse on that. Otherwise, we've found the window we want. */
904 if (!NILP (XWINDOW (window
)->hchild
))
905 window
= XWINDOW (window
)->hchild
;
906 else if (!NILP (XWINDOW (window
)->vchild
))
907 window
= XWINDOW (window
)->vchild
;
911 /* Which windows are acceptible?
912 Exit the loop and accept this window if
913 this isn't a minibuffer window, or
914 we're accepting minibuffer windows, or
915 we've come all the way around and we're back at the original window. */
916 while (MINI_WINDOW_P (XWINDOW (window
))
917 && ! EQ (minibuf
, Qt
)
918 && ! EQ (window
, start_window
));
923 /* This comment supplies the doc string for `previous-window',
924 for make-docfile to see. We cannot put this in the real DEFUN
925 due to limits in the Unix cpp.
927 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
928 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
929 If omitted, WINDOW defaults to the selected window.\n\
931 Optional second arg MINIBUF t means count the minibuffer window even\n\
932 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
933 it is active. MINIBUF neither t nor nil means not to count the\n\
934 minibuffer even if it is active.\n\
936 Several frames may share a single minibuffer; if the minibuffer\n\
937 counts, all windows on all frames that share that minibuffer count\n\
938 too. This means that previous-window may be used to iterate through\n\
939 the set of windows even when the minibuffer is on another frame. If\n\
940 the minibuffer does not count, only windows from WINDOW's frame\n\
943 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
944 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
945 above. If neither nil nor t, restrict to WINDOW's frame.\n\
947 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
948 `previous-window' to iterate through the entire cycle of acceptable\n\
949 windows, eventually ending up back at the window you started with.\n\
950 `next-window' traverses the same cycle, in the reverse order.")
951 (window, minibuf, all_frames) */
954 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
956 (window
, minibuf
, all_frames
)
957 register Lisp_Object window
, minibuf
, all_frames
;
959 register Lisp_Object tem
;
960 Lisp_Object start_window
;
963 window
= selected_window
;
965 CHECK_LIVE_WINDOW (window
, 0);
967 start_window
= window
;
969 /* minibuf == nil may or may not include minibuffers.
970 Decide if it does. */
972 minibuf
= (minibuf_level
? Qt
: Qlambda
);
974 /* all_frames == nil doesn't specify which frames to include.
975 Decide which frames it includes. */
976 if (NILP (all_frames
))
977 all_frames
= (EQ (minibuf
, Qt
)
978 ? (FRAME_MINIBUF_WINDOW
981 (XWINDOW (window
)))))
983 else if (! EQ (all_frames
, Qt
))
985 /* Now all_frames is t meaning search all frames,
986 nil meaning search just current frame,
987 or a window, meaning search the frame that window belongs to. */
989 /* Do this loop at least once, to get the previous window, and perhaps
990 again, if we hit the minibuffer and that is not acceptable. */
993 /* Find a window that actually has a previous one. This loop
994 climbs up the tree. */
995 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
996 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1000 /* We have found the top window on the frame.
1001 Which frames are acceptable? */
1002 tem
= WINDOW_FRAME (XWINDOW (window
));
1004 if (! NILP (all_frames
))
1005 /* It's actually important that we use prev_frame here,
1006 rather than next_frame. All the windows acceptable
1007 according to the given parameters should form a ring;
1008 Fnext_window and Fprevious_window should go back and
1009 forth around the ring. If we use next_frame here,
1010 then Fnext_window and Fprevious_window take different
1011 paths through the set of acceptable windows.
1012 window_loop assumes that these `ring' requirement are
1014 tem
= prev_frame (tem
, all_frames
);
1016 /* If this frame has a minibuffer, find that window first,
1017 because it is conceptually the last window in that frame. */
1018 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1019 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1021 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1027 /* If we're in a combination window, find its last child and
1028 recurse on that. Otherwise, we've found the window we want. */
1031 if (!NILP (XWINDOW (window
)->hchild
))
1032 window
= XWINDOW (window
)->hchild
;
1033 else if (!NILP (XWINDOW (window
)->vchild
))
1034 window
= XWINDOW (window
)->vchild
;
1036 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1040 /* Which windows are acceptable?
1041 Exit the loop and accept this window if
1042 this isn't a minibuffer window, or
1043 we're accepting minibuffer windows, or
1044 we've come all the way around and we're back at the original window. */
1045 while (MINI_WINDOW_P (XWINDOW (window
))
1046 && !EQ (minibuf
, Qt
)
1047 && !EQ (window
, start_window
));
1052 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1053 "Select the ARG'th different window on this frame.\n\
1054 All windows on current frame are arranged in a cyclic order.\n\
1055 This command selects the window ARG steps away in that order.\n\
1056 A negative ARG moves in the opposite order. If the optional second\n\
1057 argument ALL_FRAMES is non-nil, cycle through all frames.")
1059 register Lisp_Object n
, all_frames
;
1062 register Lisp_Object w
;
1064 CHECK_NUMBER (n
, 0);
1065 w
= selected_window
;
1070 w
= Fnext_window (w
, Qnil
, all_frames
);
1075 w
= Fprevious_window (w
, Qnil
, all_frames
);
1082 /* Look at all windows, performing an operation specified by TYPE
1084 If FRAMES is Qt, look at all frames;
1085 Qnil, look at just the selected frame;
1086 a frame, just look at windows on that frame.
1087 If MINI is non-zero, perform the operation on minibuffer windows too.
1093 GET_BUFFER_WINDOW
, /* Arg is buffer */
1094 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1095 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1096 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1098 UNSHOW_BUFFER
/* Arg is buffer */
1102 window_loop (type
, obj
, mini
, frames
)
1103 enum window_loop type
;
1104 register Lisp_Object obj
, frames
;
1107 register Lisp_Object w
;
1108 register Lisp_Object best_window
;
1109 register Lisp_Object next_window
;
1110 register Lisp_Object last_window
;
1114 /* If we're only looping through windows on a particular frame,
1115 frame points to that frame. If we're looping through windows
1116 on all frames, frame is 0. */
1117 if (FRAMEP (frames
))
1118 frame
= XFRAME (frames
);
1119 else if (NILP (frames
))
1120 frame
= selected_frame
;
1127 /* Pick a window to start with. */
1128 if (XTYPE (obj
) == Lisp_Window
)
1131 w
= FRAME_SELECTED_WINDOW (frame
);
1133 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1135 /* Figure out the last window we're going to mess with. Since
1136 Fnext_window, given the same options, is guaranteed to go in a
1137 ring, we can just use Fprevious_window to find the last one.
1139 We can't just wait until we hit the first window again, because
1140 it might be deleted. */
1144 last_window
= Fprevious_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1146 #endif /* MULTI_FRAME */
1147 /* We know frame is 0, so we're looping through all frames.
1148 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1149 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, Qt
);
1154 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1156 /* Pick the next window now, since some operations will delete
1157 the current window. */
1160 next_window
= Fnext_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1162 #endif /* MULTI_FRAME */
1163 /* We know frame is 0, so we're looping through all frames.
1164 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1165 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, Qt
);
1167 if (! MINI_WINDOW_P (XWINDOW (w
))
1168 || (mini
&& minibuf_level
> 0))
1171 case GET_BUFFER_WINDOW
:
1172 /* Ignore invisible and iconified frames. */
1173 if (! FRAME_VISIBLE_P (w_frame
)
1174 || FRAME_ICONIFIED_P (w_frame
))
1176 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1180 case GET_LRU_WINDOW
:
1181 /* t as arg means consider only full-width windows */
1182 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1183 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1186 /* Ignore invisible and iconified frames. */
1187 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1188 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1191 /* Ignore dedicated windows and minibuffers. */
1192 if (MINI_WINDOW_P (XWINDOW (w
))
1193 || !NILP (XWINDOW (w
)->dedicated
))
1195 if (NILP (best_window
)
1196 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1197 > XFASTINT (XWINDOW (w
)->use_time
)))
1201 case DELETE_OTHER_WINDOWS
:
1202 if (XWINDOW (w
) != XWINDOW (obj
))
1206 case DELETE_BUFFER_WINDOWS
:
1207 if (EQ (XWINDOW (w
)->buffer
, obj
))
1209 /* If we're deleting the buffer displayed in the only window
1210 on the frame, find a new buffer to display there. */
1211 if (NILP (XWINDOW (w
)->parent
))
1213 Lisp_Object new_buffer
= Fother_buffer (obj
, Qnil
);
1214 if (NILP (new_buffer
))
1216 = Fget_buffer_create (build_string ("*scratch*"));
1217 Fset_window_buffer (w
, new_buffer
);
1218 if (EQ (w
, selected_window
))
1219 Fset_buffer (XWINDOW (w
)->buffer
);
1226 case GET_LARGEST_WINDOW
:
1228 /* Ignore invisible and iconified frames. */
1229 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1230 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1233 /* Ignore dedicated windows and minibuffers. */
1234 if (MINI_WINDOW_P (XWINDOW (w
))
1235 || !NILP (XWINDOW (w
)->dedicated
))
1238 struct window
*best_window_ptr
= XWINDOW (best_window
);
1239 struct window
*w_ptr
= XWINDOW (w
);
1240 if (NILP (best_window
) ||
1241 (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
))
1242 > (XFASTINT (best_window_ptr
->height
)
1243 * XFASTINT (best_window_ptr
->width
)))
1249 if (EQ (XWINDOW (w
)->buffer
, obj
))
1251 /* Find another buffer to show in this window. */
1252 Lisp_Object another_buffer
= Fother_buffer (obj
, Qnil
);
1253 if (NILP (another_buffer
))
1255 = Fget_buffer_create (build_string ("*scratch*"));
1256 Fset_window_buffer (w
, another_buffer
);
1257 if (EQ (w
, selected_window
))
1258 Fset_buffer (XWINDOW (w
)->buffer
);
1263 if (EQ (w
, last_window
))
1272 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1273 "Return the window least recently selected or used for display.\n\
1274 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1275 frame, search only that frame.\n")
1279 register Lisp_Object w
;
1280 /* First try for a window that is full-width */
1281 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frames
);
1282 if (!NILP (w
) && !EQ (w
, selected_window
))
1284 /* If none of them, try the rest */
1285 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frames
);
1288 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1289 "Return the largest window in area.\n\
1290 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1291 frame, search only that frame.\n")
1295 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1299 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1300 "Return a window currently displaying BUFFER, or nil if none.\n\
1301 If optional argument FRAME is t, search all visible frames.\n\
1302 If FRAME is nil, search only the selected frame.\n\
1303 If FRAME is a frame, search only that frame.\n")
1305 Lisp_Object buffer
, frame
;
1307 buffer
= Fget_buffer (buffer
);
1308 if (XTYPE (buffer
) == Lisp_Buffer
)
1309 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1314 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1316 "Make WINDOW (or the selected window) fill its frame.\n\
1317 Only the frame WINDOW is on is affected.\n\
1318 This function tries to reduce display jumps\n\
1319 by keeping the text previously visible in WINDOW\n\
1320 in the same place on the frame. Doing this depends on\n\
1321 the value of (window-start WINDOW), so if calling this function\n\
1322 in a program gives strange scrolling, make sure the window-start\n\
1323 value is reasonable when this function is called.")
1328 struct buffer
*obuf
= current_buffer
;
1333 window
= selected_window
;
1335 CHECK_LIVE_WINDOW (window
, 0);
1337 w
= XWINDOW (window
);
1338 top
= XFASTINT (w
->top
);
1340 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1342 Fset_buffer (w
->buffer
);
1344 SET_PT (marker_position (w
->start
));
1345 Frecenter (make_number (top
- FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)))));
1348 set_buffer_internal (obuf
);
1352 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1353 1, 2, "bDelete windows on (buffer): ",
1354 "Delete all windows showing BUFFER.\n\
1355 Optional second argument FRAME controls which frames are affected.\n\
1356 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1357 If t, delete only windows showing BUFFER in the selected frame.\n\
1358 If a frame, delete only windows showing BUFFER in that frame.")
1360 Lisp_Object buffer
, frame
;
1363 /* FRAME uses t and nil to mean the opposite of what window_loop
1365 if (! FRAMEP (frame
))
1366 frame
= NILP (frame
) ? Qt
: Qnil
;
1373 buffer
= Fget_buffer (buffer
);
1374 CHECK_BUFFER (buffer
, 0);
1375 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1380 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1381 Sreplace_buffer_in_windows
,
1382 1, 1, "bReplace buffer in windows: ",
1383 "Replace BUFFER with some other buffer in all windows showing it.")
1389 buffer
= Fget_buffer (buffer
);
1390 CHECK_BUFFER (buffer
, 0);
1391 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1396 /* Set the height of WINDOW and all its inferiors. */
1398 /* The smallest acceptable dimensions for a window. Anything smaller
1399 might crash Emacs. */
1400 #define MIN_SAFE_WINDOW_WIDTH (2)
1401 #define MIN_SAFE_WINDOW_HEIGHT (2)
1403 /* Make sure that window_min_height and window_min_width are
1404 not too small; if they are, set them to safe minima. */
1407 check_min_window_sizes ()
1409 /* Smaller values might permit a crash. */
1410 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1411 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1412 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1413 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1416 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1417 minimum allowable size. */
1419 check_frame_size (frame
, rows
, cols
)
1423 /* For height, we have to see:
1424 whether the frame has a minibuffer,
1425 whether it wants a mode line, and
1426 whether it has a menu bar. */
1428 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1429 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1430 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1431 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1432 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1434 if (*rows
< min_height
)
1436 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1437 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1440 /* Normally the window is deleted if it gets too small.
1441 nodelete nonzero means do not do this.
1442 (The caller should check later and do so if appropriate) */
1444 set_window_height (window
, height
, nodelete
)
1449 register struct window
*w
= XWINDOW (window
);
1450 register struct window
*c
;
1451 int oheight
= XFASTINT (w
->height
);
1452 int top
, pos
, lastbot
, opos
, lastobot
;
1455 check_min_window_sizes ();
1458 && ! NILP (w
->parent
)
1459 && height
< window_min_height
)
1461 Fdelete_window (window
);
1465 XFASTINT (w
->last_modified
) = 0;
1466 windows_or_buffers_changed
++;
1467 XFASTINT (w
->height
) = height
;
1468 if (!NILP (w
->hchild
))
1470 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1472 XWINDOW (child
)->top
= w
->top
;
1473 set_window_height (child
, height
, nodelete
);
1476 else if (!NILP (w
->vchild
))
1478 lastbot
= top
= XFASTINT (w
->top
);
1480 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1482 c
= XWINDOW (child
);
1484 opos
= lastobot
+ XFASTINT (c
->height
);
1486 XFASTINT (c
->top
) = lastbot
;
1488 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1490 /* Avoid confusion: inhibit deletion of child if becomes too small */
1491 set_window_height (child
, pos
+ top
- lastbot
, 1);
1493 /* Now advance child to next window,
1494 and set lastbot if child was not just deleted. */
1495 lastbot
= pos
+ top
;
1498 /* Now delete any children that became too small. */
1500 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1502 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1507 /* Recursively set width of WINDOW and its inferiors. */
1509 set_window_width (window
, width
, nodelete
)
1514 register struct window
*w
= XWINDOW (window
);
1515 register struct window
*c
;
1516 int owidth
= XFASTINT (w
->width
);
1517 int left
, pos
, lastright
, opos
, lastoright
;
1520 if (!nodelete
&& width
< window_min_width
)
1522 Fdelete_window (window
);
1526 XFASTINT (w
->last_modified
) = 0;
1527 windows_or_buffers_changed
++;
1528 XFASTINT (w
->width
) = width
;
1529 if (!NILP (w
->vchild
))
1531 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1533 XWINDOW (child
)->left
= w
->left
;
1534 set_window_width (child
, width
, nodelete
);
1537 else if (!NILP (w
->hchild
))
1539 lastright
= left
= XFASTINT (w
->left
);
1541 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1543 c
= XWINDOW (child
);
1545 opos
= lastoright
+ XFASTINT (c
->width
);
1547 XFASTINT (c
->left
) = lastright
;
1549 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1551 /* Inhibit deletion for becoming too small */
1552 set_window_width (child
, pos
+ left
- lastright
, 1);
1554 /* Now advance child to next window,
1555 and set lastright if child was not just deleted. */
1556 lastright
= pos
+ left
, lastoright
= opos
;
1558 /* Delete children that became too small */
1560 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1562 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1567 int window_select_count
;
1569 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1570 "Make WINDOW display BUFFER as its contents.\n\
1571 BUFFER can be a buffer or buffer name.")
1573 register Lisp_Object window
, buffer
;
1575 register Lisp_Object tem
;
1576 register struct window
*w
= decode_window (window
);
1578 buffer
= Fget_buffer (buffer
);
1579 CHECK_BUFFER (buffer
, 1);
1581 if (NILP (XBUFFER (buffer
)->name
))
1582 error ("Attempt to display deleted buffer");
1586 error ("Window is deleted");
1587 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1588 is first being set up. */
1590 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1591 error ("Window is dedicated to %s\n", tem
);
1597 w
->window_end_pos
= 0;
1598 w
->window_end_valid
= Qnil
;
1600 Fset_marker (w
->pointm
,
1601 make_number (BUF_PT (XBUFFER (buffer
))),
1603 set_marker_restricted (w
->start
,
1604 make_number (XBUFFER (buffer
)->last_window_start
),
1606 w
->start_at_line_beg
= Qnil
;
1607 w
->force_start
= Qnil
;
1608 XFASTINT (w
->last_modified
) = 0;
1609 windows_or_buffers_changed
++;
1610 if (EQ (window
, selected_window
))
1611 Fset_buffer (buffer
);
1616 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1617 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1618 The main editor command loop selects the buffer of the selected window\n\
1619 before each command.")
1621 register Lisp_Object window
;
1623 register struct window
*w
;
1624 register struct window
*ow
= XWINDOW (selected_window
);
1626 CHECK_LIVE_WINDOW (window
, 0);
1628 w
= XWINDOW (window
);
1630 if (NILP (w
->buffer
))
1631 error ("Trying to select deleted window or non-leaf window");
1633 XFASTINT (w
->use_time
) = ++window_select_count
;
1634 if (EQ (window
, selected_window
))
1637 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1640 selected_window
= window
;
1642 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1644 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1645 Fhandle_switch_frame (WINDOW_FRAME (w
), Qnil
);
1648 selected_frame
->selected_window
= window
;
1651 record_buffer (w
->buffer
);
1652 Fset_buffer (w
->buffer
);
1654 /* Go to the point recorded in the window.
1655 This is important when the buffer is in more
1656 than one window. It also matters when
1657 redisplay_window has altered point after scrolling,
1658 because it makes the change only in the window. */
1660 register int new_point
= marker_position (w
->pointm
);
1661 if (new_point
< BEGV
)
1669 windows_or_buffers_changed
++;
1673 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1674 "BDisplay buffer: \nP",
1675 "Make BUFFER appear in some window but don't select it.\n\
1676 BUFFER can be a buffer or a buffer name.\n\
1677 If BUFFER is shown already in some window, just use that one,\n\
1678 unless the window is the selected window and the optional second\n\
1679 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1680 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1681 Returns the window displaying BUFFER.")
1682 (buffer
, not_this_window
)
1683 register Lisp_Object buffer
, not_this_window
;
1685 register Lisp_Object window
;
1687 buffer
= Fget_buffer (buffer
);
1688 CHECK_BUFFER (buffer
, 0);
1690 if (!NILP (Vdisplay_buffer_function
))
1691 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1693 if (NILP (not_this_window
)
1694 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1695 return selected_window
;
1697 /* If pop_up_frames, look for a window on any frame, showing BUFFER. */
1698 window
= Fget_buffer_window (buffer
, pop_up_frames
? Qt
: Qnil
);
1700 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1704 /* If there are no frames open that have more than a minibuffer,
1705 we need to create a new frame. */
1706 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1709 = Fframe_selected_window (call0 (Vpop_up_frame_function
));
1710 Fset_window_buffer (window
, buffer
);
1712 Fhandle_switch_frame (XWINDOW (window
)->frame
, Qnil
);
1716 #endif /* MULTI_FRAME */
1720 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1724 Lisp_Object frames
= Qnil
;
1727 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1728 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1730 /* Don't try to create a window if would get an error */
1731 if (split_height_threshold
< window_min_height
<< 1)
1732 split_height_threshold
= window_min_height
<< 1;
1734 window
= Fget_largest_window (frames
);
1737 && window_height (window
) >= split_height_threshold
1738 && (XFASTINT (XWINDOW (window
)->width
)
1739 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1740 window
= Fsplit_window (window
, Qnil
, Qnil
);
1743 window
= Fget_lru_window (frames
);
1744 if ((EQ (window
, selected_window
)
1745 || EQ (XWINDOW (window
)->parent
, Qnil
))
1746 && window_height (window
) >= window_min_height
<< 1)
1747 window
= Fsplit_window (window
, Qnil
, Qnil
);
1751 window
= Fget_lru_window (Qnil
);
1753 Fset_window_buffer (window
, buffer
);
1758 temp_output_buffer_show (buf
)
1759 register Lisp_Object buf
;
1761 register struct buffer
*old
= current_buffer
;
1762 register Lisp_Object window
;
1763 register struct window
*w
;
1766 XBUFFER (buf
)->save_modified
= MODIFF
;
1771 set_buffer_internal (old
);
1773 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1774 call1 (Vtemp_buffer_show_function
, buf
);
1777 window
= Fdisplay_buffer (buf
, Qnil
);
1780 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1781 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1782 #endif /* MULTI_FRAME */
1783 Vminibuf_scroll_window
= window
;
1784 w
= XWINDOW (window
);
1785 XFASTINT (w
->hscroll
) = 0;
1786 set_marker_restricted (w
->start
, make_number (1), buf
);
1787 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1792 make_dummy_parent (window
)
1795 register Lisp_Object old
, new;
1796 register struct window
*o
, *p
;
1799 XSETTYPE (old
, Lisp_Vector
);
1800 new = Fcopy_sequence (old
);
1801 XSETTYPE (new, Lisp_Window
);
1805 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1807 /* Put new into window structure in place of window */
1808 replace_window (window
, new);
1821 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1822 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1823 WINDOW defaults to selected one and SIZE to half its size.\n\
1824 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1825 and put SIZE columns in the first of the pair.")
1826 (window
, chsize
, horflag
)
1827 Lisp_Object window
, chsize
, horflag
;
1829 register Lisp_Object
new;
1830 register struct window
*o
, *p
;
1834 window
= selected_window
;
1836 CHECK_LIVE_WINDOW (window
, 0);
1838 o
= XWINDOW (window
);
1842 if (!NILP (horflag
))
1843 /* Round odd size up, since this is for the left-hand window,
1844 and it will lose a column for the separators. */
1845 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1847 size
= XFASTINT (o
->height
) >> 1;
1851 CHECK_NUMBER (chsize
, 1);
1852 size
= XINT (chsize
);
1855 if (MINI_WINDOW_P (o
))
1856 error ("Attempt to split minibuffer window");
1857 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1858 error ("Attempt to split unsplittable frame");
1860 check_min_window_sizes ();
1864 if (size
< window_min_height
1865 || size
+ window_min_height
> XFASTINT (o
->height
))
1866 args_out_of_range_3 (window
, chsize
, horflag
);
1867 if (NILP (o
->parent
)
1868 || NILP (XWINDOW (o
->parent
)->vchild
))
1870 make_dummy_parent (window
);
1872 XWINDOW (new)->vchild
= window
;
1877 if (size
< window_min_width
1878 || size
+ window_min_width
> XFASTINT (o
->width
))
1879 args_out_of_range_3 (window
, chsize
, horflag
);
1880 if (NILP (o
->parent
)
1881 || NILP (XWINDOW (o
->parent
)->hchild
))
1883 make_dummy_parent (window
);
1885 XWINDOW (new)->hchild
= window
;
1889 /* Now we know that window's parent is a vertical combination
1890 if we are dividing vertically, or a horizontal combination
1891 if we are making side-by-side windows */
1893 windows_or_buffers_changed
++;
1894 new = make_window ();
1897 p
->frame
= o
->frame
;
1899 if (!NILP (p
->next
))
1900 XWINDOW (p
->next
)->prev
= new;
1903 p
->parent
= o
->parent
;
1906 Fset_window_buffer (new, o
->buffer
);
1908 /* Apportion the available frame space among the two new windows */
1910 if (!NILP (horflag
))
1912 p
->height
= o
->height
;
1914 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1915 XFASTINT (o
->width
) = size
;
1916 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1921 p
->width
= o
->width
;
1922 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1923 XFASTINT (o
->height
) = size
;
1924 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
1930 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
1931 "Make current window ARG lines bigger.\n\
1932 From program, optional second arg non-nil means grow sideways ARG columns.")
1934 register Lisp_Object n
, side
;
1936 CHECK_NUMBER (n
, 0);
1937 change_window_height (XINT (n
), !NILP (side
));
1941 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
1942 "Make current window ARG lines smaller.\n\
1943 From program, optional second arg non-nil means shrink sideways ARG columns.")
1945 register Lisp_Object n
, side
;
1947 CHECK_NUMBER (n
, 0);
1948 change_window_height (-XINT (n
), !NILP (side
));
1953 window_height (window
)
1956 register struct window
*p
= XWINDOW (window
);
1957 return XFASTINT (p
->height
);
1961 window_width (window
)
1964 register struct window
*p
= XWINDOW (window
);
1965 return XFASTINT (p
->width
);
1968 #define MINSIZE(w) \
1970 ? window_min_width \
1971 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
1974 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
1976 #define CURSIZE(w) \
1977 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
1979 /* Unlike set_window_height, this function
1980 also changes the heights of the siblings so as to
1981 keep everything consistent. */
1983 change_window_height (delta
, widthflag
)
1987 register Lisp_Object parent
;
1989 register struct window
*p
;
1991 int (*sizefun
) () = widthflag
? window_width
: window_height
;
1992 register int (*setsizefun
) () = (widthflag
1994 : set_window_height
);
1996 check_min_window_sizes ();
1998 window
= selected_window
;
2001 p
= XWINDOW (window
);
2006 error ("No other window to side of this one");
2009 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2010 : !NILP (XWINDOW (parent
)->vchild
))
2015 sizep
= &CURSIZE (window
);
2017 if (*sizep
+ delta
< MINSIZE (window
))
2019 Fdelete_window (window
);
2024 register int maxdelta
;
2026 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2027 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2028 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2029 /* This is a frame with only one window, a minibuffer-only
2030 or a minibufferless frame. */
2033 if (delta
> maxdelta
)
2034 /* This case traps trying to make the minibuffer
2035 the full frame, or make the only window aside from the
2036 minibuffer the full frame. */
2043 if (!NILP (p
->next
) &&
2044 (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2046 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2047 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2048 CURBEG (p
->next
) += delta
;
2049 /* This does not change size of p->next,
2050 but it propagates the new top edge to its children */
2051 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2053 else if (!NILP (p
->prev
) &&
2054 (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2056 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2057 CURBEG (window
) -= delta
;
2058 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2062 register int delta1
;
2063 register int opht
= (*sizefun
) (parent
);
2065 /* If trying to grow this window to or beyond size of the parent,
2066 make delta1 so big that, on shrinking back down,
2067 all the siblings end up with less than one line and are deleted. */
2068 if (opht
<= *sizep
+ delta
)
2069 delta1
= opht
* opht
* 2;
2070 /* Otherwise, make delta1 just right so that if we add delta1
2071 lines to this window and to the parent, and then shrink
2072 the parent back to its original size, the new proportional
2073 size of this window will increase by delta. */
2075 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2077 /* Add delta1 lines or columns to this window, and to the parent,
2078 keeping things consistent while not affecting siblings. */
2079 CURSIZE (parent
) = opht
+ delta1
;
2080 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2082 /* Squeeze out delta1 lines or columns from our parent,
2083 shriking this window and siblings proportionately.
2084 This brings parent back to correct size.
2085 Delta1 was calculated so this makes this window the desired size,
2086 taking it all out of the siblings. */
2087 (*setsizefun
) (parent
, opht
, 0);
2090 XFASTINT (p
->last_modified
) = 0;
2097 /* Return number of lines of text (not counting mode line) in W. */
2100 window_internal_height (w
)
2103 int ht
= XFASTINT (w
->height
);
2105 if (MINI_WINDOW_P (w
))
2108 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2109 || !NILP (w
->next
) || !NILP (w
->prev
)
2110 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2117 /* Return the number of columns in W.
2118 Don't count columns occupied by scroll bars or the vertical bar
2119 separating W from the sibling to its right. */
2121 window_internal_width (w
)
2124 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2125 int left
= XINT (w
->left
);
2126 int width
= XINT (w
->width
);
2128 /* If this window is flush against the right edge of the frame, its
2129 internal width is its full width. */
2130 if (left
+ width
>= FRAME_WIDTH (f
))
2133 /* If we are not flush right, then our rightmost columns are
2134 occupied by some sort of separator. */
2136 /* Scroll bars occupy a few columns. */
2137 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2138 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2140 /* The column of `|' characters separating side-by-side windows
2141 occupies one column only. */
2146 /* Scroll contents of window WINDOW up N lines. */
2149 window_scroll (window
, n
, noerror
)
2154 register struct window
*w
= XWINDOW (window
);
2155 register int opoint
= point
;
2157 register int ht
= window_internal_height (w
);
2158 register Lisp_Object tem
;
2160 Lisp_Object bolp
, nmoved
;
2162 XFASTINT (tem
) = point
;
2163 tem
= Fpos_visible_in_window_p (tem
, window
);
2167 Fvertical_motion (make_number (- ht
/ 2));
2168 XFASTINT (tem
) = point
;
2169 Fset_marker (w
->start
, tem
, w
->buffer
);
2170 w
->force_start
= Qt
;
2173 SET_PT (marker_position (w
->start
));
2174 lose
= n
< 0 && point
== BEGV
;
2175 Fvertical_motion (make_number (n
));
2185 Fsignal (Qbeginning_of_buffer
, Qnil
);
2190 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2191 w
->start_at_line_beg
= bolp
;
2192 w
->update_mode_line
= Qt
;
2193 XFASTINT (w
->last_modified
) = 0;
2199 tem
= Fvertical_motion (make_number (ht
));
2200 if (point
> opoint
|| XFASTINT (tem
) < ht
)
2203 Fvertical_motion (make_number (-1));
2211 Fsignal (Qend_of_buffer
, Qnil
);
2215 /* This is the guts of Fscroll_up and Fscroll_down. */
2218 scroll_command (n
, direction
)
2219 register Lisp_Object n
;
2222 register int defalt
;
2223 int count
= specpdl_ptr
- specpdl
;
2225 /* If selected window's buffer isn't current, make it current for the moment.
2226 But don't screw up if window_scroll gets an error. */
2227 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2229 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2230 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2233 defalt
= (window_internal_height (XWINDOW (selected_window
))
2234 - next_screen_context_lines
);
2235 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2238 window_scroll (selected_window
, defalt
, 0);
2239 else if (EQ (n
, Qminus
))
2240 window_scroll (selected_window
, - defalt
, 0);
2243 n
= Fprefix_numeric_value (n
);
2244 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2247 unbind_to (count
, Qnil
);
2250 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2251 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2252 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2253 When calling from a program, supply a number as argument or nil.")
2257 scroll_command (n
, 1);
2261 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2262 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2263 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2264 When calling from a program, supply a number as argument or nil.")
2268 scroll_command (n
, -1);
2272 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2273 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2274 The next window is the one below the current one; or the one at the top\n\
2275 if the current one is at the bottom.\n\
2276 When calling from a program, supply a number as argument or nil.\n\
2278 If in the minibuffer, `minibuf-scroll-window' if non-nil\n\
2279 specifies the window to scroll.\n\
2280 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2281 showing that buffer, popping the buffer up if necessary.")
2283 register Lisp_Object n
;
2285 register Lisp_Object window
;
2287 register struct window
*w
;
2288 register int count
= specpdl_ptr
- specpdl
;
2290 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2291 && !NILP (Vminibuf_scroll_window
))
2292 window
= Vminibuf_scroll_window
;
2293 /* If buffer is specified, scroll that buffer. */
2294 else if (!NILP (Vother_window_scroll_buffer
))
2296 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2298 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2302 /* Nothing specified; look for a neighboring window on the same
2304 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2306 if (EQ (window
, selected_window
))
2307 /* That didn't get us anywhere; look for a window on another
2310 window
= Fnext_window (window
, Qnil
, Qt
);
2311 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2312 && ! EQ (window
, selected_window
));
2315 CHECK_LIVE_WINDOW (window
, 0);
2317 if (EQ (window
, selected_window
))
2318 error ("There is no other window");
2320 w
= XWINDOW (window
);
2321 ht
= window_internal_height (w
);
2323 /* Don't screw up if window_scroll gets an error. */
2324 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2326 Fset_buffer (w
->buffer
);
2327 SET_PT (marker_position (w
->pointm
));
2330 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2331 else if (EQ (n
, Qminus
))
2332 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2335 if (XTYPE (n
) == Lisp_Cons
)
2337 CHECK_NUMBER (n
, 0);
2338 window_scroll (window
, XINT (n
), 1);
2341 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
2342 unbind_to (count
, Qnil
);
2347 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2348 "Scroll selected window display ARG columns left.\n\
2349 Default for ARG is window width minus 2.")
2351 register Lisp_Object arg
;
2355 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2357 arg
= Fprefix_numeric_value (arg
);
2360 Fset_window_hscroll (selected_window
,
2361 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2365 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2366 "Scroll selected window display ARG columns right.\n\
2367 Default for ARG is window width minus 2.")
2369 register Lisp_Object arg
;
2372 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2374 arg
= Fprefix_numeric_value (arg
);
2377 Fset_window_hscroll (selected_window
,
2378 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2382 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2383 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2384 The desired position of point is always relative to the current window.\n\
2385 Just C-u as prefix means put point in the center of the window.\n\
2386 No arg (i.e., it is nil) erases the entire frame and then\n\
2387 redraws with point in the center of the current window.")
2389 register Lisp_Object n
;
2391 register struct window
*w
= XWINDOW (selected_window
);
2392 register int ht
= window_internal_height (w
);
2393 register int opoint
= point
;
2397 extern int frame_garbaged
;
2399 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2400 XFASTINT (n
) = ht
/ 2;
2402 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2404 XFASTINT (n
) = ht
/ 2;
2408 n
= Fprefix_numeric_value (n
);
2409 CHECK_NUMBER (n
, 0);
2413 XSETINT (n
, XINT (n
) + ht
);
2415 XSETINT (n
, - XINT (n
));
2417 Fvertical_motion (n
);
2418 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2419 w
->start_at_line_beg
= Fbolp ();
2422 w
->force_start
= Qt
;
2427 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2429 "Position point relative to window.\n\
2430 With no argument, position text at center of window.\n\
2431 An argument specifies frame line; zero means top of window,\n\
2432 negative means relative to bottom of window.")
2434 register Lisp_Object arg
;
2436 register struct window
*w
= XWINDOW (selected_window
);
2437 register int height
= window_internal_height (w
);
2441 XFASTINT (arg
) = height
/ 2;
2444 arg
= Fprefix_numeric_value (arg
);
2446 XSETINT (arg
, XINT (arg
) + height
);
2449 start
= marker_position (w
->start
);
2450 if (start
< BEGV
|| start
> ZV
)
2452 Fvertical_motion (make_number (- height
/ 2));
2453 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2454 w
->start_at_line_beg
= Fbolp ();
2455 w
->force_start
= Qt
;
2460 return Fvertical_motion (arg
);
2463 struct save_window_data
2465 int size_from_Lisp_Vector_struct
;
2466 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2467 Lisp_Object frame_width
, frame_height
;
2468 Lisp_Object selected_frame
;
2469 Lisp_Object current_window
;
2470 Lisp_Object current_buffer
;
2471 Lisp_Object minibuf_scroll_window
;
2472 Lisp_Object root_window
;
2473 Lisp_Object focus_frame
;
2474 /* A vector, interpreted as a struct saved_window */
2475 Lisp_Object saved_windows
;
2478 /* Arg to Fmake_vector */
2479 #define SAVE_WINDOW_DATA_SIZE \
2480 ((sizeof (struct save_window_data) \
2481 - (sizeof (struct Lisp_Vector) \
2482 /* Don't count the contents member of the struct Lisp_Vector */ \
2483 - sizeof (Lisp_Object))) \
2484 / sizeof (Lisp_Object))
2486 /* This is saved as a Lisp_Vector */
2489 /* these first two must agree with struct Lisp_Vector in lisp.h */
2490 int size_from_Lisp_Vector_struct
;
2491 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2494 Lisp_Object buffer
, start
, pointm
, mark
;
2495 Lisp_Object left
, top
, width
, height
, hscroll
;
2496 Lisp_Object parent
, prev
;
2497 Lisp_Object start_at_line_beg
;
2498 Lisp_Object display_table
;
2500 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2502 #define SAVED_WINDOW_N(swv,n) \
2503 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2505 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2506 "T if OBJECT is a window-configration object.")
2510 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2516 DEFUN ("set-window-configuration", Fset_window_configuration
,
2517 Sset_window_configuration
, 1, 1, 0,
2518 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2519 CONFIGURATION must be a value previously returned\n\
2520 by `current-window-configuration' (which see).")
2522 Lisp_Object configuration
;
2524 register struct save_window_data
*data
;
2525 struct Lisp_Vector
*saved_windows
;
2526 Lisp_Object new_current_buffer
;
2530 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2532 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2536 data
= (struct save_window_data
*) XVECTOR (configuration
);
2537 saved_windows
= XVECTOR (data
->saved_windows
);
2539 new_current_buffer
= data
->current_buffer
;
2540 if (NILP (XBUFFER (new_current_buffer
)->name
))
2541 new_current_buffer
= Qnil
;
2543 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2546 /* If f is a dead frame, don't bother rebuilding its window tree.
2547 However, there is other stuff we should still try to do below. */
2548 if (FRAME_LIVE_P (f
))
2550 register struct window
*w
;
2551 register struct saved_window
*p
;
2554 /* If the frame has been resized since this window configuration was
2555 made, we change the frame to the size specified in the
2556 configuration, restore the configuration, and then resize it
2557 back. We keep track of the prevailing height in these variables. */
2558 int previous_frame_height
= FRAME_HEIGHT (f
);
2559 int previous_frame_width
= FRAME_WIDTH (f
);
2561 if (XFASTINT (data
->frame_height
) != previous_frame_height
2562 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2563 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2565 windows_or_buffers_changed
++;
2568 Mark all windows now on frame as "deleted".
2569 Restoring the new configuration "undeletes" any that are in it.
2571 Save their current buffers in their height fields, since we may
2572 need it later, if a buffer saved in the configuration is now
2574 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2576 for (k
= 0; k
< saved_windows
->size
; k
++)
2578 p
= SAVED_WINDOW_N (saved_windows
, k
);
2579 w
= XWINDOW (p
->window
);
2582 if (!NILP (p
->parent
))
2583 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2584 XFASTINT (p
->parent
))->window
;
2588 if (!NILP (p
->prev
))
2590 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2591 XFASTINT (p
->prev
))->window
;
2592 XWINDOW (w
->prev
)->next
= p
->window
;
2597 if (!NILP (w
->parent
))
2599 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2601 XWINDOW (w
->parent
)->vchild
= p
->window
;
2602 XWINDOW (w
->parent
)->hchild
= Qnil
;
2606 XWINDOW (w
->parent
)->hchild
= p
->window
;
2607 XWINDOW (w
->parent
)->vchild
= Qnil
;
2612 /* If we squirreled away the buffer in the window's height,
2614 if (XTYPE (w
->height
) == Lisp_Buffer
)
2615 w
->buffer
= w
->height
;
2618 w
->width
= p
->width
;
2619 w
->height
= p
->height
;
2620 w
->hscroll
= p
->hscroll
;
2621 w
->display_table
= p
->display_table
;
2622 XFASTINT (w
->last_modified
) = 0;
2624 /* Reinstall the saved buffer and pointers into it. */
2625 if (NILP (p
->buffer
))
2626 w
->buffer
= p
->buffer
;
2629 if (!NILP (XBUFFER (p
->buffer
)->name
))
2630 /* If saved buffer is alive, install it. */
2632 w
->buffer
= p
->buffer
;
2633 w
->start_at_line_beg
= p
->start_at_line_beg
;
2634 set_marker_restricted (w
->start
,
2635 Fmarker_position (p
->start
),
2637 set_marker_restricted (w
->pointm
,
2638 Fmarker_position (p
->pointm
),
2640 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2641 Fmarker_position (p
->mark
), w
->buffer
);
2643 /* As documented in Fcurrent_window_configuration, don't
2644 save the location of point in the buffer which was current
2645 when the window configuration was recorded. */
2646 if (!EQ (p
->buffer
, new_current_buffer
) &&
2647 XBUFFER (p
->buffer
) == current_buffer
)
2648 Fgoto_char (w
->pointm
);
2650 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2651 /* Else unless window has a live buffer, get one. */
2653 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2654 /* This will set the markers to beginning of visible
2656 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2657 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2658 w
->start_at_line_beg
= Qt
;
2661 /* Keeping window's old buffer; make sure the markers
2664 /* Set window markers at start of visible range. */
2665 if (XMARKER (w
->start
)->buffer
== 0)
2666 set_marker_restricted (w
->start
, make_number (0),
2668 if (XMARKER (w
->pointm
)->buffer
== 0)
2669 set_marker_restricted (w
->pointm
,
2671 (BUF_PT (XBUFFER (w
->buffer
)))),
2673 w
->start_at_line_beg
= Qt
;
2678 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2679 Fselect_window (data
->current_window
);
2682 if (NILP (data
->focus_frame
)
2683 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2684 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2685 Fredirect_frame_focus (frame
, data
->focus_frame
);
2688 #if 0 /* I don't understand why this is needed, and it causes problems
2689 when the frame's old selected window has been deleted. */
2691 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2692 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2696 /* Set the screen height to the value it had before this function. */
2697 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2698 || previous_frame_width
!= FRAME_WIDTH (f
))
2699 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2704 /* Fselect_window will have made f the selected frame, so we
2705 reselect the proper frame here. Fhandle_switch_frame will change the
2706 selected window too, but that doesn't make the call to
2707 Fselect_window above totally superfluous; it still sets f's
2709 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2710 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2713 if (!NILP (new_current_buffer
))
2714 Fset_buffer (new_current_buffer
);
2716 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2720 /* Mark all windows now on frame as deleted
2721 by setting their buffers to nil. */
2724 delete_all_subwindows (w
)
2725 register struct window
*w
;
2727 if (!NILP (w
->next
))
2728 delete_all_subwindows (XWINDOW (w
->next
));
2729 if (!NILP (w
->vchild
))
2730 delete_all_subwindows (XWINDOW (w
->vchild
));
2731 if (!NILP (w
->hchild
))
2732 delete_all_subwindows (XWINDOW (w
->hchild
));
2734 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2736 /* We set all three of these fields to nil, to make sure that we can
2737 distinguish this dead window from any live window. Live leaf
2738 windows will have buffer set, and combination windows will have
2739 vchild or hchild set. */
2746 count_windows (window
)
2747 register struct window
*window
;
2749 register int count
= 1;
2750 if (!NILP (window
->next
))
2751 count
+= count_windows (XWINDOW (window
->next
));
2752 if (!NILP (window
->vchild
))
2753 count
+= count_windows (XWINDOW (window
->vchild
));
2754 if (!NILP (window
->hchild
))
2755 count
+= count_windows (XWINDOW (window
->hchild
));
2760 save_window_save (window
, vector
, i
)
2762 struct Lisp_Vector
*vector
;
2765 register struct saved_window
*p
;
2766 register struct window
*w
;
2767 register Lisp_Object tem
;
2769 for (;!NILP (window
); window
= w
->next
)
2771 p
= SAVED_WINDOW_N (vector
, i
);
2772 w
= XWINDOW (window
);
2774 XFASTINT (w
->temslot
) = i
++;
2776 p
->buffer
= w
->buffer
;
2779 p
->width
= w
->width
;
2780 p
->height
= w
->height
;
2781 p
->hscroll
= w
->hscroll
;
2782 p
->display_table
= w
->display_table
;
2783 if (!NILP (w
->buffer
))
2785 /* Save w's value of point in the window configuration.
2786 If w is the selected window, then get the value of point
2787 from the buffer; pointm is garbage in the selected window. */
2788 if (EQ (window
, selected_window
))
2790 p
->pointm
= Fmake_marker ();
2791 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2795 p
->pointm
= Fcopy_marker (w
->pointm
);
2797 p
->start
= Fcopy_marker (w
->start
);
2798 p
->start_at_line_beg
= w
->start_at_line_beg
;
2800 tem
= XBUFFER (w
->buffer
)->mark
;
2801 p
->mark
= Fcopy_marker (tem
);
2808 p
->start_at_line_beg
= Qnil
;
2811 if (NILP (w
->parent
))
2814 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2819 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2821 if (!NILP (w
->vchild
))
2822 i
= save_window_save (w
->vchild
, vector
, i
);
2823 if (!NILP (w
->hchild
))
2824 i
= save_window_save (w
->hchild
, vector
, i
);
2830 DEFUN ("current-window-configuration",
2831 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2832 "Return an object representing the current window configuration of FRAME.\n\
2833 If FRAME is nil or omitted, use the selected frame.\n\
2834 This describes the number of windows, their sizes and current buffers,\n\
2835 and for each displayed buffer, where display starts, and the positions of\n\
2836 point and mark. An exception is made for point in the current buffer:\n\
2837 its value is -not- saved.\n\
2838 This also records the currently selected frame, and FRAME's focus\n\
2839 redirection (see `redirect-frame-focus').")
2843 register Lisp_Object tem
;
2844 register int n_windows
;
2845 register struct save_window_data
*data
;
2853 CHECK_LIVE_FRAME (frame
, 0);
2857 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2858 data
= (struct save_window_data
*)
2859 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2861 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2862 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2864 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2866 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2867 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2868 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2869 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2870 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2871 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2872 data
->saved_windows
= tem
;
2873 for (i
= 0; i
< n_windows
; i
++)
2874 XVECTOR (tem
)->contents
[i
]
2875 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2876 save_window_save (FRAME_ROOT_WINDOW (f
),
2878 XSET (tem
, Lisp_Window_Configuration
, data
);
2882 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2884 "Execute body, preserving window sizes and contents.\n\
2885 Restores which buffer appears in which window, where display starts,\n\
2886 as well as the current buffer.\n\
2887 Does not restore the value of point in current buffer.")
2891 register Lisp_Object val
;
2892 register int count
= specpdl_ptr
- specpdl
;
2894 record_unwind_protect (Fset_window_configuration
,
2895 Fcurrent_window_configuration (Qnil
));
2896 val
= Fprogn (args
);
2897 return unbind_to (count
, val
);
2903 selected_frame
= make_terminal_frame ();
2904 minibuf_window
= selected_frame
->minibuffer_window
;
2905 selected_window
= selected_frame
->selected_window
;
2906 last_nonminibuf_frame
= selected_frame
;
2907 #else /* not MULTI_FRAME */
2908 extern Lisp_Object
get_minibuffer ();
2910 minibuf_window
= make_window ();
2911 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
2913 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
2914 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
2915 XWINDOW (minibuf_window
)->mini_p
= Qt
;
2917 /* These values 9 and 10 are arbitrary,
2918 just so that there is "something there."
2919 Correct values are put in in init_xdisp */
2921 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
2922 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
2924 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
2925 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
2926 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
2928 /* Prevent error in Fset_window_buffer. */
2929 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
2930 XWINDOW (minibuf_window
)->buffer
= Qt
;
2932 /* Now set them up for real. */
2933 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
2934 Fcurrent_buffer ());
2935 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
2937 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
2938 /* Make sure this window seems more recently used than
2939 a newly-created, never-selected window. Increment
2940 window_select_count so the first selection ever will get
2941 something newer than this. */
2942 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
2943 #endif /* not MULTI_FRAME */
2948 Qwindowp
= intern ("windowp");
2949 staticpro (&Qwindowp
);
2951 Qwindow_live_p
= intern ("window-live-p");
2952 staticpro (&Qwindow_live_p
);
2955 /* Make sure all windows get marked */
2956 staticpro (&minibuf_window
);
2959 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
2960 "Non-nil means call as function to display a help buffer.\n\
2961 Used by `with-output-to-temp-buffer'.");
2962 Vtemp_buffer_show_function
= Qnil
;
2964 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
2965 "If non-nil, function to call to handle `display-buffer'.\n\
2966 It will receive two args, the buffer and a flag which if non-nil means\n\
2967 that the currently selected window is not acceptable.\n\
2968 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
2969 work using this function.");
2970 Vdisplay_buffer_function
= Qnil
;
2972 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
2973 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
2974 Vminibuf_scroll_window
= Qnil
;
2976 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
2977 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
2978 Vother_window_scroll_buffer
= Qnil
;
2980 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
2981 "*Non-nil means `display-buffer' should make a separate frame.");
2984 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
2985 "*If non-nil, function to call to handle automatic new frame creation.\n\
2986 It is called with no arguments and should return a newly created frame.\n\
2988 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
2989 where `pop-up-frame-alist' would hold the default frame parameters.");
2990 Vpop_up_frame_function
= Qnil
;
2992 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
2993 "*Non-nil means display-buffer should make new windows.");
2996 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
2997 "*Number of lines of continuity when scrolling by screenfuls.");
2998 next_screen_context_lines
= 2;
3000 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3001 "*display-buffer would prefer to split the largest window if this large.\n\
3002 If there is only one window, it is split regardless of this value.");
3003 split_height_threshold
= 500;
3005 DEFVAR_INT ("window-min-height", &window_min_height
,
3006 "*Delete any window less than this tall (including its mode line).");
3007 window_min_height
= 4;
3009 DEFVAR_INT ("window-min-width", &window_min_width
,
3010 "*Delete any window less than this wide.");
3011 window_min_width
= 10;
3013 defsubr (&Sselected_window
);
3014 defsubr (&Sminibuffer_window
);
3015 defsubr (&Swindow_minibuffer_p
);
3016 defsubr (&Swindowp
);
3017 defsubr (&Swindow_live_p
);
3018 defsubr (&Spos_visible_in_window_p
);
3019 defsubr (&Swindow_buffer
);
3020 defsubr (&Swindow_height
);
3021 defsubr (&Swindow_width
);
3022 defsubr (&Swindow_hscroll
);
3023 defsubr (&Sset_window_hscroll
);
3024 defsubr (&Swindow_edges
);
3025 defsubr (&Scoordinates_in_window_p
);
3026 defsubr (&Swindow_at
);
3027 defsubr (&Swindow_point
);
3028 defsubr (&Swindow_start
);
3029 defsubr (&Swindow_end
);
3030 defsubr (&Sset_window_point
);
3031 defsubr (&Sset_window_start
);
3032 defsubr (&Swindow_dedicated_p
);
3033 defsubr (&Sset_window_dedicated_p
);
3034 defsubr (&Swindow_display_table
);
3035 defsubr (&Sset_window_display_table
);
3036 defsubr (&Snext_window
);
3037 defsubr (&Sprevious_window
);
3038 defsubr (&Sother_window
);
3039 defsubr (&Sget_lru_window
);
3040 defsubr (&Sget_largest_window
);
3041 defsubr (&Sget_buffer_window
);
3042 defsubr (&Sdelete_other_windows
);
3043 defsubr (&Sdelete_windows_on
);
3044 defsubr (&Sreplace_buffer_in_windows
);
3045 defsubr (&Sdelete_window
);
3046 defsubr (&Sset_window_buffer
);
3047 defsubr (&Sselect_window
);
3048 defsubr (&Sdisplay_buffer
);
3049 defsubr (&Ssplit_window
);
3050 defsubr (&Senlarge_window
);
3051 defsubr (&Sshrink_window
);
3052 defsubr (&Sscroll_up
);
3053 defsubr (&Sscroll_down
);
3054 defsubr (&Sscroll_left
);
3055 defsubr (&Sscroll_right
);
3056 defsubr (&Sscroll_other_window
);
3057 defsubr (&Srecenter
);
3058 defsubr (&Smove_to_window_line
);
3059 defsubr (&Swindow_configuration_p
);
3060 defsubr (&Sset_window_configuration
);
3061 defsubr (&Scurrent_window_configuration
);
3062 defsubr (&Ssave_window_excursion
);
3067 initial_define_key (control_x_map
, '1', "delete-other-windows");
3068 initial_define_key (control_x_map
, '2', "split-window");
3069 initial_define_key (control_x_map
, '0', "delete-window");
3070 initial_define_key (control_x_map
, 'o', "other-window");
3071 initial_define_key (control_x_map
, '^', "enlarge-window");
3072 initial_define_key (control_x_map
, '<', "scroll-left");
3073 initial_define_key (control_x_map
, '>', "scroll-right");
3075 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3076 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3077 initial_define_key (meta_map
, 'v', "scroll-down");
3079 initial_define_key (global_map
, Ctl('L'), "recenter");
3080 initial_define_key (meta_map
, 'r', "move-to-window-line");