1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 Lisp_Object Qwindowp
, Qwindow_live_p
;
34 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
35 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
37 void delete_all_subwindows ();
38 static struct window
*decode_window();
40 /* This is the window in which the terminal's cursor should
41 be left when nothing is being done with it. This must
42 always be a leaf window, and its buffer is selected by
43 the top level editing loop at the end of each command.
45 This value is always the same as
46 FRAME_SELECTED_WINDOW (selected_frame). */
48 Lisp_Object selected_window
;
50 /* The minibuffer window of the selected frame.
51 Note that you cannot test for minibufferness of an arbitrary window
52 by comparing against this; but you can test for minibufferness of
53 the selected window. */
54 Lisp_Object minibuf_window
;
56 /* Non-nil means it is the window for C-M-v to scroll
57 when the minibuffer is selected. */
58 Lisp_Object Vminibuf_scroll_window
;
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
61 Lisp_Object Vother_window_scroll_buffer
;
63 /* Non-nil means it's function to call to display temp buffers. */
64 Lisp_Object Vtemp_buffer_show_function
;
66 /* If a window gets smaller than either of these, it is removed. */
67 int window_min_height
;
70 /* Nonzero implies Fdisplay_buffer should create windows. */
73 /* Nonzero implies make new frames for Fdisplay_buffer. */
76 /* Non-nil means use this function instead of default */
77 Lisp_Object Vpop_up_frame_function
;
79 /* Function to call to handle Fdisplay_buffer. */
80 Lisp_Object Vdisplay_buffer_function
;
82 /* Fdisplay_buffer always splits the largest window
83 if that window is more than this high. */
84 int split_height_threshold
;
86 /* Number of lines of continuity in scrolling by screenfuls. */
87 int next_screen_context_lines
;
89 /* Incremented for each window created. */
90 static int sequence_number
;
92 #define min(a, b) ((a) < (b) ? (a) : (b))
94 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
95 "Returns t if OBJ is a window.")
99 return XTYPE (obj
) == Lisp_Window
? Qt
: Qnil
;
102 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
103 "Returns t if OBJ is a window which is currently visible.")
107 return ((XTYPE (obj
) == Lisp_Window
108 && ! NILP (XWINDOW (obj
)->buffer
))
115 register Lisp_Object val
;
116 register struct window
*p
;
118 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector)
119 includes the first element. */
121 make_number ((sizeof (struct window
) - sizeof (struct Lisp_Vector
)
122 + sizeof (Lisp_Object
))
123 / sizeof (Lisp_Object
)),
125 XSETTYPE (val
, Lisp_Window
);
127 XFASTINT (p
->sequence_number
) = ++sequence_number
;
128 XFASTINT (p
->left
) = XFASTINT (p
->top
)
129 = XFASTINT (p
->height
) = XFASTINT (p
->width
)
130 = XFASTINT (p
->hscroll
) = 0;
131 XFASTINT (p
->last_point_x
) = XFASTINT (p
->last_point_y
) = 0;
132 p
->start
= Fmake_marker ();
133 p
->pointm
= Fmake_marker ();
134 XFASTINT (p
->use_time
) = 0;
136 p
->display_table
= Qnil
;
141 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
142 "Return the window that the cursor now appears in and commands apply to.")
145 return selected_window
;
148 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
149 "Return the window used now for minibuffers.\n\
150 If the optional argument FRAME is specified, return the minibuffer window\n\
151 used by that frame.")
157 XSET (frame
, Lisp_Frame
, selected_frame
);
159 CHECK_LIVE_FRAME (frame
, 0);
162 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
165 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
166 "Returns non-nil if WINDOW is a minibuffer window.")
170 struct window
*w
= decode_window (window
);
171 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
174 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
175 Spos_visible_in_window_p
, 0, 2, 0,
176 "Return t if position POS is currently on the frame in WINDOW.\n\
177 Returns nil if that position is scrolled vertically out of view.\n\
178 POS defaults to point; WINDOW, to the selected window.")
180 Lisp_Object pos
, window
;
182 register struct window
*w
;
186 register struct buffer
*buf
;
187 struct position posval
;
193 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
197 w
= decode_window (window
);
198 top
= marker_position (w
->start
);
203 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
205 buf
= XBUFFER (w
->buffer
);
206 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
208 /* If frame is up to date,
209 use the info recorded about how much text fit on it. */
210 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
211 || (XFASTINT (w
->window_end_vpos
) < height
))
217 if (posint
> BUF_Z (buf
))
220 /* If that info is not correct, calculate afresh */
221 posval
= *compute_motion (top
, 0, 0, posint
, height
, 0,
222 window_internal_width (w
) - 1,
223 XINT (w
->hscroll
), 0);
225 return posval
.vpos
< height
? Qt
: Qnil
;
229 static struct window
*
230 decode_window (window
)
231 register Lisp_Object window
;
234 return XWINDOW (selected_window
);
236 CHECK_LIVE_WINDOW (window
, 0);
237 return XWINDOW (window
);
240 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
241 "Return the buffer that WINDOW is displaying.")
245 return decode_window (window
)->buffer
;
248 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
249 "Return the number of lines in WINDOW (including its mode line).")
253 return decode_window (window
)->height
;
256 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
257 "Return the number of columns in WINDOW.")
261 register struct window
*w
= decode_window (window
);
262 register int width
= XFASTINT (w
->width
);
264 return make_number (window_internal_width (w
));
267 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
268 "Return the number of columns by which WINDOW is scrolled from left margin.")
272 return decode_window (window
)->hscroll
;
275 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
276 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
277 NCOL should be zero or positive.")
279 register Lisp_Object window
, ncol
;
281 register struct window
*w
;
283 CHECK_NUMBER (ncol
, 1);
284 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
285 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
286 args_out_of_range (ncol
, Qnil
);
287 w
= decode_window (window
);
288 if (XINT (w
->hscroll
) != XINT (ncol
))
289 clip_changed
= 1; /* Prevent redisplay shortcuts */
294 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
295 "Return a list of the edge coordinates of WINDOW.\n\
296 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
297 RIGHT is one more than the rightmost column used by WINDOW,\n\
298 and BOTTOM is one more than the bottommost row used by WINDOW\n\
303 register struct window
*w
= decode_window (window
);
305 return Fcons (w
->left
, Fcons (w
->top
,
306 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
307 Fcons (make_number (XFASTINT (w
->top
)
308 + XFASTINT (w
->height
)),
312 /* Test if the character at column *x, row *y is within window *w.
313 If it is not, return 0;
314 if it is in the window's text area,
315 set *x and *y to its location relative to the upper left corner
318 if it is on the window's modeline, return 2;
319 if it is on the border between the window and its right sibling,
322 coordinates_in_window (w
, x
, y
)
323 register struct window
*w
;
326 register int left
= XINT (w
->left
);
327 register int width
= XINT (w
->width
);
328 register int window_height
= XINT (w
->height
);
329 register int top
= XFASTINT (w
->top
);
331 if ( *x
< left
|| *x
>= left
+ width
332 || *y
< top
|| *y
>= top
+ window_height
)
335 /* Is the character is the mode line? */
336 if (*y
== top
+ window_height
- 1
337 && ! MINI_WINDOW_P (w
))
340 /* Is the character in the right border? */
341 if (*x
== left
+ width
- 1
342 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
350 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
351 Scoordinates_in_window_p
, 2, 2, 0,
352 "Return non-nil if COORDINATES are in WINDOW.\n\
353 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
354 measured in characters from the upper-left corner of the frame.\n\
355 (0 . 0) denotes the character in the upper left corner of the\n\
357 If COORDINATES are in the text portion of WINDOW,\n\
358 the coordinates relative to the window are returned.\n\
359 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
360 If they are on the border between WINDOW and its right sibling,\n\
361 `vertical-line' is returned.")
362 (coordinates
, window
)
363 register Lisp_Object coordinates
, window
;
367 CHECK_LIVE_WINDOW (window
, 0);
368 CHECK_CONS (coordinates
, 1);
369 x
= XINT (Fcar (coordinates
));
370 y
= XINT (Fcdr (coordinates
));
372 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
374 case 0: /* NOT in window at all. */
377 case 1: /* In text part of window. */
380 case 2: /* In mode line of window. */
383 case 3: /* On right border of window. */
384 return Qvertical_line
;
391 /* Find the window containing column x, row y, and return it as a
392 Lisp_Object. If x, y is on the window's modeline, set *part
393 to 1; if it is on the separating line between the window and its
394 right sibling, set it to 2; otherwise set it to 0. If there is no
395 window under x, y return nil and leave *part unmodified. */
397 window_from_coordinates (frame
, x
, y
, part
)
402 register Lisp_Object tem
, first
;
404 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
408 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
416 tem
= Fnext_window (tem
, Qt
, Qlambda
);
418 while (! EQ (tem
, first
));
423 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
424 "Return window containing coordinates X and Y on FRAME.\n\
425 If omitted, FRAME defaults to the currently selected frame.\n\
426 The top left corner of the frame is considered to be row 0,\n\
429 Lisp_Object x
, y
, frame
;
435 XSET (frame
, Lisp_Frame
, selected_frame
);
437 CHECK_LIVE_FRAME (frame
, 2);
442 return window_from_coordinates (XFRAME (frame
),
447 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
448 "Return current value of point in WINDOW.\n\
449 For a nonselected window, this is the value point would have\n\
450 if that window were selected.\n\
452 Note that, when WINDOW is the selected window and its buffer\n\
453 is also currently selected, the value returned is the same as (point).\n\
454 It would be more strictly correct to return the `top-level' value\n\
455 of point, outside of any save-excursion forms.\n\
456 But that is hard to define.")
460 register struct window
*w
= decode_window (window
);
462 if (w
== XWINDOW (selected_window
)
463 && current_buffer
== XBUFFER (w
->buffer
))
465 return Fmarker_position (w
->pointm
);
468 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
469 "Return position at which display currently starts in WINDOW.")
473 return Fmarker_position (decode_window (window
)->start
);
476 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
477 "Return position at which display currently ends in WINDOW.")
482 struct window
*w
= decode_window (window
);
484 XSET (value
, Lisp_Int
,
485 BUF_Z (current_buffer
) - XFASTINT (w
->window_end_pos
));
490 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
491 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
493 Lisp_Object window
, pos
;
495 register struct window
*w
= decode_window (window
);
497 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
498 if (w
== XWINDOW (selected_window
))
501 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
506 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
507 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
508 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
509 from overriding motion of point in order to display at this exact start.")
510 (window
, pos
, noforce
)
511 Lisp_Object window
, pos
, noforce
;
513 register struct window
*w
= decode_window (window
);
515 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
516 set_marker_restricted (w
->start
, pos
, w
->buffer
);
517 /* this is not right, but much easier than doing what is right. */
518 w
->start_at_line_beg
= Qnil
;
521 w
->update_mode_line
= Qt
;
522 XFASTINT (w
->last_modified
) = 0;
523 if (!EQ (window
, selected_window
))
524 windows_or_buffers_changed
++;
528 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
530 "Return WINDOW's dedicated object, usually t or nil.\n\
531 See also `set-window-dedicated-p'.")
535 return decode_window (window
)->dedicated
;
538 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
539 Sset_window_dedicated_p
, 2, 2, 0,
540 "Control whether WINDOW is dedicated to the buffer it displays.\n\
541 If it is dedicated, Emacs will not automatically change\n\
542 which buffer appears in it.\n\
543 The second argument is the new value for the dedication flag;\n\
546 Lisp_Object window
, arg
;
548 register struct window
*w
= decode_window (window
);
558 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
560 "Return the display-table that WINDOW is using.")
564 return decode_window (window
)->display_table
;
567 /* Get the display table for use currently on window W.
568 This is either W's display table or W's buffer's display table.
569 Ignore the specified tables if they are not valid;
570 if no valid table is specified, return 0. */
573 window_display_table (w
)
577 tem
= w
->display_table
;
578 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
579 return XVECTOR (tem
);
580 tem
= XBUFFER (w
->buffer
)->display_table
;
581 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
582 return XVECTOR (tem
);
583 tem
= Vstandard_display_table
;
584 if (XTYPE (tem
) == Lisp_Vector
&& XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
585 return XVECTOR (tem
);
589 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
590 "Set WINDOW's display-table to TABLE.")
592 register Lisp_Object window
, table
;
594 register struct window
*w
;
595 register Lisp_Object z
; /* Return value. */
597 w
= decode_window (window
);
598 w
->display_table
= table
;
602 /* Record info on buffer window w is displaying
603 when it is about to cease to display that buffer. */
606 register struct window
*w
;
608 Lisp_Object buf
= w
->buffer
;
610 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
613 if (w
== XWINDOW (selected_window
)
614 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
615 /* Do this except when the selected window's buffer
616 is being removed from some other window. */
617 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
619 /* Point in the selected window's buffer
620 is actually stored in that buffer, and the window's pointm isn't used.
621 So don't clobber point in that buffer. */
622 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
623 BUF_PT (XBUFFER (buf
))
624 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
625 marker_position (w
->pointm
),
626 BUF_ZV (XBUFFER (buf
)));
629 /* Put replacement into the window structure in place of old. */
631 replace_window (old
, replacement
)
632 Lisp_Object old
, replacement
;
634 register Lisp_Object tem
;
635 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
637 /* If OLD is its frame's root_window, then replacement is the new
638 root_window for that frame. */
640 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
641 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
646 p
->height
= o
->height
;
648 p
->next
= tem
= o
->next
;
650 XWINDOW (tem
)->prev
= replacement
;
652 p
->prev
= tem
= o
->prev
;
654 XWINDOW (tem
)->next
= replacement
;
656 p
->parent
= tem
= o
->parent
;
659 if (EQ (XWINDOW (tem
)->vchild
, old
))
660 XWINDOW (tem
)->vchild
= replacement
;
661 if (EQ (XWINDOW (tem
)->hchild
, old
))
662 XWINDOW (tem
)->hchild
= replacement
;
665 /*** Here, if replacement is a vertical combination
666 and so is its new parent, we should make replacement's
667 children be children of that parent instead. ***/
670 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
671 "Remove WINDOW from the display. Default is selected window.")
673 register Lisp_Object window
;
675 register Lisp_Object tem
, parent
, sib
;
676 register struct window
*p
;
677 register struct window
*par
;
679 /* Because this function is called by other C code on non-leaf
680 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
681 so we can't decode_window here. */
683 window
= selected_window
;
685 CHECK_WINDOW (window
, 0);
686 p
= XWINDOW (window
);
688 /* It's okay to delete an already-deleted window. */
696 error ("Attempt to delete minibuffer or sole ordinary window");
697 par
= XWINDOW (parent
);
699 windows_or_buffers_changed
++;
701 /* Are we trying to delete any frame's selected window? */
703 Lisp_Object frame
= WINDOW_FRAME (XWINDOW (window
));
705 if (EQ (window
, FRAME_SELECTED_WINDOW (XFRAME (frame
))))
707 Lisp_Object alternative
= Fnext_window (window
, Qlambda
, Qnil
);
709 /* If we're about to delete the selected window on the
710 selected frame, then we should use Fselect_window to select
711 the new window. On the other hand, if we're about to
712 delete the selected window on any other frame, we shouldn't do
713 anything but set the frame's selected_window slot. */
714 if (EQ (window
, selected_window
))
715 Fselect_window (alternative
);
717 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
722 /* tem is null for dummy parent windows
723 (which have inferiors but not any contents themselves) */
727 unchain_marker (p
->pointm
);
728 unchain_marker (p
->start
);
733 XWINDOW (tem
)->prev
= p
->prev
;
737 XWINDOW (tem
)->next
= p
->next
;
739 if (EQ (window
, par
->hchild
))
740 par
->hchild
= p
->next
;
741 if (EQ (window
, par
->vchild
))
742 par
->vchild
= p
->next
;
744 /* Find one of our siblings to give our space to. */
748 /* If p gives its space to its next sibling, that sibling needs
749 to have its top/left side pulled back to where p's is.
750 set_window_{height,width} will re-position the sibling's
753 XWINDOW (sib
)->top
= p
->top
;
754 XWINDOW (sib
)->left
= p
->left
;
757 /* Stretch that sibling. */
758 if (!NILP (par
->vchild
))
759 set_window_height (sib
,
760 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
762 if (!NILP (par
->hchild
))
763 set_window_width (sib
,
764 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
767 /* If parent now has only one child,
768 put the child into the parent's place. */
772 if (NILP (XWINDOW (tem
)->next
))
773 replace_window (parent
, tem
);
775 /* Since we may be deleting combination windows, we must make sure that
776 not only p but all its children have been marked as deleted. */
777 if (! NILP (p
->hchild
))
778 delete_all_subwindows (XWINDOW (p
->hchild
));
779 else if (! NILP (p
->vchild
))
780 delete_all_subwindows (XWINDOW (p
->vchild
));
782 /* Mark this window as deleted. */
783 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
789 extern Lisp_Object
next_frame (), prev_frame ();
791 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
792 "Return next window after WINDOW in canonical ordering of windows.\n\
793 If omitted, WINDOW defaults to the selected window.\n\
795 Optional second arg MINIBUF t means count the minibuffer window even\n\
796 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
797 it is active. MINIBUF neither t nor nil means not to count the\n\
798 minibuffer even if it is active.\n\
800 Several frames may share a single minibuffer; if the minibuffer\n\
801 counts, all windows on all frames that share that minibuffer count\n\
802 too. This means that next-window may be used to iterate through the\n\
803 set of windows even when the minibuffer is on another frame. If the\n\
804 minibuffer does not count, only windows from WINDOW's frame count.\n\
806 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
807 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
808 above. If neither nil nor t, restrict to WINDOW's frame.\n\
810 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
811 `next-window' to iterate through the entire cycle of acceptable\n\
812 windows, eventually ending up back at the window you started with.\n\
813 `previous-window' traverses the same cycle, in the reverse order.")
814 (window
, minibuf
, all_frames
)
815 register Lisp_Object window
, minibuf
, all_frames
;
817 register Lisp_Object tem
;
818 Lisp_Object start_window
;
821 window
= selected_window
;
823 CHECK_LIVE_WINDOW (window
, 0);
825 start_window
= window
;
827 /* minibuf == nil may or may not include minibuffers.
828 Decide if it does. */
830 minibuf
= (minibuf_level
? Qt
: Qlambda
);
832 /* all_frames == nil doesn't specify which frames to include.
833 Decide which frames it includes. */
834 if (NILP (all_frames
))
835 all_frames
= (EQ (minibuf
, Qt
)
836 ? (FRAME_MINIBUF_WINDOW
839 (XWINDOW (window
)))))
841 else if (! EQ (all_frames
, Qt
))
844 /* Do this loop at least once, to get the next window, and perhaps
845 again, if we hit the minibuffer and that is not acceptable. */
848 /* Find a window that actually has a next one. This loop
849 climbs up the tree. */
850 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
851 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
855 /* We've reached the end of this frame.
856 Which other frames are acceptable? */
857 tem
= WINDOW_FRAME (XWINDOW (window
));
859 if (! NILP (all_frames
))
860 tem
= next_frame (tem
, all_frames
);
862 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
869 /* If we're in a combination window, find its first child and
870 recurse on that. Otherwise, we've found the window we want. */
873 if (!NILP (XWINDOW (window
)->hchild
))
874 window
= XWINDOW (window
)->hchild
;
875 else if (!NILP (XWINDOW (window
)->vchild
))
876 window
= XWINDOW (window
)->vchild
;
880 /* Which windows are acceptible?
881 Exit the loop and accept this window if
882 this isn't a minibuffer window, or
883 we're accepting minibuffer windows, or
884 we've come all the way around and we're back at the original window. */
885 while (MINI_WINDOW_P (XWINDOW (window
))
886 && ! EQ (minibuf
, Qt
)
887 && ! EQ (window
, start_window
));
892 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
893 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
894 If omitted, WINDOW defaults to the selected window.\n\
896 Optional second arg MINIBUF t means count the minibuffer window even\n\
897 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
898 it is active. MINIBUF neither t nor nil means not to count the\n\
899 minibuffer even if it is active.\n\
901 Several frames may share a single minibuffer; if the minibuffer\n\
902 counts, all windows on all frames that share that minibuffer count\n\
903 too. This means that previous-window may be used to iterate through\n\
904 the set of windows even when the minibuffer is on another frame. If\n\
905 the minibuffer does not count, only windows from WINDOW's frame\n\
908 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
909 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
910 above. If neither nil nor t, restrict to WINDOW's frame.\n\
912 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
913 `previous-window' to iterate through the entire cycle of acceptable\n\
914 windows, eventually ending up back at the window you started with.\n\
915 `next-window' traverses the same cycle, in the reverse order.")
916 (window
, minibuf
, all_frames
)
917 register Lisp_Object window
, minibuf
, all_frames
;
919 register Lisp_Object tem
;
920 Lisp_Object start_window
;
923 window
= selected_window
;
925 CHECK_LIVE_WINDOW (window
, 0);
927 start_window
= window
;
929 /* minibuf == nil may or may not include minibuffers.
930 Decide if it does. */
932 minibuf
= (minibuf_level
? Qt
: Qlambda
);
934 /* all_frames == nil doesn't specify which frames to include.
935 Decide which frames it includes. */
936 if (NILP (all_frames
))
937 all_frames
= (EQ (minibuf
, Qt
)
938 ? (FRAME_MINIBUF_WINDOW
941 (XWINDOW (window
)))))
943 else if (! EQ (all_frames
, Qt
))
946 /* Do this loop at least once, to get the previous window, and perhaps
947 again, if we hit the minibuffer and that is not acceptable. */
950 /* Find a window that actually has a previous one. This loop
951 climbs up the tree. */
952 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
953 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
957 /* We have found the top window on the frame.
958 Which frames are acceptable? */
959 tem
= WINDOW_FRAME (XWINDOW (window
));
961 if (! NILP (all_frames
))
962 /* It's actually important that we use prev_frame here,
963 rather than next_frame. All the windows acceptable
964 according to the given parameters should form a ring;
965 Fnext_window and Fprevious_window should go back and
966 forth around the ring. If we use next_frame here,
967 then Fnext_window and Fprevious_window take different
968 paths through the set of acceptable windows.
969 window_loop assumes that these `ring' requirement are
971 tem
= prev_frame (tem
, all_frames
);
973 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
979 /* If we're in a combination window, find its last child and
980 recurse on that. Otherwise, we've found the window we want. */
983 if (!NILP (XWINDOW (window
)->hchild
))
984 window
= XWINDOW (window
)->hchild
;
985 else if (!NILP (XWINDOW (window
)->vchild
))
986 window
= XWINDOW (window
)->vchild
;
988 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
992 /* Which windows are acceptable?
993 Exit the loop and accept this window if
994 this isn't a minibuffer window, or
995 we're accepting minibuffer windows, or
996 we've come all the way around and we're back at the original window. */
997 while (MINI_WINDOW_P (XWINDOW (window
))
999 && !EQ (window
, start_window
));
1004 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1005 "Select the ARG'th different window on this frame.\n\
1006 All windows on current frame are arranged in a cyclic order.\n\
1007 This command selects the window ARG steps away in that order.\n\
1008 A negative ARG moves in the opposite order. If the optional second\n\
1009 argument ALL_FRAMES is non-nil, cycle through all frames.")
1011 register Lisp_Object n
, all_frames
;
1014 register Lisp_Object w
;
1016 CHECK_NUMBER (n
, 0);
1017 w
= selected_window
;
1022 w
= Fnext_window (w
, Qnil
, all_frames
);
1027 w
= Fprevious_window (w
, Qnil
, all_frames
);
1034 /* Look at all windows, performing an operation specified by TYPE
1036 If FRAMES is Qt, look at all frames, if Qnil, look at just the selected
1037 frame. If FRAMES is a frame, just look at windows on that frame.
1038 If MINI is non-zero, perform the operation on minibuffer windows too.
1044 GET_BUFFER_WINDOW
, /* Arg is buffer */
1045 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1046 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1047 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1049 UNSHOW_BUFFER
, /* Arg is buffer */
1053 window_loop (type
, obj
, mini
, frames
)
1054 enum window_loop type
;
1055 register Lisp_Object obj
, frames
;
1058 register Lisp_Object w
;
1059 register Lisp_Object best_window
;
1060 register Lisp_Object next_window
;
1061 register Lisp_Object last_window
;
1065 /* If we're only looping through windows on a particular frame,
1066 frame points to that frame. If we're looping through windows
1067 on all frames, frame is 0. */
1068 if (FRAMEP (frames
))
1069 frame
= XFRAME (frames
);
1070 else if (NILP (frames
))
1071 frame
= selected_frame
;
1078 /* Pick a window to start with. */
1079 if (XTYPE (obj
) == Lisp_Window
)
1082 w
= FRAME_SELECTED_WINDOW (frame
);
1084 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1086 /* Figure out the last window we're going to mess with. Since
1087 Fnext_window, given the same options, is guaranteed to go in a
1088 ring, we can just use Fprevious_window to find the last one.
1090 We can't just wait until we hit the first window again, because
1091 it might be deleted. */
1095 last_window
= Fprevious_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1097 #endif /* MULTI_FRAME */
1098 /* We know frame is 0, so we're looping through all frames.
1099 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1100 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, Qt
);
1105 /* Pick the next window now, since some operations will delete
1106 the current window. */
1109 next_window
= Fnext_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1111 #endif /* MULTI_FRAME */
1112 /* We know frame is 0, so we're looping through all frames.
1113 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1114 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, Qt
);
1116 if (!MINI_WINDOW_P (XWINDOW (w
))
1117 || (mini
&& minibuf_level
> 0))
1120 case GET_BUFFER_WINDOW
:
1122 /* Ignore invisible and iconified frames. */
1123 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1124 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1127 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1131 case GET_LRU_WINDOW
:
1132 /* t as arg means consider only full-width windows */
1133 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1134 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1137 /* Ignore invisible and iconified frames. */
1138 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1139 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1142 /* Ignore dedicated windows and minibuffers. */
1143 if (MINI_WINDOW_P (XWINDOW (w
))
1144 || !NILP (XWINDOW (w
)->dedicated
))
1146 if (NILP (best_window
)
1147 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1148 > XFASTINT (XWINDOW (w
)->use_time
)))
1152 case DELETE_OTHER_WINDOWS
:
1153 if (XWINDOW (w
) != XWINDOW (obj
))
1157 case DELETE_BUFFER_WINDOWS
:
1158 if (EQ (XWINDOW (w
)->buffer
, obj
))
1160 /* If we're deleting the buffer displayed in the only window
1161 on the frame, find a new buffer to display there. */
1162 if (NILP (XWINDOW (w
)->parent
))
1164 Lisp_Object new_buffer
= Fother_buffer (obj
, Qnil
);
1165 if (NILP (new_buffer
))
1167 = Fget_buffer_create (build_string ("*scratch*"));
1168 Fset_window_buffer (w
, new_buffer
);
1169 Fset_buffer (XWINDOW (w
)->buffer
);
1176 case GET_LARGEST_WINDOW
:
1178 /* Ignore invisible and iconified frames. */
1179 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1180 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1183 /* Ignore dedicated windows and minibuffers. */
1184 if (MINI_WINDOW_P (XWINDOW (w
))
1185 || !NILP (XWINDOW (w
)->dedicated
))
1188 struct window
*best_window_ptr
= XWINDOW (best_window
);
1189 struct window
*w_ptr
= XWINDOW (w
);
1190 if (NILP (best_window
) ||
1191 (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
))
1192 > (XFASTINT (best_window_ptr
->height
)
1193 * XFASTINT (best_window_ptr
->width
)))
1199 if (EQ (XWINDOW (w
)->buffer
, obj
))
1201 /* Find another buffer to show in this window. */
1202 Lisp_Object another_buffer
= Fother_buffer (obj
, Qnil
);
1203 if (NILP (another_buffer
))
1205 = Fget_buffer_create (build_string ("*scratch*"));
1206 Fset_window_buffer (w
, another_buffer
);
1207 if (EQ (w
, selected_window
))
1208 Fset_buffer (XWINDOW (w
)->buffer
);
1213 if (EQ (w
, last_window
))
1222 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1223 "Return the window least recently selected or used for display.\n\
1224 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1225 frame, search only that frame.\n")
1229 register Lisp_Object w
;
1230 /* First try for a window that is full-width */
1231 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frames
);
1232 if (!NILP (w
) && !EQ (w
, selected_window
))
1234 /* If none of them, try the rest */
1235 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frames
);
1238 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1239 "Return the largest window in area.\n\
1240 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1241 frame, search only that frame.\n")
1245 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1249 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1250 "Return a window currently displaying BUFFER, or nil if none.\n\
1251 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1252 frame, search only that frame.\n")
1254 Lisp_Object buffer
, frame
;
1256 buffer
= Fget_buffer (buffer
);
1257 if (XTYPE (buffer
) == Lisp_Buffer
)
1258 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1263 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1265 "Make WINDOW (or the selected window) fill its frame.\n\
1266 Only the frame WINDOW is on is affected.")
1272 struct buffer
*obuf
= current_buffer
;
1276 window
= selected_window
;
1278 CHECK_LIVE_WINDOW (window
, 0);
1280 w
= XWINDOW (window
);
1281 top
= XFASTINT (w
->top
);
1283 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1285 Fset_buffer (w
->buffer
);
1286 SET_PT (marker_position (w
->start
));
1287 Frecenter (make_number (top
- FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)))));
1289 set_buffer_internal (obuf
);
1294 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1295 1, 1, "bDelete windows on (buffer): ",
1296 "Delete all windows showing BUFFER.")
1302 buffer
= Fget_buffer (buffer
);
1303 CHECK_BUFFER (buffer
, 0);
1304 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, Qt
);
1309 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1310 Sreplace_buffer_in_windows
,
1311 1, 1, "bReplace buffer in windows: ",
1312 "Replace BUFFER with some other buffer in all windows showing it.")
1318 buffer
= Fget_buffer (buffer
);
1319 CHECK_BUFFER (buffer
, 0);
1320 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1325 /* Set the height of WINDOW and all its inferiors. */
1327 /* The smallest acceptable dimensions for a window. Anything smaller
1328 might crash Emacs. */
1329 #define MIN_SAFE_WINDOW_WIDTH (2)
1330 #define MIN_SAFE_WINDOW_HEIGHT (2)
1332 /* Make sure that window_min_height and window_min_width are
1333 not too small; if they are, set them to safe minima. */
1336 check_min_window_sizes ()
1338 /* Smaller values might permit a crash. */
1339 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1340 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1341 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1342 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1345 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1346 minimum allowable size. */
1348 check_frame_size (frame
, rows
, cols
)
1352 /* For height, we have to see whether the frame has a minibuffer, and
1353 whether it wants a mode line. */
1355 ((FRAME_MINIBUF_ONLY_P (frame
)
1356 || ! FRAME_HAS_MINIBUF_P (frame
))
1357 ? MIN_SAFE_WINDOW_HEIGHT
1358 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1360 if (*rows
< min_height
)
1362 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1363 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1366 /* Normally the window is deleted if it gets too small.
1367 nodelete nonzero means do not do this.
1368 (The caller should check later and do so if appropriate) */
1370 set_window_height (window
, height
, nodelete
)
1375 register struct window
*w
= XWINDOW (window
);
1376 register struct window
*c
;
1377 int oheight
= XFASTINT (w
->height
);
1378 int top
, pos
, lastbot
, opos
, lastobot
;
1381 check_min_window_sizes ();
1384 && ! NILP (w
->parent
)
1385 && height
< window_min_height
)
1387 Fdelete_window (window
);
1391 XFASTINT (w
->last_modified
) = 0;
1392 windows_or_buffers_changed
++;
1393 XFASTINT (w
->height
) = height
;
1394 if (!NILP (w
->hchild
))
1396 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1398 XWINDOW (child
)->top
= w
->top
;
1399 set_window_height (child
, height
, nodelete
);
1402 else if (!NILP (w
->vchild
))
1404 lastbot
= top
= XFASTINT (w
->top
);
1406 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1408 c
= XWINDOW (child
);
1410 opos
= lastobot
+ XFASTINT (c
->height
);
1412 XFASTINT (c
->top
) = lastbot
;
1414 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1416 /* Avoid confusion: inhibit deletion of child if becomes too small */
1417 set_window_height (child
, pos
+ top
- lastbot
, 1);
1419 /* Now advance child to next window,
1420 and set lastbot if child was not just deleted. */
1421 lastbot
= pos
+ top
;
1424 /* Now delete any children that became too small. */
1426 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1428 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1433 /* Recursively set width of WINDOW and its inferiors. */
1435 set_window_width (window
, width
, nodelete
)
1440 register struct window
*w
= XWINDOW (window
);
1441 register struct window
*c
;
1442 int owidth
= XFASTINT (w
->width
);
1443 int left
, pos
, lastright
, opos
, lastoright
;
1446 if (!nodelete
&& width
< window_min_width
)
1448 Fdelete_window (window
);
1452 XFASTINT (w
->last_modified
) = 0;
1453 windows_or_buffers_changed
++;
1454 XFASTINT (w
->width
) = width
;
1455 if (!NILP (w
->vchild
))
1457 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1459 XWINDOW (child
)->left
= w
->left
;
1460 set_window_width (child
, width
, nodelete
);
1463 else if (!NILP (w
->hchild
))
1465 lastright
= left
= XFASTINT (w
->left
);
1467 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1469 c
= XWINDOW (child
);
1471 opos
= lastoright
+ XFASTINT (c
->width
);
1473 XFASTINT (c
->left
) = lastright
;
1475 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1477 /* Inhibit deletion for becoming too small */
1478 set_window_width (child
, pos
+ left
- lastright
, 1);
1480 /* Now advance child to next window,
1481 and set lastright if child was not just deleted. */
1482 lastright
= pos
+ left
, lastoright
= opos
;
1484 /* Delete children that became too small */
1486 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1488 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1493 int window_select_count
;
1495 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1496 "Make WINDOW display BUFFER as its contents.\n\
1497 BUFFER can be a buffer or buffer name.")
1499 register Lisp_Object window
, buffer
;
1501 register Lisp_Object tem
;
1502 register struct window
*w
= decode_window (window
);
1504 buffer
= Fget_buffer (buffer
);
1505 CHECK_BUFFER (buffer
, 1);
1507 if (NILP (XBUFFER (buffer
)->name
))
1508 error ("Attempt to display deleted buffer");
1512 error ("Window is deleted");
1513 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1514 is first being set up. */
1516 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1517 error ("Window is dedicated to %s\n", tem
);
1524 Fset_marker (w
->pointm
,
1525 make_number (BUF_PT (XBUFFER (buffer
))),
1527 set_marker_restricted (w
->start
,
1528 make_number (XBUFFER (buffer
)->last_window_start
),
1530 w
->start_at_line_beg
= Qnil
;
1531 w
->force_start
= Qnil
;
1532 XFASTINT (w
->last_modified
) = 0;
1533 windows_or_buffers_changed
++;
1534 if (EQ (window
, selected_window
))
1535 Fset_buffer (buffer
);
1540 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1541 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1542 The main editor command loop selects the buffer of the selected window\n\
1543 before each command.")
1545 register Lisp_Object window
;
1547 register struct window
*w
;
1548 register struct window
*ow
= XWINDOW (selected_window
);
1550 CHECK_LIVE_WINDOW (window
, 0);
1552 w
= XWINDOW (window
);
1554 if (NILP (w
->buffer
))
1555 error ("Trying to select deleted window or non-leaf window");
1557 XFASTINT (w
->use_time
) = ++window_select_count
;
1558 if (EQ (window
, selected_window
))
1561 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1564 selected_window
= window
;
1566 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1568 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1569 Fhandle_switch_frame (WINDOW_FRAME (w
), Qnil
);
1572 selected_frame
->selected_window
= window
;
1575 record_buffer (w
->buffer
);
1576 Fset_buffer (w
->buffer
);
1578 /* Go to the point recorded in the window.
1579 This is important when the buffer is in more
1580 than one window. It also matters when
1581 redisplay_window has altered point after scrolling,
1582 because it makes the change only in the window. */
1584 register int new_point
= marker_position (w
->pointm
);
1585 if (new_point
< BEGV
)
1593 windows_or_buffers_changed
++;
1597 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1598 "BDisplay buffer: \nP",
1599 "Make BUFFER appear in some window but don't select it.\n\
1600 BUFFER can be a buffer or a buffer name.\n\
1601 If BUFFER is shown already in some window, just use that one,\n\
1602 unless the window is the selected window and the optional second\n\
1603 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1604 Returns the window displaying BUFFER.")
1605 (buffer
, not_this_window
)
1606 register Lisp_Object buffer
, not_this_window
;
1608 register Lisp_Object window
;
1610 buffer
= Fget_buffer (buffer
);
1611 CHECK_BUFFER (buffer
, 0);
1613 if (!NILP (Vdisplay_buffer_function
))
1614 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1616 if (NILP (not_this_window
)
1617 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1618 return selected_window
;
1620 window
= Fget_buffer_window (buffer
, Qnil
);
1622 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1626 /* If there are no frames open that have more than a minibuffer,
1627 we need to create a new frame. */
1628 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1631 = Fframe_selected_window (call0 (Vpop_up_frame_function
));
1632 Fset_window_buffer (window
, buffer
);
1634 Fhandle_switch_frame (XWINDOW (window
)->frame
, Qnil
);
1638 #endif /* MULTI_FRAME */
1642 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1646 Lisp_Object frames
= Qnil
;
1649 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1650 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1652 /* Don't try to create a window if would get an error */
1653 if (split_height_threshold
< window_min_height
<< 1)
1654 split_height_threshold
= window_min_height
<< 1;
1656 window
= Fget_largest_window (frames
);
1659 && window_height (window
) >= split_height_threshold
1660 && (XFASTINT (XWINDOW (window
)->width
)
1661 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1662 window
= Fsplit_window (window
, Qnil
, Qnil
);
1665 window
= Fget_lru_window (frames
);
1666 if ((EQ (window
, selected_window
)
1667 || EQ (XWINDOW (window
)->parent
, Qnil
))
1668 && window_height (window
) >= window_min_height
<< 1)
1669 window
= Fsplit_window (window
, Qnil
, Qnil
);
1673 window
= Fget_lru_window (Qnil
);
1675 Fset_window_buffer (window
, buffer
);
1680 temp_output_buffer_show (buf
)
1681 register Lisp_Object buf
;
1683 register struct buffer
*old
= current_buffer
;
1684 register Lisp_Object window
;
1685 register struct window
*w
;
1688 XBUFFER (buf
)->save_modified
= MODIFF
;
1693 set_buffer_internal (old
);
1695 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1696 call1 (Vtemp_buffer_show_function
, buf
);
1699 window
= Fdisplay_buffer (buf
, Qnil
);
1702 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1703 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1704 #endif /* MULTI_FRAME */
1705 Vminibuf_scroll_window
= window
;
1706 w
= XWINDOW (window
);
1707 XFASTINT (w
->hscroll
) = 0;
1708 set_marker_restricted (w
->start
, make_number (1), buf
);
1709 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1714 make_dummy_parent (window
)
1717 register Lisp_Object old
, new;
1718 register struct window
*o
, *p
;
1721 XSETTYPE (old
, Lisp_Vector
);
1722 new = Fcopy_sequence (old
);
1723 XSETTYPE (new, Lisp_Window
);
1727 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1729 /* Put new into window structure in place of window */
1730 replace_window (window
, new);
1743 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1744 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1745 WINDOW defaults to selected one and SIZE to half its size.\n\
1746 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1747 and put SIZE columns in the first of the pair.")
1748 (window
, chsize
, horflag
)
1749 Lisp_Object window
, chsize
, horflag
;
1751 register Lisp_Object
new;
1752 register struct window
*o
, *p
;
1756 window
= selected_window
;
1758 CHECK_LIVE_WINDOW (window
, 0);
1760 o
= XWINDOW (window
);
1764 if (!NILP (horflag
))
1765 /* Round odd size up, since this is for the left-hand window,
1766 and it will lose a column for the separators. */
1767 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1769 size
= XFASTINT (o
->height
) >> 1;
1773 CHECK_NUMBER (chsize
, 1);
1774 size
= XINT (chsize
);
1777 if (MINI_WINDOW_P (o
))
1778 error ("Attempt to split minibuffer window");
1779 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1780 error ("Attempt to split unsplittable frame");
1782 check_min_window_sizes ();
1786 if (size
< window_min_height
1787 || size
+ window_min_height
> XFASTINT (o
->height
))
1788 args_out_of_range_3 (window
, chsize
, horflag
);
1789 if (NILP (o
->parent
)
1790 || NILP (XWINDOW (o
->parent
)->vchild
))
1792 make_dummy_parent (window
);
1794 XWINDOW (new)->vchild
= window
;
1799 if (size
< window_min_width
1800 || size
+ window_min_width
> XFASTINT (o
->width
))
1801 args_out_of_range_3 (window
, chsize
, horflag
);
1802 if (NILP (o
->parent
)
1803 || NILP (XWINDOW (o
->parent
)->hchild
))
1805 make_dummy_parent (window
);
1807 XWINDOW (new)->hchild
= window
;
1811 /* Now we know that window's parent is a vertical combination
1812 if we are dividing vertically, or a horizontal combination
1813 if we are making side-by-side windows */
1815 windows_or_buffers_changed
++;
1816 new = make_window ();
1819 p
->frame
= o
->frame
;
1821 if (!NILP (p
->next
))
1822 XWINDOW (p
->next
)->prev
= new;
1825 p
->parent
= o
->parent
;
1828 Fset_window_buffer (new, o
->buffer
);
1830 /* Apportion the available frame space among the two new windows */
1832 if (!NILP (horflag
))
1834 p
->height
= o
->height
;
1836 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1837 XFASTINT (o
->width
) = size
;
1838 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1843 p
->width
= o
->width
;
1844 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1845 XFASTINT (o
->height
) = size
;
1846 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
1852 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
1853 "Make current window ARG lines bigger.\n\
1854 From program, optional second arg non-nil means grow sideways ARG columns.")
1856 register Lisp_Object n
, side
;
1858 CHECK_NUMBER (n
, 0);
1859 change_window_height (XINT (n
), !NILP (side
));
1863 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
1864 "Make current window ARG lines smaller.\n\
1865 From program, optional second arg non-nil means shrink sideways ARG columns.")
1867 register Lisp_Object n
, side
;
1869 CHECK_NUMBER (n
, 0);
1870 change_window_height (-XINT (n
), !NILP (side
));
1875 window_height (window
)
1878 register struct window
*p
= XWINDOW (window
);
1879 return XFASTINT (p
->height
);
1883 window_width (window
)
1886 register struct window
*p
= XWINDOW (window
);
1887 return XFASTINT (p
->width
);
1890 #define MINSIZE(w) \
1892 ? window_min_width \
1893 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
1896 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
1898 #define CURSIZE(w) \
1899 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
1901 /* Unlike set_window_height, this function
1902 also changes the heights of the siblings so as to
1903 keep everything consistent. */
1905 change_window_height (delta
, widthflag
)
1909 register Lisp_Object parent
;
1911 register struct window
*p
;
1913 int (*sizefun
) () = widthflag
? window_width
: window_height
;
1914 register int (*setsizefun
) () = (widthflag
1916 : set_window_height
);
1918 check_min_window_sizes ();
1920 window
= selected_window
;
1923 p
= XWINDOW (window
);
1928 error ("No other window to side of this one");
1931 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
1932 : !NILP (XWINDOW (parent
)->vchild
))
1937 sizep
= &CURSIZE (window
);
1939 if (*sizep
+ delta
< MINSIZE (window
))
1941 Fdelete_window (window
);
1946 register int maxdelta
;
1948 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
1949 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
1950 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
1951 /* This is a frame with only one window, a minibuffer-only
1952 or a minibufferless frame. */
1955 if (delta
> maxdelta
)
1956 /* This case traps trying to make the minibuffer
1957 the full frame, or make the only window aside from the
1958 minibuffer the full frame. */
1965 if (!NILP (p
->next
) &&
1966 (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
1968 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
1969 (*setsizefun
) (window
, *sizep
+ delta
, 0);
1970 CURBEG (p
->next
) += delta
;
1971 /* This does not change size of p->next,
1972 but it propagates the new top edge to its children */
1973 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
1975 else if (!NILP (p
->prev
) &&
1976 (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
1978 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
1979 CURBEG (window
) -= delta
;
1980 (*setsizefun
) (window
, *sizep
+ delta
, 0);
1984 register int delta1
;
1985 register int opht
= (*sizefun
) (parent
);
1987 /* If trying to grow this window to or beyond size of the parent,
1988 make delta1 so big that, on shrinking back down,
1989 all the siblings end up with less than one line and are deleted. */
1990 if (opht
<= *sizep
+ delta
)
1991 delta1
= opht
* opht
* 2;
1992 /* Otherwise, make delta1 just right so that if we add delta1
1993 lines to this window and to the parent, and then shrink
1994 the parent back to its original size, the new proportional
1995 size of this window will increase by delta. */
1997 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
1999 /* Add delta1 lines or columns to this window, and to the parent,
2000 keeping things consistent while not affecting siblings. */
2001 CURSIZE (parent
) = opht
+ delta1
;
2002 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2004 /* Squeeze out delta1 lines or columns from our parent,
2005 shriking this window and siblings proportionately.
2006 This brings parent back to correct size.
2007 Delta1 was calculated so this makes this window the desired size,
2008 taking it all out of the siblings. */
2009 (*setsizefun
) (parent
, opht
, 0);
2012 XFASTINT (p
->last_modified
) = 0;
2019 /* Return number of lines of text (not counting mode line) in W. */
2022 window_internal_height (w
)
2025 int ht
= XFASTINT (w
->height
);
2027 if (MINI_WINDOW_P (w
))
2030 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2031 || !NILP (w
->next
) || !NILP (w
->prev
)
2032 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2039 /* Return the number of columns in W.
2040 Don't count columns occupied by scroll bars or the vertical bar
2041 separating W from the sibling to its right. */
2043 window_internal_width (w
)
2046 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2047 int left
= XINT (w
->left
);
2048 int width
= XINT (w
->width
);
2050 /* If this window is flush against the right edge of the frame, its
2051 internal width is its full width. */
2052 if (left
+ width
>= FRAME_WIDTH (f
))
2055 /* If we are not flush right, then our rightmost columns are
2056 occupied by some sort of separator. */
2058 /* Scroll bars occupy a few columns. */
2059 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2060 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2062 /* The column of `|' characters separating side-by-side windows
2063 occupies one column only. */
2068 /* Scroll contents of window WINDOW up N lines. */
2071 window_scroll (window
, n
, noerror
)
2076 register struct window
*w
= XWINDOW (window
);
2077 register int opoint
= point
;
2079 register int ht
= window_internal_height (w
);
2080 register Lisp_Object tem
;
2082 Lisp_Object bolp
, nmoved
;
2084 XFASTINT (tem
) = point
;
2085 tem
= Fpos_visible_in_window_p (tem
, window
);
2089 Fvertical_motion (make_number (- ht
/ 2));
2090 XFASTINT (tem
) = point
;
2091 Fset_marker (w
->start
, tem
, w
->buffer
);
2092 w
->force_start
= Qt
;
2095 SET_PT (marker_position (w
->start
));
2096 lose
= n
< 0 && point
== BEGV
;
2097 Fvertical_motion (make_number (n
));
2107 Fsignal (Qbeginning_of_buffer
, Qnil
);
2112 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2113 w
->start_at_line_beg
= bolp
;
2114 w
->update_mode_line
= Qt
;
2115 XFASTINT (w
->last_modified
) = 0;
2121 tem
= Fvertical_motion (make_number (ht
));
2122 if (point
> opoint
|| XFASTINT (tem
) < ht
)
2125 Fvertical_motion (make_number (-1));
2133 Fsignal (Qend_of_buffer
, Qnil
);
2137 /* This is the guts of Fscroll_up and Fscroll_down. */
2140 scroll_command (n
, direction
)
2141 register Lisp_Object n
;
2144 register int defalt
;
2145 int count
= specpdl_ptr
- specpdl
;
2147 /* If selected window's buffer isn't current, make it current for the moment.
2148 But don't screw up if window_scroll gets an error. */
2149 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2151 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2152 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2155 defalt
= (window_internal_height (XWINDOW (selected_window
))
2156 - next_screen_context_lines
);
2157 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2160 window_scroll (selected_window
, defalt
, 0);
2161 else if (EQ (n
, Qminus
))
2162 window_scroll (selected_window
, - defalt
, 0);
2165 n
= Fprefix_numeric_value (n
);
2166 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2169 unbind_to (count
, Qnil
);
2172 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2173 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2174 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2175 When calling from a program, supply a number as argument or nil.")
2179 scroll_command (n
, 1);
2183 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2184 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2185 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2186 When calling from a program, supply a number as argument or nil.")
2190 scroll_command (n
, -1);
2194 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2195 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2196 The next window is the one below the current one; or the one at the top\n\
2197 if the current one is at the bottom.\n\
2198 When calling from a program, supply a number as argument or nil.\n\
2200 If in the minibuffer, `minibuf-scroll-window' if non-nil\n\
2201 specifies the window to scroll.\n\
2202 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2203 showing that buffer, popping the buffer up if necessary.")
2205 register Lisp_Object n
;
2207 register Lisp_Object window
;
2209 register struct window
*w
;
2210 register int count
= specpdl_ptr
- specpdl
;
2212 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2213 && !NILP (Vminibuf_scroll_window
))
2214 window
= Vminibuf_scroll_window
;
2215 /* If buffer is specified, scroll that buffer. */
2216 else if (!NILP (Vother_window_scroll_buffer
))
2218 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2220 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2224 /* Nothing specified; look for a neighboring window on the same
2226 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2228 if (EQ (window
, selected_window
))
2229 /* That didn't get us anywhere; look for a window on another
2232 window
= Fnext_window (window
, Qnil
, Qt
);
2233 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2234 && ! EQ (window
, selected_window
));
2237 CHECK_LIVE_WINDOW (window
, 0);
2239 if (EQ (window
, selected_window
))
2240 error ("There is no other window");
2242 w
= XWINDOW (window
);
2243 ht
= window_internal_height (w
);
2245 /* Don't screw up if window_scroll gets an error. */
2246 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2248 Fset_buffer (w
->buffer
);
2249 SET_PT (marker_position (w
->pointm
));
2252 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2253 else if (EQ (n
, Qminus
))
2254 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2257 if (XTYPE (n
) == Lisp_Cons
)
2259 CHECK_NUMBER (n
, 0);
2260 window_scroll (window
, XINT (n
), 1);
2263 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
2264 unbind_to (count
, Qnil
);
2269 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 1, 1, "P",
2270 "Scroll selected window display ARG columns left.\n\
2271 Default for ARG is window width minus 2.")
2273 register Lisp_Object arg
;
2277 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2279 arg
= Fprefix_numeric_value (arg
);
2282 Fset_window_hscroll (selected_window
,
2283 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2287 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 1, 1, "P",
2288 "Scroll selected window display ARG columns right.\n\
2289 Default for ARG is window width minus 2.")
2291 register Lisp_Object arg
;
2294 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2296 arg
= Fprefix_numeric_value (arg
);
2299 Fset_window_hscroll (selected_window
,
2300 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2304 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2305 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2306 The desired position of point is always relative to the current window.\n\
2307 Just C-u as prefix means put point in the center of the window.\n\
2308 No arg (i.e., it is nil) erases the entire frame and then\n\
2309 redraws with point in the center of the current window.")
2311 register Lisp_Object n
;
2313 register struct window
*w
= XWINDOW (selected_window
);
2314 register int ht
= window_internal_height (w
);
2315 register int opoint
= point
;
2319 extern int frame_garbaged
;
2321 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2322 XFASTINT (n
) = ht
/ 2;
2324 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2326 XFASTINT (n
) = ht
/ 2;
2330 n
= Fprefix_numeric_value (n
);
2331 CHECK_NUMBER (n
, 0);
2335 XSETINT (n
, XINT (n
) + ht
);
2337 XSETINT (n
, - XINT (n
));
2339 Fvertical_motion (n
);
2340 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2341 w
->start_at_line_beg
= Fbolp ();
2344 w
->force_start
= Qt
;
2349 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2351 "Position point relative to window.\n\
2352 With no argument, position text at center of window.\n\
2353 An argument specifies frame line; zero means top of window,\n\
2354 negative means relative to bottom of window.")
2356 register Lisp_Object arg
;
2358 register struct window
*w
= XWINDOW (selected_window
);
2359 register int height
= window_internal_height (w
);
2363 XFASTINT (arg
) = height
/ 2;
2366 arg
= Fprefix_numeric_value (arg
);
2368 XSETINT (arg
, XINT (arg
) + height
);
2371 start
= marker_position (w
->start
);
2372 if (start
< BEGV
|| start
> ZV
)
2374 Fvertical_motion (make_number (- height
/ 2));
2375 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2376 w
->start_at_line_beg
= Fbolp ();
2377 w
->force_start
= Qt
;
2382 return Fvertical_motion (arg
);
2385 struct save_window_data
2387 int size_from_Lisp_Vector_struct
;
2388 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2389 Lisp_Object frame_width
, frame_height
;
2390 Lisp_Object selected_frame
;
2391 Lisp_Object current_window
;
2392 Lisp_Object current_buffer
;
2393 Lisp_Object minibuf_scroll_window
;
2394 Lisp_Object root_window
;
2395 Lisp_Object focus_frame
;
2396 /* A vector, interpreted as a struct saved_window */
2397 Lisp_Object saved_windows
;
2400 /* Arg to Fmake_vector */
2401 #define SAVE_WINDOW_DATA_SIZE \
2402 ((sizeof (struct save_window_data) \
2403 - (sizeof (struct Lisp_Vector) \
2404 /* Don't count the contents member of the struct Lisp_Vector */ \
2405 - sizeof (Lisp_Object))) \
2406 / sizeof (Lisp_Object))
2408 /* This is saved as a Lisp_Vector */
2411 /* these first two must agree with struct Lisp_Vector in lisp.h */
2412 int size_from_Lisp_Vector_struct
;
2413 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2416 Lisp_Object buffer
, start
, pointm
, mark
;
2417 Lisp_Object left
, top
, width
, height
, hscroll
;
2418 Lisp_Object parent
, prev
;
2419 Lisp_Object start_at_line_beg
;
2420 Lisp_Object display_table
;
2422 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2424 #define SAVED_WINDOW_N(swv,n) \
2425 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2427 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2428 "T if OBJECT is a window-configration object.")
2432 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2438 DEFUN ("set-window-configuration", Fset_window_configuration
,
2439 Sset_window_configuration
, 1, 1, 0,
2440 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2441 CONFIGURATION must be a value previously returned\n\
2442 by `current-window-configuration' (which see).")
2444 Lisp_Object configuration
;
2446 register struct save_window_data
*data
;
2447 struct Lisp_Vector
*saved_windows
;
2448 Lisp_Object new_current_buffer
;
2452 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2454 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2458 data
= (struct save_window_data
*) XVECTOR (configuration
);
2459 saved_windows
= XVECTOR (data
->saved_windows
);
2461 new_current_buffer
= data
->current_buffer
;
2462 if (NILP (XBUFFER (new_current_buffer
)->name
))
2463 new_current_buffer
= Qnil
;
2465 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2468 /* If f is a dead frame, don't bother rebuilding its window tree.
2469 However, there is other stuff we should still try to do below. */
2470 if (FRAME_LIVE_P (f
))
2472 register struct window
*w
;
2473 register struct saved_window
*p
;
2476 /* If the frame has been resized since this window configuration was
2477 made, we change the frame to the size specified in the
2478 configuration, restore the configuration, and then resize it
2479 back. We keep track of the prevailing height in these variables. */
2480 int previous_frame_height
= FRAME_HEIGHT (f
);
2481 int previous_frame_width
= FRAME_WIDTH (f
);
2483 if (XFASTINT (data
->frame_height
) != previous_frame_height
2484 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2485 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2487 windows_or_buffers_changed
++;
2490 Mark all windows now on frame as "deleted".
2491 Restoring the new configuration "undeletes" any that are in it.
2493 Save their current buffers in their height fields, since we may
2494 need it later, if a buffer saved in the configuration is now
2496 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2498 for (k
= 0; k
< saved_windows
->size
; k
++)
2500 p
= SAVED_WINDOW_N (saved_windows
, k
);
2501 w
= XWINDOW (p
->window
);
2504 if (!NILP (p
->parent
))
2505 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2506 XFASTINT (p
->parent
))->window
;
2510 if (!NILP (p
->prev
))
2512 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2513 XFASTINT (p
->prev
))->window
;
2514 XWINDOW (w
->prev
)->next
= p
->window
;
2519 if (!NILP (w
->parent
))
2521 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2523 XWINDOW (w
->parent
)->vchild
= p
->window
;
2524 XWINDOW (w
->parent
)->hchild
= Qnil
;
2528 XWINDOW (w
->parent
)->hchild
= p
->window
;
2529 XWINDOW (w
->parent
)->vchild
= Qnil
;
2534 /* If we squirreled away the buffer in the window's height,
2536 if (XTYPE (w
->height
) == Lisp_Buffer
)
2537 w
->buffer
= w
->height
;
2540 w
->width
= p
->width
;
2541 w
->height
= p
->height
;
2542 w
->hscroll
= p
->hscroll
;
2543 w
->display_table
= p
->display_table
;
2544 XFASTINT (w
->last_modified
) = 0;
2546 /* Reinstall the saved buffer and pointers into it. */
2547 if (NILP (p
->buffer
))
2548 w
->buffer
= p
->buffer
;
2551 if (!NILP (XBUFFER (p
->buffer
)->name
))
2552 /* If saved buffer is alive, install it. */
2554 w
->buffer
= p
->buffer
;
2555 w
->start_at_line_beg
= p
->start_at_line_beg
;
2556 set_marker_restricted (w
->start
,
2557 Fmarker_position (p
->start
),
2559 set_marker_restricted (w
->pointm
,
2560 Fmarker_position (p
->pointm
),
2562 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2563 Fmarker_position (p
->mark
), w
->buffer
);
2565 /* As documented in Fcurrent_window_configuration, don't
2566 save the location of point in the buffer which was current
2567 when the window configuration was recorded. */
2568 if (!EQ (p
->buffer
, new_current_buffer
) &&
2569 XBUFFER (p
->buffer
) == current_buffer
)
2570 Fgoto_char (w
->pointm
);
2572 else if (NILP (XBUFFER (w
->buffer
)->name
))
2573 /* Else if window's old buffer is dead too, get a live one. */
2575 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2576 /* This will set the markers to beginning of visible
2578 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2579 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2580 w
->start_at_line_beg
= Qt
;
2583 /* Keeping window's old buffer; make sure the markers
2584 are real. Else if window's old buffer is dead too,
2587 /* Set window markers at start of visible range. */
2588 if (XMARKER (w
->start
)->buffer
== 0)
2589 set_marker_restricted (w
->start
, make_number (0),
2591 if (XMARKER (w
->pointm
)->buffer
== 0)
2592 set_marker_restricted (w
->pointm
,
2594 (BUF_PT (XBUFFER (w
->buffer
)))),
2596 w
->start_at_line_beg
= Qt
;
2601 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2602 Fselect_window (data
->current_window
);
2605 if (NILP (data
->focus_frame
)
2606 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2607 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2608 Fredirect_frame_focus (frame
, data
->focus_frame
);
2611 #if 0 /* I don't understand why this is needed, and it causes problems
2612 when the frame's old selected window has been deleted. */
2614 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2615 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2619 /* Set the screen height to the value it had before this function. */
2620 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2621 || previous_frame_width
!= FRAME_WIDTH (f
))
2622 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2627 /* Fselect_window will have made f the selected frame, so we
2628 reselect the proper frame here. Fhandle_switch_frame will change the
2629 selected window too, but that doesn't make the call to
2630 Fselect_window above totally superfluous; it still sets f's
2632 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2633 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2636 if (!NILP (new_current_buffer
))
2637 Fset_buffer (new_current_buffer
);
2639 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2643 /* Mark all windows now on frame as deleted
2644 by setting their buffers to nil. */
2647 delete_all_subwindows (w
)
2648 register struct window
*w
;
2650 if (!NILP (w
->next
))
2651 delete_all_subwindows (XWINDOW (w
->next
));
2652 if (!NILP (w
->vchild
))
2653 delete_all_subwindows (XWINDOW (w
->vchild
));
2654 if (!NILP (w
->hchild
))
2655 delete_all_subwindows (XWINDOW (w
->hchild
));
2657 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2659 /* We set all three of these fields to nil, to make sure that we can
2660 distinguish this dead window from any live window. Live leaf
2661 windows will have buffer set, and combination windows will have
2662 vchild or hchild set. */
2669 count_windows (window
)
2670 register struct window
*window
;
2672 register int count
= 1;
2673 if (!NILP (window
->next
))
2674 count
+= count_windows (XWINDOW (window
->next
));
2675 if (!NILP (window
->vchild
))
2676 count
+= count_windows (XWINDOW (window
->vchild
));
2677 if (!NILP (window
->hchild
))
2678 count
+= count_windows (XWINDOW (window
->hchild
));
2683 save_window_save (window
, vector
, i
)
2685 struct Lisp_Vector
*vector
;
2688 register struct saved_window
*p
;
2689 register struct window
*w
;
2690 register Lisp_Object tem
;
2692 for (;!NILP (window
); window
= w
->next
)
2694 p
= SAVED_WINDOW_N (vector
, i
);
2695 w
= XWINDOW (window
);
2697 XFASTINT (w
->temslot
) = i
++;
2699 p
->buffer
= w
->buffer
;
2702 p
->width
= w
->width
;
2703 p
->height
= w
->height
;
2704 p
->hscroll
= w
->hscroll
;
2705 p
->display_table
= w
->display_table
;
2706 if (!NILP (w
->buffer
))
2708 /* Save w's value of point in the window configuration.
2709 If w is the selected window, then get the value of point
2710 from the buffer; pointm is garbage in the selected window. */
2711 if (EQ (window
, selected_window
))
2713 p
->pointm
= Fmake_marker ();
2714 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2718 p
->pointm
= Fcopy_marker (w
->pointm
);
2720 p
->start
= Fcopy_marker (w
->start
);
2721 p
->start_at_line_beg
= w
->start_at_line_beg
;
2723 tem
= XBUFFER (w
->buffer
)->mark
;
2724 p
->mark
= Fcopy_marker (tem
);
2731 p
->start_at_line_beg
= Qnil
;
2734 if (NILP (w
->parent
))
2737 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2742 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2744 if (!NILP (w
->vchild
))
2745 i
= save_window_save (w
->vchild
, vector
, i
);
2746 if (!NILP (w
->hchild
))
2747 i
= save_window_save (w
->hchild
, vector
, i
);
2753 DEFUN ("current-window-configuration",
2754 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2755 "Return an object representing the current window configuration of FRAME.\n\
2756 If FRAME is nil or omitted, use the selected frame.\n\
2757 This describes the number of windows, their sizes and current buffers,\n\
2758 and for each displayed buffer, where display starts, and the positions of\n\
2759 point and mark. An exception is made for point in the current buffer:\n\
2760 its value is -not- saved.\n\
2761 This also records the currently selected frame, and FRAME's focus\n\
2762 redirection (see `redirect-frame-focus').")
2766 register Lisp_Object tem
;
2767 register int n_windows
;
2768 register struct save_window_data
*data
;
2776 CHECK_LIVE_FRAME (frame
, 0);
2780 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2781 data
= (struct save_window_data
*)
2782 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2784 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2785 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2787 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2789 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2790 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2791 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2792 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2793 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2794 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2795 data
->saved_windows
= tem
;
2796 for (i
= 0; i
< n_windows
; i
++)
2797 XVECTOR (tem
)->contents
[i
]
2798 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2799 save_window_save (FRAME_ROOT_WINDOW (f
),
2801 XSET (tem
, Lisp_Window_Configuration
, data
);
2805 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2807 "Execute body, preserving window sizes and contents.\n\
2808 Restores which buffer appears in which window, where display starts,\n\
2809 as well as the current buffer.\n\
2810 Does not restore the value of point in current buffer.")
2814 register Lisp_Object val
;
2815 register int count
= specpdl_ptr
- specpdl
;
2817 record_unwind_protect (Fset_window_configuration
,
2818 Fcurrent_window_configuration (Qnil
));
2819 val
= Fprogn (args
);
2820 return unbind_to (count
, val
);
2826 selected_frame
= make_terminal_frame ();
2827 minibuf_window
= selected_frame
->minibuffer_window
;
2828 selected_window
= selected_frame
->selected_window
;
2829 last_nonminibuf_frame
= selected_frame
;
2830 #else /* not MULTI_FRAME */
2831 extern Lisp_Object
get_minibuffer ();
2833 minibuf_window
= make_window ();
2834 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
2836 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
2837 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
2838 XWINDOW (minibuf_window
)->mini_p
= Qt
;
2840 /* These values 9 and 10 are arbitrary,
2841 just so that there is "something there."
2842 Correct values are put in in init_xdisp */
2844 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
2845 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
2847 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
2848 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
2849 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
2851 /* Prevent error in Fset_window_buffer. */
2852 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
2853 XWINDOW (minibuf_window
)->buffer
= Qt
;
2855 /* Now set them up for real. */
2856 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
2857 Fcurrent_buffer ());
2858 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
2860 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
2861 /* Make sure this window seems more recently used than
2862 a newly-created, never-selected window. Increment
2863 window_select_count so the first selection ever will get
2864 something newer than this. */
2865 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
2866 #endif /* not MULTI_FRAME */
2871 Qwindowp
= intern ("windowp");
2872 staticpro (&Qwindowp
);
2874 Qwindow_live_p
= intern ("window-live-p");
2875 staticpro (&Qwindow_live_p
);
2878 /* Make sure all windows get marked */
2879 staticpro (&minibuf_window
);
2882 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
2883 "Non-nil means call as function to display a help buffer.\n\
2884 Used by `with-output-to-temp-buffer'.");
2885 Vtemp_buffer_show_function
= Qnil
;
2887 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
2888 "If non-nil, function to call to handle `display-buffer'.\n\
2889 It will receive two args, the buffer and a flag which if non-nil means\n\
2890 that the currently selected window is not acceptable.\n\
2891 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
2892 work using this function.");
2893 Vdisplay_buffer_function
= Qnil
;
2895 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
2896 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
2897 Vminibuf_scroll_window
= Qnil
;
2899 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
2900 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
2901 Vother_window_scroll_buffer
= Qnil
;
2904 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
2905 "*Non-nil means `display-buffer' should make a separate frame.");
2908 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
2909 "*If non-nil, function to call to handle automatic new frame creation.\n\
2910 It is called with no arguments and should return a newly created frame.\n\
2912 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
2913 where `pop-up-frame-alist' would hold the default frame parameters.");
2914 Vpop_up_frame_function
= Qnil
;
2917 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
2918 "*Non-nil means display-buffer should make new windows.");
2921 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
2922 "*Number of lines of continuity when scrolling by screenfuls.");
2923 next_screen_context_lines
= 2;
2925 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
2926 "*display-buffer would prefer to split the largest window if this large.\n\
2927 If there is only one window, it is split regardless of this value.");
2928 split_height_threshold
= 500;
2930 DEFVAR_INT ("window-min-height", &window_min_height
,
2931 "*Delete any window less than this tall (including its mode line).");
2932 window_min_height
= 4;
2934 DEFVAR_INT ("window-min-width", &window_min_width
,
2935 "*Delete any window less than this wide.");
2936 window_min_width
= 10;
2938 defsubr (&Sselected_window
);
2939 defsubr (&Sminibuffer_window
);
2940 defsubr (&Swindow_minibuffer_p
);
2941 defsubr (&Swindowp
);
2942 defsubr (&Swindow_live_p
);
2943 defsubr (&Spos_visible_in_window_p
);
2944 defsubr (&Swindow_buffer
);
2945 defsubr (&Swindow_height
);
2946 defsubr (&Swindow_width
);
2947 defsubr (&Swindow_hscroll
);
2948 defsubr (&Sset_window_hscroll
);
2949 defsubr (&Swindow_edges
);
2950 defsubr (&Scoordinates_in_window_p
);
2951 defsubr (&Swindow_at
);
2952 defsubr (&Swindow_point
);
2953 defsubr (&Swindow_start
);
2954 defsubr (&Swindow_end
);
2955 defsubr (&Sset_window_point
);
2956 defsubr (&Sset_window_start
);
2957 defsubr (&Swindow_dedicated_p
);
2958 defsubr (&Sset_window_dedicated_p
);
2959 defsubr (&Swindow_display_table
);
2960 defsubr (&Sset_window_display_table
);
2961 defsubr (&Snext_window
);
2962 defsubr (&Sprevious_window
);
2963 defsubr (&Sother_window
);
2964 defsubr (&Sget_lru_window
);
2965 defsubr (&Sget_largest_window
);
2966 defsubr (&Sget_buffer_window
);
2967 defsubr (&Sdelete_other_windows
);
2968 defsubr (&Sdelete_windows_on
);
2969 defsubr (&Sreplace_buffer_in_windows
);
2970 defsubr (&Sdelete_window
);
2971 defsubr (&Sset_window_buffer
);
2972 defsubr (&Sselect_window
);
2973 defsubr (&Sdisplay_buffer
);
2974 defsubr (&Ssplit_window
);
2975 defsubr (&Senlarge_window
);
2976 defsubr (&Sshrink_window
);
2977 defsubr (&Sscroll_up
);
2978 defsubr (&Sscroll_down
);
2979 defsubr (&Sscroll_left
);
2980 defsubr (&Sscroll_right
);
2981 defsubr (&Sscroll_other_window
);
2982 defsubr (&Srecenter
);
2983 defsubr (&Smove_to_window_line
);
2984 defsubr (&Swindow_configuration_p
);
2985 defsubr (&Sset_window_configuration
);
2986 defsubr (&Scurrent_window_configuration
);
2987 defsubr (&Ssave_window_excursion
);
2992 initial_define_key (control_x_map
, '1', "delete-other-windows");
2993 initial_define_key (control_x_map
, '2', "split-window");
2994 initial_define_key (control_x_map
, '0', "delete-window");
2995 initial_define_key (control_x_map
, 'o', "other-window");
2996 initial_define_key (control_x_map
, '^', "enlarge-window");
2997 initial_define_key (control_x_map
, '<', "scroll-left");
2998 initial_define_key (control_x_map
, '>', "scroll-right");
3000 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3001 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3002 initial_define_key (meta_map
, 'v', "scroll-down");
3004 initial_define_key (global_map
, Ctl('L'), "recenter");
3005 initial_define_key (meta_map
, 'r', "move-to-window-line");