1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 Lisp_Object Qwindowp
, Qwindow_live_p
;
34 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
35 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
37 void delete_all_subwindows ();
38 static struct window
*decode_window();
40 /* This is the window in which the terminal's cursor should
41 be left when nothing is being done with it. This must
42 always be a leaf window, and its buffer is selected by
43 the top level editing loop at the end of each command.
45 This value is always the same as
46 FRAME_SELECTED_WINDOW (selected_frame). */
48 Lisp_Object selected_window
;
50 /* The minibuffer window of the selected frame.
51 Note that you cannot test for minibufferness of an arbitrary window
52 by comparing against this; but you can test for minibufferness of
53 the selected window. */
54 Lisp_Object minibuf_window
;
56 /* Non-nil means it is the window for C-M-v to scroll
57 when the minibuffer is selected. */
58 Lisp_Object Vminibuf_scroll_window
;
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
61 Lisp_Object Vother_window_scroll_buffer
;
63 /* Non-nil means it's function to call to display temp buffers. */
64 Lisp_Object Vtemp_buffer_show_function
;
66 /* If a window gets smaller than either of these, it is removed. */
67 int window_min_height
;
70 /* Nonzero implies Fdisplay_buffer should create windows. */
73 /* Nonzero implies make new frames for Fdisplay_buffer. */
76 /* Non-nil means use this function instead of default */
77 Lisp_Object Vpop_up_frame_function
;
79 /* Function to call to handle Fdisplay_buffer. */
80 Lisp_Object Vdisplay_buffer_function
;
82 /* 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 display columns in WINDOW.\n\
261 This is the width that is usable columns available for text in WINDOW.\n\
262 If you want to find out how many columns WINDOW takes up,\n\
263 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
267 register struct window
*w
= decode_window (window
);
268 register int width
= XFASTINT (w
->width
);
270 return make_number (window_internal_width (w
));
273 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
274 "Return the number of columns by which WINDOW is scrolled from left margin.")
278 return decode_window (window
)->hscroll
;
281 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
282 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
283 NCOL should be zero or positive.")
285 register Lisp_Object window
, ncol
;
287 register struct window
*w
;
289 CHECK_NUMBER (ncol
, 1);
290 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
291 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
292 args_out_of_range (ncol
, Qnil
);
293 w
= decode_window (window
);
294 if (XINT (w
->hscroll
) != XINT (ncol
))
295 clip_changed
= 1; /* Prevent redisplay shortcuts */
300 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
301 "Return a list of the edge coordinates of WINDOW.\n\
302 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
303 RIGHT is one more than the rightmost column used by WINDOW,\n\
304 and BOTTOM is one more than the bottommost row used by WINDOW\n\
309 register struct window
*w
= decode_window (window
);
311 return Fcons (w
->left
, Fcons (w
->top
,
312 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
313 Fcons (make_number (XFASTINT (w
->top
)
314 + XFASTINT (w
->height
)),
318 /* Test if the character at column *x, row *y is within window *w.
319 If it is not, return 0;
320 if it is in the window's text area,
321 set *x and *y to its location relative to the upper left corner
324 if it is on the window's modeline, return 2;
325 if it is on the border between the window and its right sibling,
328 coordinates_in_window (w
, x
, y
)
329 register struct window
*w
;
332 register int left
= XINT (w
->left
);
333 register int width
= XINT (w
->width
);
334 register int window_height
= XINT (w
->height
);
335 register int top
= XFASTINT (w
->top
);
337 if ( *x
< left
|| *x
>= left
+ width
338 || *y
< top
|| *y
>= top
+ window_height
)
341 /* Is the character is the mode line? */
342 if (*y
== top
+ window_height
- 1
343 && ! MINI_WINDOW_P (w
))
346 /* Is the character in the right border? */
347 if (*x
== left
+ width
- 1
348 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
356 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
357 Scoordinates_in_window_p
, 2, 2, 0,
358 "Return non-nil if COORDINATES are in WINDOW.\n\
359 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
360 measured in characters from the upper-left corner of the frame.\n\
361 (0 . 0) denotes the character in the upper left corner of the\n\
363 If COORDINATES are in the text portion of WINDOW,\n\
364 the coordinates relative to the window are returned.\n\
365 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
366 If they are on the border between WINDOW and its right sibling,\n\
367 `vertical-line' is returned.")
368 (coordinates
, window
)
369 register Lisp_Object coordinates
, window
;
373 CHECK_LIVE_WINDOW (window
, 0);
374 CHECK_CONS (coordinates
, 1);
375 x
= XINT (Fcar (coordinates
));
376 y
= XINT (Fcdr (coordinates
));
378 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
380 case 0: /* NOT in window at all. */
383 case 1: /* In text part of window. */
386 case 2: /* In mode line of window. */
389 case 3: /* On right border of window. */
390 return Qvertical_line
;
397 /* Find the window containing column x, row y, and return it as a
398 Lisp_Object. If x, y is on the window's modeline, set *part
399 to 1; if it is on the separating line between the window and its
400 right sibling, set it to 2; otherwise set it to 0. If there is no
401 window under x, y return nil and leave *part unmodified. */
403 window_from_coordinates (frame
, x
, y
, part
)
408 register Lisp_Object tem
, first
;
410 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
414 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
422 tem
= Fnext_window (tem
, Qt
, Qlambda
);
424 while (! EQ (tem
, first
));
429 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
430 "Return window containing coordinates X and Y on FRAME.\n\
431 If omitted, FRAME defaults to the currently selected frame.\n\
432 The top left corner of the frame is considered to be row 0,\n\
435 Lisp_Object x
, y
, frame
;
441 XSET (frame
, Lisp_Frame
, selected_frame
);
443 CHECK_LIVE_FRAME (frame
, 2);
448 return window_from_coordinates (XFRAME (frame
),
453 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
454 "Return current value of point in WINDOW.\n\
455 For a nonselected window, this is the value point would have\n\
456 if that window were selected.\n\
458 Note that, when WINDOW is the selected window and its buffer\n\
459 is also currently selected, the value returned is the same as (point).\n\
460 It would be more strictly correct to return the `top-level' value\n\
461 of point, outside of any save-excursion forms.\n\
462 But that is hard to define.")
466 register struct window
*w
= decode_window (window
);
468 if (w
== XWINDOW (selected_window
)
469 && current_buffer
== XBUFFER (w
->buffer
))
471 return Fmarker_position (w
->pointm
);
474 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
475 "Return position at which display currently starts in WINDOW.")
479 return Fmarker_position (decode_window (window
)->start
);
482 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
483 "Return position at which display currently ends in WINDOW.")
488 struct window
*w
= decode_window (window
);
492 CHECK_BUFFER (buf
, 0);
494 XSET (value
, Lisp_Int
,
495 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
500 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
501 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
503 Lisp_Object window
, pos
;
505 register struct window
*w
= decode_window (window
);
507 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
508 if (w
== XWINDOW (selected_window
))
511 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
516 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
517 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
518 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
519 from overriding motion of point in order to display at this exact start.")
520 (window
, pos
, noforce
)
521 Lisp_Object window
, pos
, noforce
;
523 register struct window
*w
= decode_window (window
);
525 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
526 set_marker_restricted (w
->start
, pos
, w
->buffer
);
527 /* this is not right, but much easier than doing what is right. */
528 w
->start_at_line_beg
= Qnil
;
531 w
->update_mode_line
= Qt
;
532 XFASTINT (w
->last_modified
) = 0;
533 if (!EQ (window
, selected_window
))
534 windows_or_buffers_changed
++;
538 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
540 "Return WINDOW's dedicated object, usually t or nil.\n\
541 See also `set-window-dedicated-p'.")
545 return decode_window (window
)->dedicated
;
548 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
549 Sset_window_dedicated_p
, 2, 2, 0,
550 "Control whether WINDOW is dedicated to the buffer it displays.\n\
551 If it is dedicated, Emacs will not automatically change\n\
552 which buffer appears in it.\n\
553 The second argument is the new value for the dedication flag;\n\
556 Lisp_Object window
, arg
;
558 register struct window
*w
= decode_window (window
);
568 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
570 "Return the display-table that WINDOW is using.")
574 return decode_window (window
)->display_table
;
577 /* Get the display table for use currently on window W.
578 This is either W's display table or W's buffer's display table.
579 Ignore the specified tables if they are not valid;
580 if no valid table is specified, return 0. */
583 window_display_table (w
)
587 tem
= w
->display_table
;
588 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
589 return XVECTOR (tem
);
590 tem
= XBUFFER (w
->buffer
)->display_table
;
591 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
592 return XVECTOR (tem
);
593 tem
= Vstandard_display_table
;
594 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
595 return XVECTOR (tem
);
599 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
600 "Set WINDOW's display-table to TABLE.")
602 register Lisp_Object window
, table
;
604 register struct window
*w
;
605 register Lisp_Object z
; /* Return value. */
607 w
= decode_window (window
);
608 w
->display_table
= table
;
612 /* Record info on buffer window w is displaying
613 when it is about to cease to display that buffer. */
616 register struct window
*w
;
618 Lisp_Object buf
= w
->buffer
;
620 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
624 if (w
== XWINDOW (selected_window
)
625 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
626 /* Do this except when the selected window's buffer
627 is being removed from some other window. */
629 /* last_window_start records the start position that this buffer
630 had in the last window to be disconnected from it.
631 Now that this statement is unconditional,
632 it is possible for the buffer to be displayed in the
633 selected window, while last_window_start reflects another
634 window which was recently showing the same buffer.
635 Some people might say that might be a good thing. Let's see. */
636 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
638 /* Point in the selected window's buffer
639 is actually stored in that buffer, and the window's pointm isn't used.
640 So don't clobber point in that buffer. */
641 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
642 BUF_PT (XBUFFER (buf
))
643 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
644 marker_position (w
->pointm
),
645 BUF_ZV (XBUFFER (buf
)));
648 /* Put replacement into the window structure in place of old. */
650 replace_window (old
, replacement
)
651 Lisp_Object old
, replacement
;
653 register Lisp_Object tem
;
654 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
656 /* If OLD is its frame's root_window, then replacement is the new
657 root_window for that frame. */
659 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
660 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
665 p
->height
= o
->height
;
667 p
->next
= tem
= o
->next
;
669 XWINDOW (tem
)->prev
= replacement
;
671 p
->prev
= tem
= o
->prev
;
673 XWINDOW (tem
)->next
= replacement
;
675 p
->parent
= tem
= o
->parent
;
678 if (EQ (XWINDOW (tem
)->vchild
, old
))
679 XWINDOW (tem
)->vchild
= replacement
;
680 if (EQ (XWINDOW (tem
)->hchild
, old
))
681 XWINDOW (tem
)->hchild
= replacement
;
684 /*** Here, if replacement is a vertical combination
685 and so is its new parent, we should make replacement's
686 children be children of that parent instead. ***/
689 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
690 "Remove WINDOW from the display. Default is selected window.")
692 register Lisp_Object window
;
694 register Lisp_Object tem
, parent
, sib
;
695 register struct window
*p
;
696 register struct window
*par
;
698 /* Because this function is called by other C code on non-leaf
699 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
700 so we can't decode_window here. */
702 window
= selected_window
;
704 CHECK_WINDOW (window
, 0);
705 p
= XWINDOW (window
);
707 /* It's okay to delete an already-deleted window. */
715 error ("Attempt to delete minibuffer or sole ordinary window");
716 par
= XWINDOW (parent
);
718 windows_or_buffers_changed
++;
720 /* Are we trying to delete any frame's selected window? */
722 Lisp_Object frame
, pwindow
;
724 /* See if the frame's selected window is either WINDOW
725 or any subwindow of it, by finding all that window's parents
726 and comparing each one with WINDOW. */
727 frame
= WINDOW_FRAME (XWINDOW (window
));
728 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
730 while (!NILP (pwindow
))
732 if (EQ (window
, pwindow
))
734 pwindow
= XWINDOW (pwindow
)->parent
;
737 if (EQ (window
, pwindow
))
739 Lisp_Object alternative
;
740 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
742 /* If we're about to delete the selected window on the
743 selected frame, then we should use Fselect_window to select
744 the new window. On the other hand, if we're about to
745 delete the selected window on any other frame, we shouldn't do
746 anything but set the frame's selected_window slot. */
747 if (EQ (window
, selected_window
))
748 Fselect_window (alternative
);
750 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
755 /* tem is null for dummy parent windows
756 (which have inferiors but not any contents themselves) */
760 unchain_marker (p
->pointm
);
761 unchain_marker (p
->start
);
766 XWINDOW (tem
)->prev
= p
->prev
;
770 XWINDOW (tem
)->next
= p
->next
;
772 if (EQ (window
, par
->hchild
))
773 par
->hchild
= p
->next
;
774 if (EQ (window
, par
->vchild
))
775 par
->vchild
= p
->next
;
777 /* Find one of our siblings to give our space to. */
781 /* If p gives its space to its next sibling, that sibling needs
782 to have its top/left side pulled back to where p's is.
783 set_window_{height,width} will re-position the sibling's
786 XWINDOW (sib
)->top
= p
->top
;
787 XWINDOW (sib
)->left
= p
->left
;
790 /* Stretch that sibling. */
791 if (!NILP (par
->vchild
))
792 set_window_height (sib
,
793 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
795 if (!NILP (par
->hchild
))
796 set_window_width (sib
,
797 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
800 /* If parent now has only one child,
801 put the child into the parent's place. */
805 if (NILP (XWINDOW (tem
)->next
))
806 replace_window (parent
, tem
);
808 /* Since we may be deleting combination windows, we must make sure that
809 not only p but all its children have been marked as deleted. */
810 if (! NILP (p
->hchild
))
811 delete_all_subwindows (XWINDOW (p
->hchild
));
812 else if (! NILP (p
->vchild
))
813 delete_all_subwindows (XWINDOW (p
->vchild
));
815 /* Mark this window as deleted. */
816 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
822 extern Lisp_Object
next_frame (), prev_frame ();
824 /* This comment supplies the doc string for `next-window',
825 for make-docfile to see. We cannot put this in the real DEFUN
826 due to limits in the Unix cpp.
828 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
829 "Return next window after WINDOW in canonical ordering of windows.\n\
830 If omitted, WINDOW defaults to the selected window.\n\
832 Optional second arg MINIBUF t means count the minibuffer window even\n\
833 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
834 it is active. MINIBUF neither t nor nil means not to count the\n\
835 minibuffer even if it is active.\n\
837 Several frames may share a single minibuffer; if the minibuffer\n\
838 counts, all windows on all frames that share that minibuffer count\n\
839 too. This means that next-window may be used to iterate through the\n\
840 set of windows even when the minibuffer is on another frame. If the\n\
841 minibuffer does not count, only windows from WINDOW's frame count.\n\
843 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
844 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
845 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
846 Anything else means restrict to WINDOW's frame.\n\
848 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
849 `next-window' to iterate through the entire cycle of acceptable\n\
850 windows, eventually ending up back at the window you started with.\n\
851 `previous-window' traverses the same cycle, in the reverse order.")
852 (window, minibuf, all_frames) */
854 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
856 (window
, minibuf
, all_frames
)
857 register Lisp_Object window
, minibuf
, all_frames
;
859 register Lisp_Object tem
;
860 Lisp_Object start_window
;
863 window
= selected_window
;
865 CHECK_LIVE_WINDOW (window
, 0);
867 start_window
= window
;
869 /* minibuf == nil may or may not include minibuffers.
870 Decide if it does. */
872 minibuf
= (minibuf_level
? Qt
: Qlambda
);
874 /* all_frames == nil doesn't specify which frames to include.
875 Decide which frames it includes. */
876 if (NILP (all_frames
))
877 all_frames
= (EQ (minibuf
, Qt
)
878 ? (FRAME_MINIBUF_WINDOW
881 (XWINDOW (window
)))))
883 else if (EQ (all_frames
, Qvisible
))
885 else if (! EQ (all_frames
, Qt
))
887 /* Now all_frames is t meaning search all frames,
888 nil meaning search just current frame,
889 or a window, meaning search the frame that window belongs to. */
891 /* Do this loop at least once, to get the next window, and perhaps
892 again, if we hit the minibuffer and that is not acceptable. */
895 /* Find a window that actually has a next one. This loop
896 climbs up the tree. */
897 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
898 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
902 /* We've reached the end of this frame.
903 Which other frames are acceptable? */
904 tem
= WINDOW_FRAME (XWINDOW (window
));
906 if (! NILP (all_frames
))
907 tem
= next_frame (tem
, all_frames
);
909 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
916 /* If we're in a combination window, find its first child and
917 recurse on that. Otherwise, we've found the window we want. */
920 if (!NILP (XWINDOW (window
)->hchild
))
921 window
= XWINDOW (window
)->hchild
;
922 else if (!NILP (XWINDOW (window
)->vchild
))
923 window
= XWINDOW (window
)->vchild
;
927 /* Which windows are acceptible?
928 Exit the loop and accept this window if
929 this isn't a minibuffer window, or
930 we're accepting minibuffer windows, or
931 we've come all the way around and we're back at the original window. */
932 while (MINI_WINDOW_P (XWINDOW (window
))
933 && ! EQ (minibuf
, Qt
)
934 && ! EQ (window
, start_window
));
939 /* This comment supplies the doc string for `previous-window',
940 for make-docfile to see. We cannot put this in the real DEFUN
941 due to limits in the Unix cpp.
943 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
944 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
945 If omitted, WINDOW defaults to the selected window.\n\
947 Optional second arg MINIBUF t means count the minibuffer window even\n\
948 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
949 it is active. MINIBUF neither t nor nil means not to count the\n\
950 minibuffer even if it is active.\n\
952 Several frames may share a single minibuffer; if the minibuffer\n\
953 counts, all windows on all frames that share that minibuffer count\n\
954 too. This means that previous-window may be used to iterate through\n\
955 the set of windows even when the minibuffer is on another frame. If\n\
956 the minibuffer does not count, only windows from WINDOW's frame\n\
959 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
960 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
961 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
962 Anything else means restrict to WINDOW's frame.\n\
964 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
965 `previous-window' to iterate through the entire cycle of acceptable\n\
966 windows, eventually ending up back at the window you started with.\n\
967 `next-window' traverses the same cycle, in the reverse order.")
968 (window, minibuf, all_frames) */
971 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
973 (window
, minibuf
, all_frames
)
974 register Lisp_Object window
, minibuf
, all_frames
;
976 register Lisp_Object tem
;
977 Lisp_Object start_window
;
980 window
= selected_window
;
982 CHECK_LIVE_WINDOW (window
, 0);
984 start_window
= window
;
986 /* minibuf == nil may or may not include minibuffers.
987 Decide if it does. */
989 minibuf
= (minibuf_level
? Qt
: Qlambda
);
991 /* all_frames == nil doesn't specify which frames to include.
992 Decide which frames it includes. */
993 if (NILP (all_frames
))
994 all_frames
= (EQ (minibuf
, Qt
)
995 ? (FRAME_MINIBUF_WINDOW
998 (XWINDOW (window
)))))
1000 else if (EQ (all_frames
, Qvisible
))
1002 else if (! EQ (all_frames
, Qt
))
1004 /* Now all_frames is t meaning search all frames,
1005 nil meaning search just current frame,
1006 or a window, meaning search the frame that window belongs to. */
1008 /* Do this loop at least once, to get the previous window, and perhaps
1009 again, if we hit the minibuffer and that is not acceptable. */
1012 /* Find a window that actually has a previous one. This loop
1013 climbs up the tree. */
1014 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1015 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1019 /* We have found the top window on the frame.
1020 Which frames are acceptable? */
1021 tem
= WINDOW_FRAME (XWINDOW (window
));
1023 if (! NILP (all_frames
))
1024 /* It's actually important that we use prev_frame here,
1025 rather than next_frame. All the windows acceptable
1026 according to the given parameters should form a ring;
1027 Fnext_window and Fprevious_window should go back and
1028 forth around the ring. If we use next_frame here,
1029 then Fnext_window and Fprevious_window take different
1030 paths through the set of acceptable windows.
1031 window_loop assumes that these `ring' requirement are
1033 tem
= prev_frame (tem
, all_frames
);
1035 /* If this frame has a minibuffer, find that window first,
1036 because it is conceptually the last window in that frame. */
1037 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1038 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1040 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1046 /* If we're in a combination window, find its last child and
1047 recurse on that. Otherwise, we've found the window we want. */
1050 if (!NILP (XWINDOW (window
)->hchild
))
1051 window
= XWINDOW (window
)->hchild
;
1052 else if (!NILP (XWINDOW (window
)->vchild
))
1053 window
= XWINDOW (window
)->vchild
;
1055 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1059 /* Which windows are acceptable?
1060 Exit the loop and accept this window if
1061 this isn't a minibuffer window, or
1062 we're accepting minibuffer windows, or
1063 we've come all the way around and we're back at the original window. */
1064 while (MINI_WINDOW_P (XWINDOW (window
))
1065 && !EQ (minibuf
, Qt
)
1066 && !EQ (window
, start_window
));
1071 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1072 "Select the ARG'th different window on this frame.\n\
1073 All windows on current frame are arranged in a cyclic order.\n\
1074 This command selects the window ARG steps away in that order.\n\
1075 A negative ARG moves in the opposite order. If the optional second\n\
1076 argument ALL_FRAMES is non-nil, cycle through all frames.")
1078 register Lisp_Object n
, all_frames
;
1081 register Lisp_Object w
;
1083 CHECK_NUMBER (n
, 0);
1084 w
= selected_window
;
1089 w
= Fnext_window (w
, Qnil
, all_frames
);
1094 w
= Fprevious_window (w
, Qnil
, all_frames
);
1101 /* Look at all windows, performing an operation specified by TYPE
1103 If FRAMES is Qt, look at all frames;
1104 Qnil, look at just the selected frame;
1105 Qvisible, look at visible frames;
1106 a frame, just look at windows on that frame.
1107 If MINI is non-zero, perform the operation on minibuffer windows too.
1113 GET_BUFFER_WINDOW
, /* Arg is buffer */
1114 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1115 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1116 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1118 UNSHOW_BUFFER
/* Arg is buffer */
1122 window_loop (type
, obj
, mini
, frames
)
1123 enum window_loop type
;
1124 register Lisp_Object obj
, frames
;
1127 register Lisp_Object w
;
1128 register Lisp_Object best_window
;
1129 register Lisp_Object next_window
;
1130 register Lisp_Object last_window
;
1132 Lisp_Object frame_arg
;
1136 /* If we're only looping through windows on a particular frame,
1137 frame points to that frame. If we're looping through windows
1138 on all frames, frame is 0. */
1139 if (FRAMEP (frames
))
1140 frame
= XFRAME (frames
);
1141 else if (NILP (frames
))
1142 frame
= selected_frame
;
1146 frame_arg
= Qlambda
;
1147 else if (EQ (frames
, Qvisible
))
1153 /* frame_arg is Qlambda to stick to one frame,
1154 Qvisible to consider all visible frames,
1157 /* Pick a window to start with. */
1158 if (XTYPE (obj
) == Lisp_Window
)
1161 w
= FRAME_SELECTED_WINDOW (frame
);
1163 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1165 /* Figure out the last window we're going to mess with. Since
1166 Fnext_window, given the same options, is guaranteed to go in a
1167 ring, we can just use Fprevious_window to find the last one.
1169 We can't just wait until we hit the first window again, because
1170 it might be deleted. */
1172 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1177 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1179 /* Pick the next window now, since some operations will delete
1180 the current window. */
1181 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1184 if (frame
!= 0 && EQ (frames
, Qt
)
1185 && FRAME_VISIBLE_P (w_frame
))
1188 if (! MINI_WINDOW_P (XWINDOW (w
))
1189 || (mini
&& minibuf_level
> 0))
1192 case GET_BUFFER_WINDOW
:
1193 /* Ignore invisible and iconified frames. */
1194 if (! FRAME_VISIBLE_P (w_frame
)
1195 || FRAME_ICONIFIED_P (w_frame
))
1197 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1201 case GET_LRU_WINDOW
:
1202 /* t as arg means consider only full-width windows */
1203 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1204 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1207 /* Ignore invisible and iconified frames. */
1208 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1209 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1212 /* Ignore dedicated windows and minibuffers. */
1213 if (MINI_WINDOW_P (XWINDOW (w
))
1214 || !NILP (XWINDOW (w
)->dedicated
))
1216 if (NILP (best_window
)
1217 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1218 > XFASTINT (XWINDOW (w
)->use_time
)))
1222 case DELETE_OTHER_WINDOWS
:
1223 if (XWINDOW (w
) != XWINDOW (obj
))
1227 case DELETE_BUFFER_WINDOWS
:
1228 if (EQ (XWINDOW (w
)->buffer
, obj
))
1230 /* If we're deleting the buffer displayed in the only window
1231 on the frame, find a new buffer to display there. */
1232 if (NILP (XWINDOW (w
)->parent
))
1234 Lisp_Object new_buffer
= Fother_buffer (obj
, Qnil
);
1235 if (NILP (new_buffer
))
1237 = Fget_buffer_create (build_string ("*scratch*"));
1238 Fset_window_buffer (w
, new_buffer
);
1239 if (EQ (w
, selected_window
))
1240 Fset_buffer (XWINDOW (w
)->buffer
);
1247 case GET_LARGEST_WINDOW
:
1249 /* Ignore invisible and iconified frames. */
1250 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1251 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1254 /* Ignore dedicated windows and minibuffers. */
1255 if (MINI_WINDOW_P (XWINDOW (w
))
1256 || !NILP (XWINDOW (w
)->dedicated
))
1259 struct window
*best_window_ptr
= XWINDOW (best_window
);
1260 struct window
*w_ptr
= XWINDOW (w
);
1261 if (NILP (best_window
) ||
1262 (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
))
1263 > (XFASTINT (best_window_ptr
->height
)
1264 * XFASTINT (best_window_ptr
->width
)))
1270 if (EQ (XWINDOW (w
)->buffer
, obj
))
1272 /* Find another buffer to show in this window. */
1273 Lisp_Object another_buffer
= Fother_buffer (obj
, Qnil
);
1274 if (NILP (another_buffer
))
1276 = Fget_buffer_create (build_string ("*scratch*"));
1277 Fset_window_buffer (w
, another_buffer
);
1278 if (EQ (w
, selected_window
))
1279 Fset_buffer (XWINDOW (w
)->buffer
);
1284 if (EQ (w
, last_window
))
1293 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1294 "Return the window least recently selected or used for display.\n\
1295 If optional argument FRAME is `visible', search all visible frames.\n\
1296 If FRAME is t, search all frames.\n\
1297 If FRAME is nil, search only the selected frame.\n\
1298 If FRAME is a frame, search only that frame.")
1302 register Lisp_Object w
;
1303 /* First try for a window that is full-width */
1304 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1305 if (!NILP (w
) && !EQ (w
, selected_window
))
1307 /* If none of them, try the rest */
1308 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1311 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1312 "Return the largest window in area.\n\
1313 If optional argument FRAME is `visible', search all visible frames.\n\
1314 If FRAME is t, search all frames.\n\
1315 If FRAME is nil, search only the selected frame.\n\
1316 If FRAME is a frame, search only that frame.")
1320 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1324 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1325 "Return a window currently displaying BUFFER, or nil if none.\n\
1326 If optional argument FRAME is `visible', search all visible frames.\n\
1327 If FRAME is t, search all frames.\n\
1328 If FRAME is nil, search only the selected frame.\n\
1329 If FRAME is a frame, search only that frame.")
1331 Lisp_Object buffer
, frame
;
1333 buffer
= Fget_buffer (buffer
);
1334 if (XTYPE (buffer
) == Lisp_Buffer
)
1335 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1340 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1342 "Make WINDOW (or the selected window) fill its frame.\n\
1343 Only the frame WINDOW is on is affected.\n\
1344 This function tries to reduce display jumps\n\
1345 by keeping the text previously visible in WINDOW\n\
1346 in the same place on the frame. Doing this depends on\n\
1347 the value of (window-start WINDOW), so if calling this function\n\
1348 in a program gives strange scrolling, make sure the window-start\n\
1349 value is reasonable when this function is called.")
1354 struct buffer
*obuf
= current_buffer
;
1359 window
= selected_window
;
1361 CHECK_LIVE_WINDOW (window
, 0);
1363 w
= XWINDOW (window
);
1364 top
= XFASTINT (w
->top
);
1366 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1368 Fset_buffer (w
->buffer
);
1370 SET_PT (marker_position (w
->start
));
1371 /* Like Frecenter but avoid setting w->force_start. */
1372 Fvertical_motion (make_number (- (top
- FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
))))));
1373 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
1374 w
->start_at_line_beg
= Fbolp ();
1377 set_buffer_internal (obuf
);
1381 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1382 1, 2, "bDelete windows on (buffer): ",
1383 "Delete all windows showing BUFFER.\n\
1384 Optional second argument FRAME controls which frames are affected.\n\
1385 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1386 If t, delete only windows showing BUFFER in the selected frame.\n\
1387 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1388 If a frame, delete only windows showing BUFFER in that frame.")
1390 Lisp_Object buffer
, frame
;
1393 /* FRAME uses t and nil to mean the opposite of what window_loop
1395 if (! FRAMEP (frame
))
1396 frame
= NILP (frame
) ? Qt
: Qnil
;
1403 buffer
= Fget_buffer (buffer
);
1404 CHECK_BUFFER (buffer
, 0);
1405 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1410 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1411 Sreplace_buffer_in_windows
,
1412 1, 1, "bReplace buffer in windows: ",
1413 "Replace BUFFER with some other buffer in all windows showing it.")
1419 buffer
= Fget_buffer (buffer
);
1420 CHECK_BUFFER (buffer
, 0);
1421 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1426 /* Set the height of WINDOW and all its inferiors. */
1428 /* The smallest acceptable dimensions for a window. Anything smaller
1429 might crash Emacs. */
1430 #define MIN_SAFE_WINDOW_WIDTH (2)
1431 #define MIN_SAFE_WINDOW_HEIGHT (2)
1433 /* Make sure that window_min_height and window_min_width are
1434 not too small; if they are, set them to safe minima. */
1437 check_min_window_sizes ()
1439 /* Smaller values might permit a crash. */
1440 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1441 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1442 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1443 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1446 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1447 minimum allowable size. */
1449 check_frame_size (frame
, rows
, cols
)
1453 /* For height, we have to see:
1454 whether the frame has a minibuffer,
1455 whether it wants a mode line, and
1456 whether it has a menu bar. */
1458 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1459 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1460 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1461 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1462 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1464 if (*rows
< min_height
)
1466 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1467 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1470 /* Normally the window is deleted if it gets too small.
1471 nodelete nonzero means do not do this.
1472 (The caller should check later and do so if appropriate) */
1474 set_window_height (window
, height
, nodelete
)
1479 register struct window
*w
= XWINDOW (window
);
1480 register struct window
*c
;
1481 int oheight
= XFASTINT (w
->height
);
1482 int top
, pos
, lastbot
, opos
, lastobot
;
1485 check_min_window_sizes ();
1488 && ! NILP (w
->parent
)
1489 && height
< window_min_height
)
1491 Fdelete_window (window
);
1495 XFASTINT (w
->last_modified
) = 0;
1496 windows_or_buffers_changed
++;
1497 XFASTINT (w
->height
) = height
;
1498 if (!NILP (w
->hchild
))
1500 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1502 XWINDOW (child
)->top
= w
->top
;
1503 set_window_height (child
, height
, nodelete
);
1506 else if (!NILP (w
->vchild
))
1508 lastbot
= top
= XFASTINT (w
->top
);
1510 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1512 c
= XWINDOW (child
);
1514 opos
= lastobot
+ XFASTINT (c
->height
);
1516 XFASTINT (c
->top
) = lastbot
;
1518 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1520 /* Avoid confusion: inhibit deletion of child if becomes too small */
1521 set_window_height (child
, pos
+ top
- lastbot
, 1);
1523 /* Now advance child to next window,
1524 and set lastbot if child was not just deleted. */
1525 lastbot
= pos
+ top
;
1528 /* Now delete any children that became too small. */
1530 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1532 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1537 /* Recursively set width of WINDOW and its inferiors. */
1539 set_window_width (window
, width
, nodelete
)
1544 register struct window
*w
= XWINDOW (window
);
1545 register struct window
*c
;
1546 int owidth
= XFASTINT (w
->width
);
1547 int left
, pos
, lastright
, opos
, lastoright
;
1550 if (!nodelete
&& width
< window_min_width
)
1552 Fdelete_window (window
);
1556 XFASTINT (w
->last_modified
) = 0;
1557 windows_or_buffers_changed
++;
1558 XFASTINT (w
->width
) = width
;
1559 if (!NILP (w
->vchild
))
1561 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1563 XWINDOW (child
)->left
= w
->left
;
1564 set_window_width (child
, width
, nodelete
);
1567 else if (!NILP (w
->hchild
))
1569 lastright
= left
= XFASTINT (w
->left
);
1571 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1573 c
= XWINDOW (child
);
1575 opos
= lastoright
+ XFASTINT (c
->width
);
1577 XFASTINT (c
->left
) = lastright
;
1579 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1581 /* Inhibit deletion for becoming too small */
1582 set_window_width (child
, pos
+ left
- lastright
, 1);
1584 /* Now advance child to next window,
1585 and set lastright if child was not just deleted. */
1586 lastright
= pos
+ left
, lastoright
= opos
;
1588 /* Delete children that became too small */
1590 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1592 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1597 int window_select_count
;
1599 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1600 "Make WINDOW display BUFFER as its contents.\n\
1601 BUFFER can be a buffer or buffer name.")
1603 register Lisp_Object window
, buffer
;
1605 register Lisp_Object tem
;
1606 register struct window
*w
= decode_window (window
);
1608 buffer
= Fget_buffer (buffer
);
1609 CHECK_BUFFER (buffer
, 1);
1611 if (NILP (XBUFFER (buffer
)->name
))
1612 error ("Attempt to display deleted buffer");
1616 error ("Window is deleted");
1617 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1618 is first being set up. */
1620 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1621 error ("Window is dedicated to %s\n", tem
);
1627 w
->window_end_pos
= 0;
1628 w
->window_end_valid
= Qnil
;
1630 Fset_marker (w
->pointm
,
1631 make_number (BUF_PT (XBUFFER (buffer
))),
1633 set_marker_restricted (w
->start
,
1634 make_number (XBUFFER (buffer
)->last_window_start
),
1636 w
->start_at_line_beg
= Qnil
;
1637 w
->force_start
= Qnil
;
1638 XFASTINT (w
->last_modified
) = 0;
1639 windows_or_buffers_changed
++;
1640 if (EQ (window
, selected_window
))
1641 Fset_buffer (buffer
);
1646 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1647 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1648 The main editor command loop selects the buffer of the selected window\n\
1649 before each command.")
1651 register Lisp_Object window
;
1653 register struct window
*w
;
1654 register struct window
*ow
= XWINDOW (selected_window
);
1656 CHECK_LIVE_WINDOW (window
, 0);
1658 w
= XWINDOW (window
);
1660 if (MINI_WINDOW_P (w
)
1661 && NILP (call1 (intern ("minibuffer-window-active-p"), window
)))
1662 error ("Attempt to select inactive minibuffer window");
1664 if (NILP (w
->buffer
))
1665 error ("Trying to select deleted window or non-leaf window");
1667 XFASTINT (w
->use_time
) = ++window_select_count
;
1668 if (EQ (window
, selected_window
))
1671 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1674 selected_window
= window
;
1676 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1678 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1679 Fhandle_switch_frame (WINDOW_FRAME (w
), Qnil
);
1682 selected_frame
->selected_window
= window
;
1685 record_buffer (w
->buffer
);
1686 Fset_buffer (w
->buffer
);
1688 /* Go to the point recorded in the window.
1689 This is important when the buffer is in more
1690 than one window. It also matters when
1691 redisplay_window has altered point after scrolling,
1692 because it makes the change only in the window. */
1694 register int new_point
= marker_position (w
->pointm
);
1695 if (new_point
< BEGV
)
1703 windows_or_buffers_changed
++;
1707 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1708 "BDisplay buffer: \nP",
1709 "Make BUFFER appear in some window but don't select it.\n\
1710 BUFFER can be a buffer or a buffer name.\n\
1711 If BUFFER is shown already in some window, just use that one,\n\
1712 unless the window is the selected window and the optional second\n\
1713 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1714 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1715 Returns the window displaying BUFFER.")
1716 (buffer
, not_this_window
)
1717 register Lisp_Object buffer
, not_this_window
;
1719 register Lisp_Object window
;
1721 buffer
= Fget_buffer (buffer
);
1722 CHECK_BUFFER (buffer
, 0);
1724 if (!NILP (Vdisplay_buffer_function
))
1725 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1727 if (NILP (not_this_window
)
1728 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1729 return selected_window
;
1731 /* If pop_up_frames,
1732 look for a window showing BUFFER on any visible frame. */
1733 window
= Fget_buffer_window (buffer
, pop_up_frames
? Qvisible
: Qnil
);
1735 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1739 /* If there are no frames open that have more than a minibuffer,
1740 we need to create a new frame. */
1741 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1744 = Fframe_selected_window (call0 (Vpop_up_frame_function
));
1745 Fset_window_buffer (window
, buffer
);
1747 Fhandle_switch_frame (XWINDOW (window
)->frame
, Qnil
);
1751 #endif /* MULTI_FRAME */
1755 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1759 Lisp_Object frames
= Qnil
;
1762 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1763 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1765 /* Don't try to create a window if would get an error */
1766 if (split_height_threshold
< window_min_height
<< 1)
1767 split_height_threshold
= window_min_height
<< 1;
1769 window
= Fget_largest_window (frames
);
1772 && window_height (window
) >= split_height_threshold
1773 && (XFASTINT (XWINDOW (window
)->width
)
1774 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1775 window
= Fsplit_window (window
, Qnil
, Qnil
);
1778 window
= Fget_lru_window (frames
);
1779 if ((EQ (window
, selected_window
)
1780 || EQ (XWINDOW (window
)->parent
, Qnil
))
1781 && window_height (window
) >= window_min_height
<< 1)
1782 window
= Fsplit_window (window
, Qnil
, Qnil
);
1786 window
= Fget_lru_window (Qnil
);
1788 Fset_window_buffer (window
, buffer
);
1793 temp_output_buffer_show (buf
)
1794 register Lisp_Object buf
;
1796 register struct buffer
*old
= current_buffer
;
1797 register Lisp_Object window
;
1798 register struct window
*w
;
1801 XBUFFER (buf
)->save_modified
= MODIFF
;
1806 set_buffer_internal (old
);
1808 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1809 call1 (Vtemp_buffer_show_function
, buf
);
1812 window
= Fdisplay_buffer (buf
, Qnil
);
1815 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1816 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1817 #endif /* MULTI_FRAME */
1818 Vminibuf_scroll_window
= window
;
1819 w
= XWINDOW (window
);
1820 XFASTINT (w
->hscroll
) = 0;
1821 set_marker_restricted (w
->start
, make_number (1), buf
);
1822 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1827 make_dummy_parent (window
)
1830 register Lisp_Object old
, new;
1831 register struct window
*o
, *p
;
1834 XSETTYPE (old
, Lisp_Vector
);
1835 new = Fcopy_sequence (old
);
1836 XSETTYPE (new, Lisp_Window
);
1840 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1842 /* Put new into window structure in place of window */
1843 replace_window (window
, new);
1856 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1857 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1858 WINDOW defaults to selected one and SIZE to half its size.\n\
1859 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1860 and put SIZE columns in the first of the pair.")
1861 (window
, chsize
, horflag
)
1862 Lisp_Object window
, chsize
, horflag
;
1864 register Lisp_Object
new;
1865 register struct window
*o
, *p
;
1869 window
= selected_window
;
1871 CHECK_LIVE_WINDOW (window
, 0);
1873 o
= XWINDOW (window
);
1877 if (!NILP (horflag
))
1878 /* Round odd size up, since this is for the left-hand window,
1879 and it will lose a column for the separators. */
1880 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1882 size
= XFASTINT (o
->height
) >> 1;
1886 CHECK_NUMBER (chsize
, 1);
1887 size
= XINT (chsize
);
1890 if (MINI_WINDOW_P (o
))
1891 error ("Attempt to split minibuffer window");
1892 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1893 error ("Attempt to split unsplittable frame");
1895 check_min_window_sizes ();
1899 if (size
< window_min_height
1900 || size
+ window_min_height
> XFASTINT (o
->height
))
1901 args_out_of_range_3 (window
, chsize
, horflag
);
1902 if (NILP (o
->parent
)
1903 || NILP (XWINDOW (o
->parent
)->vchild
))
1905 make_dummy_parent (window
);
1907 XWINDOW (new)->vchild
= window
;
1912 if (size
< window_min_width
1913 || size
+ window_min_width
> XFASTINT (o
->width
))
1914 args_out_of_range_3 (window
, chsize
, horflag
);
1915 if (NILP (o
->parent
)
1916 || NILP (XWINDOW (o
->parent
)->hchild
))
1918 make_dummy_parent (window
);
1920 XWINDOW (new)->hchild
= window
;
1924 /* Now we know that window's parent is a vertical combination
1925 if we are dividing vertically, or a horizontal combination
1926 if we are making side-by-side windows */
1928 windows_or_buffers_changed
++;
1929 new = make_window ();
1932 p
->frame
= o
->frame
;
1934 if (!NILP (p
->next
))
1935 XWINDOW (p
->next
)->prev
= new;
1938 p
->parent
= o
->parent
;
1941 Fset_window_buffer (new, o
->buffer
);
1943 /* Apportion the available frame space among the two new windows */
1945 if (!NILP (horflag
))
1947 p
->height
= o
->height
;
1949 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1950 XFASTINT (o
->width
) = size
;
1951 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1956 p
->width
= o
->width
;
1957 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1958 XFASTINT (o
->height
) = size
;
1959 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
1965 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
1966 "Make current window ARG lines bigger.\n\
1967 From program, optional second arg non-nil means grow sideways ARG columns.")
1969 register Lisp_Object n
, side
;
1971 CHECK_NUMBER (n
, 0);
1972 change_window_height (XINT (n
), !NILP (side
));
1976 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
1977 "Make current window ARG lines smaller.\n\
1978 From program, optional second arg non-nil means shrink sideways ARG columns.")
1980 register Lisp_Object n
, side
;
1982 CHECK_NUMBER (n
, 0);
1983 change_window_height (-XINT (n
), !NILP (side
));
1988 window_height (window
)
1991 register struct window
*p
= XWINDOW (window
);
1992 return XFASTINT (p
->height
);
1996 window_width (window
)
1999 register struct window
*p
= XWINDOW (window
);
2000 return XFASTINT (p
->width
);
2003 #define MINSIZE(w) \
2005 ? window_min_width \
2006 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2009 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2011 #define CURSIZE(w) \
2012 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2014 /* Unlike set_window_height, this function
2015 also changes the heights of the siblings so as to
2016 keep everything consistent. */
2018 change_window_height (delta
, widthflag
)
2022 register Lisp_Object parent
;
2024 register struct window
*p
;
2026 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2027 register int (*setsizefun
) () = (widthflag
2029 : set_window_height
);
2031 check_min_window_sizes ();
2033 window
= selected_window
;
2036 p
= XWINDOW (window
);
2041 error ("No other window to side of this one");
2044 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2045 : !NILP (XWINDOW (parent
)->vchild
))
2050 sizep
= &CURSIZE (window
);
2052 if (*sizep
+ delta
< MINSIZE (window
))
2054 Fdelete_window (window
);
2059 register int maxdelta
;
2061 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2062 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2063 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2064 /* This is a frame with only one window, a minibuffer-only
2065 or a minibufferless frame. */
2068 if (delta
> maxdelta
)
2069 /* This case traps trying to make the minibuffer
2070 the full frame, or make the only window aside from the
2071 minibuffer the full frame. */
2078 if (!NILP (p
->next
) &&
2079 (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2081 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2082 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2083 CURBEG (p
->next
) += delta
;
2084 /* This does not change size of p->next,
2085 but it propagates the new top edge to its children */
2086 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2088 else if (!NILP (p
->prev
) &&
2089 (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2091 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2092 CURBEG (window
) -= delta
;
2093 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2097 register int delta1
;
2098 register int opht
= (*sizefun
) (parent
);
2100 /* If trying to grow this window to or beyond size of the parent,
2101 make delta1 so big that, on shrinking back down,
2102 all the siblings end up with less than one line and are deleted. */
2103 if (opht
<= *sizep
+ delta
)
2104 delta1
= opht
* opht
* 2;
2105 /* Otherwise, make delta1 just right so that if we add delta1
2106 lines to this window and to the parent, and then shrink
2107 the parent back to its original size, the new proportional
2108 size of this window will increase by delta. */
2110 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2112 /* Add delta1 lines or columns to this window, and to the parent,
2113 keeping things consistent while not affecting siblings. */
2114 CURSIZE (parent
) = opht
+ delta1
;
2115 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2117 /* Squeeze out delta1 lines or columns from our parent,
2118 shriking this window and siblings proportionately.
2119 This brings parent back to correct size.
2120 Delta1 was calculated so this makes this window the desired size,
2121 taking it all out of the siblings. */
2122 (*setsizefun
) (parent
, opht
, 0);
2125 XFASTINT (p
->last_modified
) = 0;
2132 /* Return number of lines of text (not counting mode line) in W. */
2135 window_internal_height (w
)
2138 int ht
= XFASTINT (w
->height
);
2140 if (MINI_WINDOW_P (w
))
2143 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2144 || !NILP (w
->next
) || !NILP (w
->prev
)
2145 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2152 /* Return the number of columns in W.
2153 Don't count columns occupied by scroll bars or the vertical bar
2154 separating W from the sibling to its right. */
2156 window_internal_width (w
)
2159 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2160 int left
= XINT (w
->left
);
2161 int width
= XINT (w
->width
);
2163 /* If this window is flush against the right edge of the frame, its
2164 internal width is its full width. */
2165 if (left
+ width
>= FRAME_WIDTH (f
))
2168 /* If we are not flush right, then our rightmost columns are
2169 occupied by some sort of separator. */
2171 /* Scroll bars occupy a few columns. */
2172 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2173 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2175 /* The column of `|' characters separating side-by-side windows
2176 occupies one column only. */
2181 /* Scroll contents of window WINDOW up N lines. */
2184 window_scroll (window
, n
, noerror
)
2189 register struct window
*w
= XWINDOW (window
);
2190 register int opoint
= point
;
2192 register int ht
= window_internal_height (w
);
2193 register Lisp_Object tem
;
2195 Lisp_Object bolp
, nmoved
;
2197 XFASTINT (tem
) = point
;
2198 tem
= Fpos_visible_in_window_p (tem
, window
);
2202 Fvertical_motion (make_number (- ht
/ 2));
2203 XFASTINT (tem
) = point
;
2204 Fset_marker (w
->start
, tem
, w
->buffer
);
2205 w
->force_start
= Qt
;
2208 SET_PT (marker_position (w
->start
));
2209 lose
= n
< 0 && point
== BEGV
;
2210 Fvertical_motion (make_number (n
));
2220 Fsignal (Qbeginning_of_buffer
, Qnil
);
2225 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2226 w
->start_at_line_beg
= bolp
;
2227 w
->update_mode_line
= Qt
;
2228 XFASTINT (w
->last_modified
) = 0;
2234 tem
= Fvertical_motion (make_number (ht
));
2235 if (point
> opoint
|| XFASTINT (tem
) < ht
)
2238 Fvertical_motion (make_number (-1));
2246 Fsignal (Qend_of_buffer
, Qnil
);
2250 /* This is the guts of Fscroll_up and Fscroll_down. */
2253 scroll_command (n
, direction
)
2254 register Lisp_Object n
;
2257 register int defalt
;
2258 int count
= specpdl_ptr
- specpdl
;
2260 /* If selected window's buffer isn't current, make it current for the moment.
2261 But don't screw up if window_scroll gets an error. */
2262 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2264 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2265 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2268 defalt
= (window_internal_height (XWINDOW (selected_window
))
2269 - next_screen_context_lines
);
2270 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2273 window_scroll (selected_window
, defalt
, 0);
2274 else if (EQ (n
, Qminus
))
2275 window_scroll (selected_window
, - defalt
, 0);
2278 n
= Fprefix_numeric_value (n
);
2279 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2282 unbind_to (count
, Qnil
);
2285 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2286 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2287 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2288 When calling from a program, supply a number as argument or nil.")
2292 scroll_command (n
, 1);
2296 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2297 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2298 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2299 When calling from a program, supply a number as argument or nil.")
2303 scroll_command (n
, -1);
2307 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2308 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2309 The next window is the one below the current one; or the one at the top\n\
2310 if the current one is at the bottom.\n\
2311 When calling from a program, supply a number as argument or nil.\n\
2313 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2314 specifies the window to scroll.\n\
2315 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2316 showing that buffer, popping the buffer up if necessary.")
2318 register Lisp_Object n
;
2320 register Lisp_Object window
;
2322 register struct window
*w
;
2323 register int count
= specpdl_ptr
- specpdl
;
2325 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2326 && !NILP (Vminibuf_scroll_window
))
2327 window
= Vminibuf_scroll_window
;
2328 /* If buffer is specified, scroll that buffer. */
2329 else if (!NILP (Vother_window_scroll_buffer
))
2331 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2333 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2337 /* Nothing specified; look for a neighboring window on the same
2339 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2341 if (EQ (window
, selected_window
))
2342 /* That didn't get us anywhere; look for a window on another
2345 window
= Fnext_window (window
, Qnil
, Qt
);
2346 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2347 && ! EQ (window
, selected_window
));
2350 CHECK_LIVE_WINDOW (window
, 0);
2352 if (EQ (window
, selected_window
))
2353 error ("There is no other window");
2355 w
= XWINDOW (window
);
2356 ht
= window_internal_height (w
);
2358 /* Don't screw up if window_scroll gets an error. */
2359 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2361 Fset_buffer (w
->buffer
);
2362 SET_PT (marker_position (w
->pointm
));
2365 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2366 else if (EQ (n
, Qminus
))
2367 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2370 if (XTYPE (n
) == Lisp_Cons
)
2372 CHECK_NUMBER (n
, 0);
2373 window_scroll (window
, XINT (n
), 1);
2376 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
2377 unbind_to (count
, Qnil
);
2382 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2383 "Scroll selected window display ARG columns left.\n\
2384 Default for ARG is window width minus 2.")
2386 register Lisp_Object arg
;
2390 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2392 arg
= Fprefix_numeric_value (arg
);
2395 Fset_window_hscroll (selected_window
,
2396 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2400 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2401 "Scroll selected window display ARG columns right.\n\
2402 Default for ARG is window width minus 2.")
2404 register Lisp_Object arg
;
2407 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2409 arg
= Fprefix_numeric_value (arg
);
2412 Fset_window_hscroll (selected_window
,
2413 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2417 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2418 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2419 The desired position of point is always relative to the current window.\n\
2420 Just C-u as prefix means put point in the center of the window.\n\
2421 No arg (i.e., it is nil) erases the entire frame and then\n\
2422 redraws with point in the center of the current window.")
2424 register Lisp_Object n
;
2426 register struct window
*w
= XWINDOW (selected_window
);
2427 register int ht
= window_internal_height (w
);
2428 register int opoint
= point
;
2432 extern int frame_garbaged
;
2434 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2435 XFASTINT (n
) = ht
/ 2;
2437 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2439 XFASTINT (n
) = ht
/ 2;
2443 n
= Fprefix_numeric_value (n
);
2444 CHECK_NUMBER (n
, 0);
2448 XSETINT (n
, XINT (n
) + ht
);
2450 XSETINT (n
, - XINT (n
));
2452 Fvertical_motion (n
);
2453 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2454 w
->start_at_line_beg
= Fbolp ();
2457 w
->force_start
= Qt
;
2462 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2464 "Position point relative to window.\n\
2465 With no argument, position text at center of window.\n\
2466 An argument specifies frame line; zero means top of window,\n\
2467 negative means relative to bottom of window.")
2469 register Lisp_Object arg
;
2471 register struct window
*w
= XWINDOW (selected_window
);
2472 register int height
= window_internal_height (w
);
2476 XFASTINT (arg
) = height
/ 2;
2479 arg
= Fprefix_numeric_value (arg
);
2481 XSETINT (arg
, XINT (arg
) + height
);
2484 start
= marker_position (w
->start
);
2485 if (start
< BEGV
|| start
> ZV
)
2487 Fvertical_motion (make_number (- height
/ 2));
2488 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2489 w
->start_at_line_beg
= Fbolp ();
2490 w
->force_start
= Qt
;
2495 return Fvertical_motion (arg
);
2498 struct save_window_data
2500 int size_from_Lisp_Vector_struct
;
2501 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2502 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2503 Lisp_Object selected_frame
;
2504 Lisp_Object current_window
;
2505 Lisp_Object current_buffer
;
2506 Lisp_Object minibuf_scroll_window
;
2507 Lisp_Object root_window
;
2508 Lisp_Object focus_frame
;
2509 /* A vector, interpreted as a struct saved_window */
2510 Lisp_Object saved_windows
;
2513 /* Arg to Fmake_vector */
2514 #define SAVE_WINDOW_DATA_SIZE \
2515 ((sizeof (struct save_window_data) \
2516 - (sizeof (struct Lisp_Vector) \
2517 /* Don't count the contents member of the struct Lisp_Vector */ \
2518 - sizeof (Lisp_Object))) \
2519 / sizeof (Lisp_Object))
2521 /* This is saved as a Lisp_Vector */
2524 /* these first two must agree with struct Lisp_Vector in lisp.h */
2525 int size_from_Lisp_Vector_struct
;
2526 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2529 Lisp_Object buffer
, start
, pointm
, mark
;
2530 Lisp_Object left
, top
, width
, height
, hscroll
;
2531 Lisp_Object parent
, prev
;
2532 Lisp_Object start_at_line_beg
;
2533 Lisp_Object display_table
;
2535 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2537 #define SAVED_WINDOW_N(swv,n) \
2538 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2540 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2541 "T if OBJECT is a window-configration object.")
2545 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2551 DEFUN ("set-window-configuration", Fset_window_configuration
,
2552 Sset_window_configuration
, 1, 1, 0,
2553 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2554 CONFIGURATION must be a value previously returned\n\
2555 by `current-window-configuration' (which see).")
2557 Lisp_Object configuration
;
2559 register struct save_window_data
*data
;
2560 struct Lisp_Vector
*saved_windows
;
2561 Lisp_Object new_current_buffer
;
2565 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2567 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2571 data
= (struct save_window_data
*) XVECTOR (configuration
);
2572 saved_windows
= XVECTOR (data
->saved_windows
);
2574 new_current_buffer
= data
->current_buffer
;
2575 if (NILP (XBUFFER (new_current_buffer
)->name
))
2576 new_current_buffer
= Qnil
;
2578 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2581 /* If f is a dead frame, don't bother rebuilding its window tree.
2582 However, there is other stuff we should still try to do below. */
2583 if (FRAME_LIVE_P (f
))
2585 register struct window
*w
;
2586 register struct saved_window
*p
;
2589 /* If the frame has been resized since this window configuration was
2590 made, we change the frame to the size specified in the
2591 configuration, restore the configuration, and then resize it
2592 back. We keep track of the prevailing height in these variables. */
2593 int previous_frame_height
= FRAME_HEIGHT (f
);
2594 int previous_frame_width
= FRAME_WIDTH (f
);
2595 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2597 if (XFASTINT (data
->frame_height
) != previous_frame_height
2598 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2599 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2600 if (XFASTINT (data
->frame_menu_bar_lines
)
2601 != previous_frame_menu_bar_lines
)
2602 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2604 windows_or_buffers_changed
++;
2607 Mark all windows now on frame as "deleted".
2608 Restoring the new configuration "undeletes" any that are in it.
2610 Save their current buffers in their height fields, since we may
2611 need it later, if a buffer saved in the configuration is now
2613 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2615 for (k
= 0; k
< saved_windows
->size
; k
++)
2617 p
= SAVED_WINDOW_N (saved_windows
, k
);
2618 w
= XWINDOW (p
->window
);
2621 if (!NILP (p
->parent
))
2622 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2623 XFASTINT (p
->parent
))->window
;
2627 if (!NILP (p
->prev
))
2629 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2630 XFASTINT (p
->prev
))->window
;
2631 XWINDOW (w
->prev
)->next
= p
->window
;
2636 if (!NILP (w
->parent
))
2638 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2640 XWINDOW (w
->parent
)->vchild
= p
->window
;
2641 XWINDOW (w
->parent
)->hchild
= Qnil
;
2645 XWINDOW (w
->parent
)->hchild
= p
->window
;
2646 XWINDOW (w
->parent
)->vchild
= Qnil
;
2651 /* If we squirreled away the buffer in the window's height,
2653 if (XTYPE (w
->height
) == Lisp_Buffer
)
2654 w
->buffer
= w
->height
;
2657 w
->width
= p
->width
;
2658 w
->height
= p
->height
;
2659 w
->hscroll
= p
->hscroll
;
2660 w
->display_table
= p
->display_table
;
2661 XFASTINT (w
->last_modified
) = 0;
2663 /* Reinstall the saved buffer and pointers into it. */
2664 if (NILP (p
->buffer
))
2665 w
->buffer
= p
->buffer
;
2668 if (!NILP (XBUFFER (p
->buffer
)->name
))
2669 /* If saved buffer is alive, install it. */
2671 w
->buffer
= p
->buffer
;
2672 w
->start_at_line_beg
= p
->start_at_line_beg
;
2673 set_marker_restricted (w
->start
,
2674 Fmarker_position (p
->start
),
2676 set_marker_restricted (w
->pointm
,
2677 Fmarker_position (p
->pointm
),
2679 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2680 Fmarker_position (p
->mark
), w
->buffer
);
2682 /* As documented in Fcurrent_window_configuration, don't
2683 save the location of point in the buffer which was current
2684 when the window configuration was recorded. */
2685 if (!EQ (p
->buffer
, new_current_buffer
) &&
2686 XBUFFER (p
->buffer
) == current_buffer
)
2687 Fgoto_char (w
->pointm
);
2689 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2690 /* Else unless window has a live buffer, get one. */
2692 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2693 /* This will set the markers to beginning of visible
2695 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2696 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2697 w
->start_at_line_beg
= Qt
;
2700 /* Keeping window's old buffer; make sure the markers
2703 /* Set window markers at start of visible range. */
2704 if (XMARKER (w
->start
)->buffer
== 0)
2705 set_marker_restricted (w
->start
, make_number (0),
2707 if (XMARKER (w
->pointm
)->buffer
== 0)
2708 set_marker_restricted (w
->pointm
,
2710 (BUF_PT (XBUFFER (w
->buffer
)))),
2712 w
->start_at_line_beg
= Qt
;
2717 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2718 Fselect_window (data
->current_window
);
2721 if (NILP (data
->focus_frame
)
2722 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2723 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2724 Fredirect_frame_focus (frame
, data
->focus_frame
);
2727 #if 0 /* I don't understand why this is needed, and it causes problems
2728 when the frame's old selected window has been deleted. */
2730 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2731 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2735 /* Set the screen height to the value it had before this function. */
2736 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2737 || previous_frame_width
!= FRAME_WIDTH (f
))
2738 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2740 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2741 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2745 /* Fselect_window will have made f the selected frame, so we
2746 reselect the proper frame here. Fhandle_switch_frame will change the
2747 selected window too, but that doesn't make the call to
2748 Fselect_window above totally superfluous; it still sets f's
2750 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2751 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2754 if (!NILP (new_current_buffer
))
2755 Fset_buffer (new_current_buffer
);
2757 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2761 /* Mark all windows now on frame as deleted
2762 by setting their buffers to nil. */
2765 delete_all_subwindows (w
)
2766 register struct window
*w
;
2768 if (!NILP (w
->next
))
2769 delete_all_subwindows (XWINDOW (w
->next
));
2770 if (!NILP (w
->vchild
))
2771 delete_all_subwindows (XWINDOW (w
->vchild
));
2772 if (!NILP (w
->hchild
))
2773 delete_all_subwindows (XWINDOW (w
->hchild
));
2775 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2777 /* We set all three of these fields to nil, to make sure that we can
2778 distinguish this dead window from any live window. Live leaf
2779 windows will have buffer set, and combination windows will have
2780 vchild or hchild set. */
2787 count_windows (window
)
2788 register struct window
*window
;
2790 register int count
= 1;
2791 if (!NILP (window
->next
))
2792 count
+= count_windows (XWINDOW (window
->next
));
2793 if (!NILP (window
->vchild
))
2794 count
+= count_windows (XWINDOW (window
->vchild
));
2795 if (!NILP (window
->hchild
))
2796 count
+= count_windows (XWINDOW (window
->hchild
));
2801 save_window_save (window
, vector
, i
)
2803 struct Lisp_Vector
*vector
;
2806 register struct saved_window
*p
;
2807 register struct window
*w
;
2808 register Lisp_Object tem
;
2810 for (;!NILP (window
); window
= w
->next
)
2812 p
= SAVED_WINDOW_N (vector
, i
);
2813 w
= XWINDOW (window
);
2815 XFASTINT (w
->temslot
) = i
++;
2817 p
->buffer
= w
->buffer
;
2820 p
->width
= w
->width
;
2821 p
->height
= w
->height
;
2822 p
->hscroll
= w
->hscroll
;
2823 p
->display_table
= w
->display_table
;
2824 if (!NILP (w
->buffer
))
2826 /* Save w's value of point in the window configuration.
2827 If w is the selected window, then get the value of point
2828 from the buffer; pointm is garbage in the selected window. */
2829 if (EQ (window
, selected_window
))
2831 p
->pointm
= Fmake_marker ();
2832 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2836 p
->pointm
= Fcopy_marker (w
->pointm
);
2838 p
->start
= Fcopy_marker (w
->start
);
2839 p
->start_at_line_beg
= w
->start_at_line_beg
;
2841 tem
= XBUFFER (w
->buffer
)->mark
;
2842 p
->mark
= Fcopy_marker (tem
);
2849 p
->start_at_line_beg
= Qnil
;
2852 if (NILP (w
->parent
))
2855 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2860 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2862 if (!NILP (w
->vchild
))
2863 i
= save_window_save (w
->vchild
, vector
, i
);
2864 if (!NILP (w
->hchild
))
2865 i
= save_window_save (w
->hchild
, vector
, i
);
2871 DEFUN ("current-window-configuration",
2872 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2873 "Return an object representing the current window configuration of FRAME.\n\
2874 If FRAME is nil or omitted, use the selected frame.\n\
2875 This describes the number of windows, their sizes and current buffers,\n\
2876 and for each displayed buffer, where display starts, and the positions of\n\
2877 point and mark. An exception is made for point in the current buffer:\n\
2878 its value is -not- saved.\n\
2879 This also records the currently selected frame, and FRAME's focus\n\
2880 redirection (see `redirect-frame-focus').")
2884 register Lisp_Object tem
;
2885 register int n_windows
;
2886 register struct save_window_data
*data
;
2894 CHECK_LIVE_FRAME (frame
, 0);
2898 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2899 data
= (struct save_window_data
*)
2900 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2902 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2903 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2904 XFASTINT (data
->frame_menu_bar_lines
) = FRAME_MENU_BAR_LINES (f
);
2906 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2908 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2909 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2910 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2911 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2912 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2913 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2914 data
->saved_windows
= tem
;
2915 for (i
= 0; i
< n_windows
; i
++)
2916 XVECTOR (tem
)->contents
[i
]
2917 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2918 save_window_save (FRAME_ROOT_WINDOW (f
),
2920 XSET (tem
, Lisp_Window_Configuration
, data
);
2924 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2926 "Execute body, preserving window sizes and contents.\n\
2927 Restores which buffer appears in which window, where display starts,\n\
2928 as well as the current buffer.\n\
2929 Does not restore the value of point in current buffer.")
2933 register Lisp_Object val
;
2934 register int count
= specpdl_ptr
- specpdl
;
2936 record_unwind_protect (Fset_window_configuration
,
2937 Fcurrent_window_configuration (Qnil
));
2938 val
= Fprogn (args
);
2939 return unbind_to (count
, val
);
2945 selected_frame
= make_terminal_frame ();
2946 minibuf_window
= selected_frame
->minibuffer_window
;
2947 selected_window
= selected_frame
->selected_window
;
2948 last_nonminibuf_frame
= selected_frame
;
2949 #else /* not MULTI_FRAME */
2950 extern Lisp_Object
get_minibuffer ();
2952 minibuf_window
= make_window ();
2953 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
2955 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
2956 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
2957 XWINDOW (minibuf_window
)->mini_p
= Qt
;
2959 /* These values 9 and 10 are arbitrary,
2960 just so that there is "something there."
2961 Correct values are put in in init_xdisp */
2963 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
2964 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
2966 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
2967 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
2968 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
2970 /* Prevent error in Fset_window_buffer. */
2971 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
2972 XWINDOW (minibuf_window
)->buffer
= Qt
;
2974 /* Now set them up for real. */
2975 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
2976 Fcurrent_buffer ());
2977 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
2979 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
2980 /* Make sure this window seems more recently used than
2981 a newly-created, never-selected window. Increment
2982 window_select_count so the first selection ever will get
2983 something newer than this. */
2984 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
2985 #endif /* not MULTI_FRAME */
2990 Qwindowp
= intern ("windowp");
2991 staticpro (&Qwindowp
);
2993 Qwindow_live_p
= intern ("window-live-p");
2994 staticpro (&Qwindow_live_p
);
2997 /* Make sure all windows get marked */
2998 staticpro (&minibuf_window
);
3001 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3002 "Non-nil means call as function to display a help buffer.\n\
3003 Used by `with-output-to-temp-buffer'.");
3004 Vtemp_buffer_show_function
= Qnil
;
3006 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3007 "If non-nil, function to call to handle `display-buffer'.\n\
3008 It will receive two args, the buffer and a flag which if non-nil means\n\
3009 that the currently selected window is not acceptable.\n\
3010 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3011 work using this function.");
3012 Vdisplay_buffer_function
= Qnil
;
3014 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3015 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3016 Vminibuf_scroll_window
= Qnil
;
3018 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3019 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3020 Vother_window_scroll_buffer
= Qnil
;
3022 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3023 "*Non-nil means `display-buffer' should make a separate frame.");
3026 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3027 "*If non-nil, function to call to handle automatic new frame creation.\n\
3028 It is called with no arguments and should return a newly created frame.\n\
3030 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3031 where `pop-up-frame-alist' would hold the default frame parameters.");
3032 Vpop_up_frame_function
= Qnil
;
3034 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3035 "*Non-nil means display-buffer should make new windows.");
3038 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3039 "*Number of lines of continuity when scrolling by screenfuls.");
3040 next_screen_context_lines
= 2;
3042 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3043 "*display-buffer would prefer to split the largest window if this large.\n\
3044 If there is only one window, it is split regardless of this value.");
3045 split_height_threshold
= 500;
3047 DEFVAR_INT ("window-min-height", &window_min_height
,
3048 "*Delete any window less than this tall (including its mode line).");
3049 window_min_height
= 4;
3051 DEFVAR_INT ("window-min-width", &window_min_width
,
3052 "*Delete any window less than this wide.");
3053 window_min_width
= 10;
3055 defsubr (&Sselected_window
);
3056 defsubr (&Sminibuffer_window
);
3057 defsubr (&Swindow_minibuffer_p
);
3058 defsubr (&Swindowp
);
3059 defsubr (&Swindow_live_p
);
3060 defsubr (&Spos_visible_in_window_p
);
3061 defsubr (&Swindow_buffer
);
3062 defsubr (&Swindow_height
);
3063 defsubr (&Swindow_width
);
3064 defsubr (&Swindow_hscroll
);
3065 defsubr (&Sset_window_hscroll
);
3066 defsubr (&Swindow_edges
);
3067 defsubr (&Scoordinates_in_window_p
);
3068 defsubr (&Swindow_at
);
3069 defsubr (&Swindow_point
);
3070 defsubr (&Swindow_start
);
3071 defsubr (&Swindow_end
);
3072 defsubr (&Sset_window_point
);
3073 defsubr (&Sset_window_start
);
3074 defsubr (&Swindow_dedicated_p
);
3075 defsubr (&Sset_window_dedicated_p
);
3076 defsubr (&Swindow_display_table
);
3077 defsubr (&Sset_window_display_table
);
3078 defsubr (&Snext_window
);
3079 defsubr (&Sprevious_window
);
3080 defsubr (&Sother_window
);
3081 defsubr (&Sget_lru_window
);
3082 defsubr (&Sget_largest_window
);
3083 defsubr (&Sget_buffer_window
);
3084 defsubr (&Sdelete_other_windows
);
3085 defsubr (&Sdelete_windows_on
);
3086 defsubr (&Sreplace_buffer_in_windows
);
3087 defsubr (&Sdelete_window
);
3088 defsubr (&Sset_window_buffer
);
3089 defsubr (&Sselect_window
);
3090 defsubr (&Sdisplay_buffer
);
3091 defsubr (&Ssplit_window
);
3092 defsubr (&Senlarge_window
);
3093 defsubr (&Sshrink_window
);
3094 defsubr (&Sscroll_up
);
3095 defsubr (&Sscroll_down
);
3096 defsubr (&Sscroll_left
);
3097 defsubr (&Sscroll_right
);
3098 defsubr (&Sscroll_other_window
);
3099 defsubr (&Srecenter
);
3100 defsubr (&Smove_to_window_line
);
3101 defsubr (&Swindow_configuration_p
);
3102 defsubr (&Sset_window_configuration
);
3103 defsubr (&Scurrent_window_configuration
);
3104 defsubr (&Ssave_window_excursion
);
3109 initial_define_key (control_x_map
, '1', "delete-other-windows");
3110 initial_define_key (control_x_map
, '2', "split-window");
3111 initial_define_key (control_x_map
, '0', "delete-window");
3112 initial_define_key (control_x_map
, 'o', "other-window");
3113 initial_define_key (control_x_map
, '^', "enlarge-window");
3114 initial_define_key (control_x_map
, '<', "scroll-left");
3115 initial_define_key (control_x_map
, '>', "scroll-right");
3117 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3118 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3119 initial_define_key (meta_map
, 'v', "scroll-down");
3121 initial_define_key (global_map
, Ctl('L'), "recenter");
3122 initial_define_key (meta_map
, 'r', "move-to-window-line");