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
, pwindow
;
705 /* See if the frame's selected window is either WINDOW
706 or any subwindow of it, by finding all that window's parents
707 and comparing each one with WINDOW. */
708 frame
= WINDOW_FRAME (XWINDOW (window
));
709 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
711 while (!NILP (pwindow
))
713 if (EQ (window
, pwindow
))
715 pwindow
= XWINDOW (pwindow
)->parent
;
718 if (EQ (window
, pwindow
))
720 Lisp_Object alternative
= Fnext_window (window
, Qlambda
, Qnil
);
722 /* If we're about to delete the selected window on the
723 selected frame, then we should use Fselect_window to select
724 the new window. On the other hand, if we're about to
725 delete the selected window on any other frame, we shouldn't do
726 anything but set the frame's selected_window slot. */
727 if (EQ (window
, selected_window
))
728 Fselect_window (alternative
);
730 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
735 /* tem is null for dummy parent windows
736 (which have inferiors but not any contents themselves) */
740 unchain_marker (p
->pointm
);
741 unchain_marker (p
->start
);
746 XWINDOW (tem
)->prev
= p
->prev
;
750 XWINDOW (tem
)->next
= p
->next
;
752 if (EQ (window
, par
->hchild
))
753 par
->hchild
= p
->next
;
754 if (EQ (window
, par
->vchild
))
755 par
->vchild
= p
->next
;
757 /* Find one of our siblings to give our space to. */
761 /* If p gives its space to its next sibling, that sibling needs
762 to have its top/left side pulled back to where p's is.
763 set_window_{height,width} will re-position the sibling's
766 XWINDOW (sib
)->top
= p
->top
;
767 XWINDOW (sib
)->left
= p
->left
;
770 /* Stretch that sibling. */
771 if (!NILP (par
->vchild
))
772 set_window_height (sib
,
773 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
775 if (!NILP (par
->hchild
))
776 set_window_width (sib
,
777 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
780 /* If parent now has only one child,
781 put the child into the parent's place. */
785 if (NILP (XWINDOW (tem
)->next
))
786 replace_window (parent
, tem
);
788 /* Since we may be deleting combination windows, we must make sure that
789 not only p but all its children have been marked as deleted. */
790 if (! NILP (p
->hchild
))
791 delete_all_subwindows (XWINDOW (p
->hchild
));
792 else if (! NILP (p
->vchild
))
793 delete_all_subwindows (XWINDOW (p
->vchild
));
795 /* Mark this window as deleted. */
796 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
802 extern Lisp_Object
next_frame (), prev_frame ();
804 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
805 "Return next window after WINDOW in canonical ordering of windows.\n\
806 If omitted, WINDOW defaults to the selected window.\n\
808 Optional second arg MINIBUF t means count the minibuffer window even\n\
809 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
810 it is active. MINIBUF neither t nor nil means not to count the\n\
811 minibuffer even if it is active.\n\
813 Several frames may share a single minibuffer; if the minibuffer\n\
814 counts, all windows on all frames that share that minibuffer count\n\
815 too. This means that next-window may be used to iterate through the\n\
816 set of windows even when the minibuffer is on another frame. If the\n\
817 minibuffer does not count, only windows from WINDOW's frame count.\n\
819 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
820 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
821 above. If neither nil nor t, restrict to WINDOW's frame.\n\
823 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
824 `next-window' to iterate through the entire cycle of acceptable\n\
825 windows, eventually ending up back at the window you started with.\n\
826 `previous-window' traverses the same cycle, in the reverse order.")
827 (window
, minibuf
, all_frames
)
828 register Lisp_Object window
, minibuf
, all_frames
;
830 register Lisp_Object tem
;
831 Lisp_Object start_window
;
834 window
= selected_window
;
836 CHECK_LIVE_WINDOW (window
, 0);
838 start_window
= window
;
840 /* minibuf == nil may or may not include minibuffers.
841 Decide if it does. */
843 minibuf
= (minibuf_level
? Qt
: Qlambda
);
845 /* all_frames == nil doesn't specify which frames to include.
846 Decide which frames it includes. */
847 if (NILP (all_frames
))
848 all_frames
= (EQ (minibuf
, Qt
)
849 ? (FRAME_MINIBUF_WINDOW
852 (XWINDOW (window
)))))
854 else if (! EQ (all_frames
, Qt
))
856 /* Now all_frames is t meaning search all frames,
857 nil meaning search just current frame,
858 or a window, meaning search the frame that window belongs to. */
860 /* Do this loop at least once, to get the next window, and perhaps
861 again, if we hit the minibuffer and that is not acceptable. */
864 /* Find a window that actually has a next one. This loop
865 climbs up the tree. */
866 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
867 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
871 /* We've reached the end of this frame.
872 Which other frames are acceptable? */
873 tem
= WINDOW_FRAME (XWINDOW (window
));
875 if (! NILP (all_frames
))
876 tem
= next_frame (tem
, all_frames
);
878 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
885 /* If we're in a combination window, find its first child and
886 recurse on that. Otherwise, we've found the window we want. */
889 if (!NILP (XWINDOW (window
)->hchild
))
890 window
= XWINDOW (window
)->hchild
;
891 else if (!NILP (XWINDOW (window
)->vchild
))
892 window
= XWINDOW (window
)->vchild
;
896 /* Which windows are acceptible?
897 Exit the loop and accept this window if
898 this isn't a minibuffer window, or
899 we're accepting minibuffer windows, or
900 we've come all the way around and we're back at the original window. */
901 while (MINI_WINDOW_P (XWINDOW (window
))
902 && ! EQ (minibuf
, Qt
)
903 && ! EQ (window
, start_window
));
908 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
909 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
910 If omitted, WINDOW defaults to the selected window.\n\
912 Optional second arg MINIBUF t means count the minibuffer window even\n\
913 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
914 it is active. MINIBUF neither t nor nil means not to count the\n\
915 minibuffer even if it is active.\n\
917 Several frames may share a single minibuffer; if the minibuffer\n\
918 counts, all windows on all frames that share that minibuffer count\n\
919 too. This means that previous-window may be used to iterate through\n\
920 the set of windows even when the minibuffer is on another frame. If\n\
921 the minibuffer does not count, only windows from WINDOW's frame\n\
924 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
925 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
926 above. If neither nil nor t, restrict to WINDOW's frame.\n\
928 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
929 `previous-window' to iterate through the entire cycle of acceptable\n\
930 windows, eventually ending up back at the window you started with.\n\
931 `next-window' traverses the same cycle, in the reverse order.")
932 (window
, minibuf
, all_frames
)
933 register Lisp_Object window
, minibuf
, all_frames
;
935 register Lisp_Object tem
;
936 Lisp_Object start_window
;
939 window
= selected_window
;
941 CHECK_LIVE_WINDOW (window
, 0);
943 start_window
= window
;
945 /* minibuf == nil may or may not include minibuffers.
946 Decide if it does. */
948 minibuf
= (minibuf_level
? Qt
: Qlambda
);
950 /* all_frames == nil doesn't specify which frames to include.
951 Decide which frames it includes. */
952 if (NILP (all_frames
))
953 all_frames
= (EQ (minibuf
, Qt
)
954 ? (FRAME_MINIBUF_WINDOW
957 (XWINDOW (window
)))))
959 else if (! EQ (all_frames
, Qt
))
961 /* Now all_frames is t meaning search all frames,
962 nil meaning search just current frame,
963 or a window, meaning search the frame that window belongs to. */
965 /* Do this loop at least once, to get the previous window, and perhaps
966 again, if we hit the minibuffer and that is not acceptable. */
969 /* Find a window that actually has a previous one. This loop
970 climbs up the tree. */
971 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
972 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
976 /* We have found the top window on the frame.
977 Which frames are acceptable? */
978 tem
= WINDOW_FRAME (XWINDOW (window
));
980 if (! NILP (all_frames
))
981 /* It's actually important that we use prev_frame here,
982 rather than next_frame. All the windows acceptable
983 according to the given parameters should form a ring;
984 Fnext_window and Fprevious_window should go back and
985 forth around the ring. If we use next_frame here,
986 then Fnext_window and Fprevious_window take different
987 paths through the set of acceptable windows.
988 window_loop assumes that these `ring' requirement are
990 tem
= prev_frame (tem
, all_frames
);
992 /* If this frame has a minibuffer, find that window first,
993 because it is conceptually the last window in that frame. */
994 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
995 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
997 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1003 /* If we're in a combination window, find its last child and
1004 recurse on that. Otherwise, we've found the window we want. */
1007 if (!NILP (XWINDOW (window
)->hchild
))
1008 window
= XWINDOW (window
)->hchild
;
1009 else if (!NILP (XWINDOW (window
)->vchild
))
1010 window
= XWINDOW (window
)->vchild
;
1012 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1016 /* Which windows are acceptable?
1017 Exit the loop and accept this window if
1018 this isn't a minibuffer window, or
1019 we're accepting minibuffer windows, or
1020 we've come all the way around and we're back at the original window. */
1021 while (MINI_WINDOW_P (XWINDOW (window
))
1022 && !EQ (minibuf
, Qt
)
1023 && !EQ (window
, start_window
));
1028 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1029 "Select the ARG'th different window on this frame.\n\
1030 All windows on current frame are arranged in a cyclic order.\n\
1031 This command selects the window ARG steps away in that order.\n\
1032 A negative ARG moves in the opposite order. If the optional second\n\
1033 argument ALL_FRAMES is non-nil, cycle through all frames.")
1035 register Lisp_Object n
, all_frames
;
1038 register Lisp_Object w
;
1040 CHECK_NUMBER (n
, 0);
1041 w
= selected_window
;
1046 w
= Fnext_window (w
, Qnil
, all_frames
);
1051 w
= Fprevious_window (w
, Qnil
, all_frames
);
1058 /* Look at all windows, performing an operation specified by TYPE
1060 If FRAMES is Qt, look at all frames;
1061 Qnil, look at just the selected frame;
1062 a frame, just look at windows on that frame.
1063 If MINI is non-zero, perform the operation on minibuffer windows too.
1069 GET_BUFFER_WINDOW
, /* Arg is buffer */
1070 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1071 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1072 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1074 UNSHOW_BUFFER
, /* Arg is buffer */
1078 window_loop (type
, obj
, mini
, frames
)
1079 enum window_loop type
;
1080 register Lisp_Object obj
, frames
;
1083 register Lisp_Object w
;
1084 register Lisp_Object best_window
;
1085 register Lisp_Object next_window
;
1086 register Lisp_Object last_window
;
1090 /* If we're only looping through windows on a particular frame,
1091 frame points to that frame. If we're looping through windows
1092 on all frames, frame is 0. */
1093 if (FRAMEP (frames
))
1094 frame
= XFRAME (frames
);
1095 else if (NILP (frames
))
1096 frame
= selected_frame
;
1103 /* Pick a window to start with. */
1104 if (XTYPE (obj
) == Lisp_Window
)
1107 w
= FRAME_SELECTED_WINDOW (frame
);
1109 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1111 /* Figure out the last window we're going to mess with. Since
1112 Fnext_window, given the same options, is guaranteed to go in a
1113 ring, we can just use Fprevious_window to find the last one.
1115 We can't just wait until we hit the first window again, because
1116 it might be deleted. */
1120 last_window
= Fprevious_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1122 #endif /* MULTI_FRAME */
1123 /* We know frame is 0, so we're looping through all frames.
1124 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1125 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, Qt
);
1130 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1132 /* Pick the next window now, since some operations will delete
1133 the current window. */
1136 next_window
= Fnext_window (w
, (mini
? Qt
: Qnil
), Qlambda
);
1138 #endif /* MULTI_FRAME */
1139 /* We know frame is 0, so we're looping through all frames.
1140 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */
1141 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, Qt
);
1143 if (! MINI_WINDOW_P (XWINDOW (w
))
1144 || (mini
&& minibuf_level
> 0))
1147 case GET_BUFFER_WINDOW
:
1148 /* Ignore invisible and iconified frames. */
1149 if (! FRAME_VISIBLE_P (w_frame
)
1150 || FRAME_ICONIFIED_P (w_frame
))
1152 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1156 case GET_LRU_WINDOW
:
1157 /* t as arg means consider only full-width windows */
1158 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1159 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1162 /* Ignore invisible and iconified frames. */
1163 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1164 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1167 /* Ignore dedicated windows and minibuffers. */
1168 if (MINI_WINDOW_P (XWINDOW (w
))
1169 || !NILP (XWINDOW (w
)->dedicated
))
1171 if (NILP (best_window
)
1172 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1173 > XFASTINT (XWINDOW (w
)->use_time
)))
1177 case DELETE_OTHER_WINDOWS
:
1178 if (XWINDOW (w
) != XWINDOW (obj
))
1182 case DELETE_BUFFER_WINDOWS
:
1183 if (EQ (XWINDOW (w
)->buffer
, obj
))
1185 /* If we're deleting the buffer displayed in the only window
1186 on the frame, find a new buffer to display there. */
1187 if (NILP (XWINDOW (w
)->parent
))
1189 Lisp_Object new_buffer
= Fother_buffer (obj
, Qnil
);
1190 if (NILP (new_buffer
))
1192 = Fget_buffer_create (build_string ("*scratch*"));
1193 Fset_window_buffer (w
, new_buffer
);
1194 Fset_buffer (XWINDOW (w
)->buffer
);
1201 case GET_LARGEST_WINDOW
:
1203 /* Ignore invisible and iconified frames. */
1204 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w
))))
1205 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1208 /* Ignore dedicated windows and minibuffers. */
1209 if (MINI_WINDOW_P (XWINDOW (w
))
1210 || !NILP (XWINDOW (w
)->dedicated
))
1213 struct window
*best_window_ptr
= XWINDOW (best_window
);
1214 struct window
*w_ptr
= XWINDOW (w
);
1215 if (NILP (best_window
) ||
1216 (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
))
1217 > (XFASTINT (best_window_ptr
->height
)
1218 * XFASTINT (best_window_ptr
->width
)))
1224 if (EQ (XWINDOW (w
)->buffer
, obj
))
1226 /* Find another buffer to show in this window. */
1227 Lisp_Object another_buffer
= Fother_buffer (obj
, Qnil
);
1228 if (NILP (another_buffer
))
1230 = Fget_buffer_create (build_string ("*scratch*"));
1231 Fset_window_buffer (w
, another_buffer
);
1232 if (EQ (w
, selected_window
))
1233 Fset_buffer (XWINDOW (w
)->buffer
);
1238 if (EQ (w
, last_window
))
1247 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1248 "Return the window least recently selected or used for display.\n\
1249 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1250 frame, search only that frame.\n")
1254 register Lisp_Object w
;
1255 /* First try for a window that is full-width */
1256 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frames
);
1257 if (!NILP (w
) && !EQ (w
, selected_window
))
1259 /* If none of them, try the rest */
1260 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frames
);
1263 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1264 "Return the largest window in area.\n\
1265 If optional argument FRAMES is t, search all frames. If FRAME is a\n\
1266 frame, search only that frame.\n")
1270 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1274 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1275 "Return a window currently displaying BUFFER, or nil if none.\n\
1276 If optional argument FRAME is t, search all visible frames.\n\
1277 If FRAME is nil, search only the selected frame.\n\
1278 If FRAME is a frame, search only that frame.\n")
1280 Lisp_Object buffer
, frame
;
1282 buffer
= Fget_buffer (buffer
);
1283 if (XTYPE (buffer
) == Lisp_Buffer
)
1284 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1289 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1291 "Make WINDOW (or the selected window) fill its frame.\n\
1292 Only the frame WINDOW is on is affected.")
1298 struct buffer
*obuf
= current_buffer
;
1302 window
= selected_window
;
1304 CHECK_LIVE_WINDOW (window
, 0);
1306 w
= XWINDOW (window
);
1307 top
= XFASTINT (w
->top
);
1309 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1311 Fset_buffer (w
->buffer
);
1312 SET_PT (marker_position (w
->start
));
1313 Frecenter (make_number (top
- FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)))));
1315 set_buffer_internal (obuf
);
1320 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1321 1, 1, "bDelete windows on (buffer): ",
1322 "Delete all windows showing BUFFER.")
1328 buffer
= Fget_buffer (buffer
);
1329 CHECK_BUFFER (buffer
, 0);
1330 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, Qt
);
1335 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1336 Sreplace_buffer_in_windows
,
1337 1, 1, "bReplace buffer in windows: ",
1338 "Replace BUFFER with some other buffer in all windows showing it.")
1344 buffer
= Fget_buffer (buffer
);
1345 CHECK_BUFFER (buffer
, 0);
1346 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1351 /* Set the height of WINDOW and all its inferiors. */
1353 /* The smallest acceptable dimensions for a window. Anything smaller
1354 might crash Emacs. */
1355 #define MIN_SAFE_WINDOW_WIDTH (2)
1356 #define MIN_SAFE_WINDOW_HEIGHT (2)
1358 /* Make sure that window_min_height and window_min_width are
1359 not too small; if they are, set them to safe minima. */
1362 check_min_window_sizes ()
1364 /* Smaller values might permit a crash. */
1365 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1366 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1367 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1368 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1371 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1372 minimum allowable size. */
1374 check_frame_size (frame
, rows
, cols
)
1378 /* For height, we have to see whether the frame has a minibuffer, and
1379 whether it wants a mode line. */
1381 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1382 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1383 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1385 if (*rows
< min_height
)
1387 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1388 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1391 /* Normally the window is deleted if it gets too small.
1392 nodelete nonzero means do not do this.
1393 (The caller should check later and do so if appropriate) */
1395 set_window_height (window
, height
, nodelete
)
1400 register struct window
*w
= XWINDOW (window
);
1401 register struct window
*c
;
1402 int oheight
= XFASTINT (w
->height
);
1403 int top
, pos
, lastbot
, opos
, lastobot
;
1406 check_min_window_sizes ();
1409 && ! NILP (w
->parent
)
1410 && height
< window_min_height
)
1412 Fdelete_window (window
);
1416 XFASTINT (w
->last_modified
) = 0;
1417 windows_or_buffers_changed
++;
1418 XFASTINT (w
->height
) = height
;
1419 if (!NILP (w
->hchild
))
1421 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1423 XWINDOW (child
)->top
= w
->top
;
1424 set_window_height (child
, height
, nodelete
);
1427 else if (!NILP (w
->vchild
))
1429 lastbot
= top
= XFASTINT (w
->top
);
1431 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1433 c
= XWINDOW (child
);
1435 opos
= lastobot
+ XFASTINT (c
->height
);
1437 XFASTINT (c
->top
) = lastbot
;
1439 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1441 /* Avoid confusion: inhibit deletion of child if becomes too small */
1442 set_window_height (child
, pos
+ top
- lastbot
, 1);
1444 /* Now advance child to next window,
1445 and set lastbot if child was not just deleted. */
1446 lastbot
= pos
+ top
;
1449 /* Now delete any children that became too small. */
1451 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1453 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1458 /* Recursively set width of WINDOW and its inferiors. */
1460 set_window_width (window
, width
, nodelete
)
1465 register struct window
*w
= XWINDOW (window
);
1466 register struct window
*c
;
1467 int owidth
= XFASTINT (w
->width
);
1468 int left
, pos
, lastright
, opos
, lastoright
;
1471 if (!nodelete
&& width
< window_min_width
)
1473 Fdelete_window (window
);
1477 XFASTINT (w
->last_modified
) = 0;
1478 windows_or_buffers_changed
++;
1479 XFASTINT (w
->width
) = width
;
1480 if (!NILP (w
->vchild
))
1482 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1484 XWINDOW (child
)->left
= w
->left
;
1485 set_window_width (child
, width
, nodelete
);
1488 else if (!NILP (w
->hchild
))
1490 lastright
= left
= XFASTINT (w
->left
);
1492 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1494 c
= XWINDOW (child
);
1496 opos
= lastoright
+ XFASTINT (c
->width
);
1498 XFASTINT (c
->left
) = lastright
;
1500 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1502 /* Inhibit deletion for becoming too small */
1503 set_window_width (child
, pos
+ left
- lastright
, 1);
1505 /* Now advance child to next window,
1506 and set lastright if child was not just deleted. */
1507 lastright
= pos
+ left
, lastoright
= opos
;
1509 /* Delete children that became too small */
1511 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1513 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1518 int window_select_count
;
1520 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1521 "Make WINDOW display BUFFER as its contents.\n\
1522 BUFFER can be a buffer or buffer name.")
1524 register Lisp_Object window
, buffer
;
1526 register Lisp_Object tem
;
1527 register struct window
*w
= decode_window (window
);
1529 buffer
= Fget_buffer (buffer
);
1530 CHECK_BUFFER (buffer
, 1);
1532 if (NILP (XBUFFER (buffer
)->name
))
1533 error ("Attempt to display deleted buffer");
1537 error ("Window is deleted");
1538 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1539 is first being set up. */
1541 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1542 error ("Window is dedicated to %s\n", tem
);
1549 Fset_marker (w
->pointm
,
1550 make_number (BUF_PT (XBUFFER (buffer
))),
1552 set_marker_restricted (w
->start
,
1553 make_number (XBUFFER (buffer
)->last_window_start
),
1555 w
->start_at_line_beg
= Qnil
;
1556 w
->force_start
= Qnil
;
1557 XFASTINT (w
->last_modified
) = 0;
1558 windows_or_buffers_changed
++;
1559 if (EQ (window
, selected_window
))
1560 Fset_buffer (buffer
);
1565 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1566 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1567 The main editor command loop selects the buffer of the selected window\n\
1568 before each command.")
1570 register Lisp_Object window
;
1572 register struct window
*w
;
1573 register struct window
*ow
= XWINDOW (selected_window
);
1575 CHECK_LIVE_WINDOW (window
, 0);
1577 w
= XWINDOW (window
);
1579 if (NILP (w
->buffer
))
1580 error ("Trying to select deleted window or non-leaf window");
1582 XFASTINT (w
->use_time
) = ++window_select_count
;
1583 if (EQ (window
, selected_window
))
1586 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1589 selected_window
= window
;
1591 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1593 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1594 Fhandle_switch_frame (WINDOW_FRAME (w
), Qnil
);
1597 selected_frame
->selected_window
= window
;
1600 record_buffer (w
->buffer
);
1601 Fset_buffer (w
->buffer
);
1603 /* Go to the point recorded in the window.
1604 This is important when the buffer is in more
1605 than one window. It also matters when
1606 redisplay_window has altered point after scrolling,
1607 because it makes the change only in the window. */
1609 register int new_point
= marker_position (w
->pointm
);
1610 if (new_point
< BEGV
)
1618 windows_or_buffers_changed
++;
1622 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1623 "BDisplay buffer: \nP",
1624 "Make BUFFER appear in some window but don't select it.\n\
1625 BUFFER can be a buffer or a buffer name.\n\
1626 If BUFFER is shown already in some window, just use that one,\n\
1627 unless the window is the selected window and the optional second\n\
1628 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1629 Returns the window displaying BUFFER.")
1630 (buffer
, not_this_window
)
1631 register Lisp_Object buffer
, not_this_window
;
1633 register Lisp_Object window
;
1635 buffer
= Fget_buffer (buffer
);
1636 CHECK_BUFFER (buffer
, 0);
1638 if (!NILP (Vdisplay_buffer_function
))
1639 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1641 if (NILP (not_this_window
)
1642 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1643 return selected_window
;
1645 window
= Fget_buffer_window (buffer
, Qnil
);
1647 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1651 /* If there are no frames open that have more than a minibuffer,
1652 we need to create a new frame. */
1653 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1656 = Fframe_selected_window (call0 (Vpop_up_frame_function
));
1657 Fset_window_buffer (window
, buffer
);
1659 Fhandle_switch_frame (XWINDOW (window
)->frame
, Qnil
);
1663 #endif /* MULTI_FRAME */
1667 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1671 Lisp_Object frames
= Qnil
;
1674 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1675 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1677 /* Don't try to create a window if would get an error */
1678 if (split_height_threshold
< window_min_height
<< 1)
1679 split_height_threshold
= window_min_height
<< 1;
1681 window
= Fget_largest_window (frames
);
1684 && window_height (window
) >= split_height_threshold
1685 && (XFASTINT (XWINDOW (window
)->width
)
1686 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1687 window
= Fsplit_window (window
, Qnil
, Qnil
);
1690 window
= Fget_lru_window (frames
);
1691 if ((EQ (window
, selected_window
)
1692 || EQ (XWINDOW (window
)->parent
, Qnil
))
1693 && window_height (window
) >= window_min_height
<< 1)
1694 window
= Fsplit_window (window
, Qnil
, Qnil
);
1698 window
= Fget_lru_window (Qnil
);
1700 Fset_window_buffer (window
, buffer
);
1705 temp_output_buffer_show (buf
)
1706 register Lisp_Object buf
;
1708 register struct buffer
*old
= current_buffer
;
1709 register Lisp_Object window
;
1710 register struct window
*w
;
1713 XBUFFER (buf
)->save_modified
= MODIFF
;
1718 set_buffer_internal (old
);
1720 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1721 call1 (Vtemp_buffer_show_function
, buf
);
1724 window
= Fdisplay_buffer (buf
, Qnil
);
1727 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
1728 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1729 #endif /* MULTI_FRAME */
1730 Vminibuf_scroll_window
= window
;
1731 w
= XWINDOW (window
);
1732 XFASTINT (w
->hscroll
) = 0;
1733 set_marker_restricted (w
->start
, make_number (1), buf
);
1734 set_marker_restricted (w
->pointm
, make_number (1), buf
);
1739 make_dummy_parent (window
)
1742 register Lisp_Object old
, new;
1743 register struct window
*o
, *p
;
1746 XSETTYPE (old
, Lisp_Vector
);
1747 new = Fcopy_sequence (old
);
1748 XSETTYPE (new, Lisp_Window
);
1752 XFASTINT (p
->sequence_number
) = ++sequence_number
;
1754 /* Put new into window structure in place of window */
1755 replace_window (window
, new);
1768 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
1769 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
1770 WINDOW defaults to selected one and SIZE to half its size.\n\
1771 If optional third arg HOR-FLAG is non-nil, split side by side\n\
1772 and put SIZE columns in the first of the pair.")
1773 (window
, chsize
, horflag
)
1774 Lisp_Object window
, chsize
, horflag
;
1776 register Lisp_Object
new;
1777 register struct window
*o
, *p
;
1781 window
= selected_window
;
1783 CHECK_LIVE_WINDOW (window
, 0);
1785 o
= XWINDOW (window
);
1789 if (!NILP (horflag
))
1790 /* Round odd size up, since this is for the left-hand window,
1791 and it will lose a column for the separators. */
1792 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
1794 size
= XFASTINT (o
->height
) >> 1;
1798 CHECK_NUMBER (chsize
, 1);
1799 size
= XINT (chsize
);
1802 if (MINI_WINDOW_P (o
))
1803 error ("Attempt to split minibuffer window");
1804 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
1805 error ("Attempt to split unsplittable frame");
1807 check_min_window_sizes ();
1811 if (size
< window_min_height
1812 || size
+ window_min_height
> XFASTINT (o
->height
))
1813 args_out_of_range_3 (window
, chsize
, horflag
);
1814 if (NILP (o
->parent
)
1815 || NILP (XWINDOW (o
->parent
)->vchild
))
1817 make_dummy_parent (window
);
1819 XWINDOW (new)->vchild
= window
;
1824 if (size
< window_min_width
1825 || size
+ window_min_width
> XFASTINT (o
->width
))
1826 args_out_of_range_3 (window
, chsize
, horflag
);
1827 if (NILP (o
->parent
)
1828 || NILP (XWINDOW (o
->parent
)->hchild
))
1830 make_dummy_parent (window
);
1832 XWINDOW (new)->hchild
= window
;
1836 /* Now we know that window's parent is a vertical combination
1837 if we are dividing vertically, or a horizontal combination
1838 if we are making side-by-side windows */
1840 windows_or_buffers_changed
++;
1841 new = make_window ();
1844 p
->frame
= o
->frame
;
1846 if (!NILP (p
->next
))
1847 XWINDOW (p
->next
)->prev
= new;
1850 p
->parent
= o
->parent
;
1853 Fset_window_buffer (new, o
->buffer
);
1855 /* Apportion the available frame space among the two new windows */
1857 if (!NILP (horflag
))
1859 p
->height
= o
->height
;
1861 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
1862 XFASTINT (o
->width
) = size
;
1863 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
1868 p
->width
= o
->width
;
1869 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
1870 XFASTINT (o
->height
) = size
;
1871 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
1877 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
1878 "Make current window ARG lines bigger.\n\
1879 From program, optional second arg non-nil means grow sideways ARG columns.")
1881 register Lisp_Object n
, side
;
1883 CHECK_NUMBER (n
, 0);
1884 change_window_height (XINT (n
), !NILP (side
));
1888 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
1889 "Make current window ARG lines smaller.\n\
1890 From program, optional second arg non-nil means shrink sideways ARG columns.")
1892 register Lisp_Object n
, side
;
1894 CHECK_NUMBER (n
, 0);
1895 change_window_height (-XINT (n
), !NILP (side
));
1900 window_height (window
)
1903 register struct window
*p
= XWINDOW (window
);
1904 return XFASTINT (p
->height
);
1908 window_width (window
)
1911 register struct window
*p
= XWINDOW (window
);
1912 return XFASTINT (p
->width
);
1915 #define MINSIZE(w) \
1917 ? window_min_width \
1918 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
1921 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
1923 #define CURSIZE(w) \
1924 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
1926 /* Unlike set_window_height, this function
1927 also changes the heights of the siblings so as to
1928 keep everything consistent. */
1930 change_window_height (delta
, widthflag
)
1934 register Lisp_Object parent
;
1936 register struct window
*p
;
1938 int (*sizefun
) () = widthflag
? window_width
: window_height
;
1939 register int (*setsizefun
) () = (widthflag
1941 : set_window_height
);
1943 check_min_window_sizes ();
1945 window
= selected_window
;
1948 p
= XWINDOW (window
);
1953 error ("No other window to side of this one");
1956 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
1957 : !NILP (XWINDOW (parent
)->vchild
))
1962 sizep
= &CURSIZE (window
);
1964 if (*sizep
+ delta
< MINSIZE (window
))
1966 Fdelete_window (window
);
1971 register int maxdelta
;
1973 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
1974 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
1975 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
1976 /* This is a frame with only one window, a minibuffer-only
1977 or a minibufferless frame. */
1980 if (delta
> maxdelta
)
1981 /* This case traps trying to make the minibuffer
1982 the full frame, or make the only window aside from the
1983 minibuffer the full frame. */
1990 if (!NILP (p
->next
) &&
1991 (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
1993 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
1994 (*setsizefun
) (window
, *sizep
+ delta
, 0);
1995 CURBEG (p
->next
) += delta
;
1996 /* This does not change size of p->next,
1997 but it propagates the new top edge to its children */
1998 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2000 else if (!NILP (p
->prev
) &&
2001 (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2003 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2004 CURBEG (window
) -= delta
;
2005 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2009 register int delta1
;
2010 register int opht
= (*sizefun
) (parent
);
2012 /* If trying to grow this window to or beyond size of the parent,
2013 make delta1 so big that, on shrinking back down,
2014 all the siblings end up with less than one line and are deleted. */
2015 if (opht
<= *sizep
+ delta
)
2016 delta1
= opht
* opht
* 2;
2017 /* Otherwise, make delta1 just right so that if we add delta1
2018 lines to this window and to the parent, and then shrink
2019 the parent back to its original size, the new proportional
2020 size of this window will increase by delta. */
2022 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2024 /* Add delta1 lines or columns to this window, and to the parent,
2025 keeping things consistent while not affecting siblings. */
2026 CURSIZE (parent
) = opht
+ delta1
;
2027 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2029 /* Squeeze out delta1 lines or columns from our parent,
2030 shriking this window and siblings proportionately.
2031 This brings parent back to correct size.
2032 Delta1 was calculated so this makes this window the desired size,
2033 taking it all out of the siblings. */
2034 (*setsizefun
) (parent
, opht
, 0);
2037 XFASTINT (p
->last_modified
) = 0;
2044 /* Return number of lines of text (not counting mode line) in W. */
2047 window_internal_height (w
)
2050 int ht
= XFASTINT (w
->height
);
2052 if (MINI_WINDOW_P (w
))
2055 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2056 || !NILP (w
->next
) || !NILP (w
->prev
)
2057 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2064 /* Return the number of columns in W.
2065 Don't count columns occupied by scroll bars or the vertical bar
2066 separating W from the sibling to its right. */
2068 window_internal_width (w
)
2071 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2072 int left
= XINT (w
->left
);
2073 int width
= XINT (w
->width
);
2075 /* If this window is flush against the right edge of the frame, its
2076 internal width is its full width. */
2077 if (left
+ width
>= FRAME_WIDTH (f
))
2080 /* If we are not flush right, then our rightmost columns are
2081 occupied by some sort of separator. */
2083 /* Scroll bars occupy a few columns. */
2084 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2085 return width
- VERTICAL_SCROLL_BAR_WIDTH
;
2087 /* The column of `|' characters separating side-by-side windows
2088 occupies one column only. */
2093 /* Scroll contents of window WINDOW up N lines. */
2096 window_scroll (window
, n
, noerror
)
2101 register struct window
*w
= XWINDOW (window
);
2102 register int opoint
= point
;
2104 register int ht
= window_internal_height (w
);
2105 register Lisp_Object tem
;
2107 Lisp_Object bolp
, nmoved
;
2109 XFASTINT (tem
) = point
;
2110 tem
= Fpos_visible_in_window_p (tem
, window
);
2114 Fvertical_motion (make_number (- ht
/ 2));
2115 XFASTINT (tem
) = point
;
2116 Fset_marker (w
->start
, tem
, w
->buffer
);
2117 w
->force_start
= Qt
;
2120 SET_PT (marker_position (w
->start
));
2121 lose
= n
< 0 && point
== BEGV
;
2122 Fvertical_motion (make_number (n
));
2132 Fsignal (Qbeginning_of_buffer
, Qnil
);
2137 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2138 w
->start_at_line_beg
= bolp
;
2139 w
->update_mode_line
= Qt
;
2140 XFASTINT (w
->last_modified
) = 0;
2146 tem
= Fvertical_motion (make_number (ht
));
2147 if (point
> opoint
|| XFASTINT (tem
) < ht
)
2150 Fvertical_motion (make_number (-1));
2158 Fsignal (Qend_of_buffer
, Qnil
);
2162 /* This is the guts of Fscroll_up and Fscroll_down. */
2165 scroll_command (n
, direction
)
2166 register Lisp_Object n
;
2169 register int defalt
;
2170 int count
= specpdl_ptr
- specpdl
;
2172 /* If selected window's buffer isn't current, make it current for the moment.
2173 But don't screw up if window_scroll gets an error. */
2174 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2176 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2177 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2180 defalt
= (window_internal_height (XWINDOW (selected_window
))
2181 - next_screen_context_lines
);
2182 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2185 window_scroll (selected_window
, defalt
, 0);
2186 else if (EQ (n
, Qminus
))
2187 window_scroll (selected_window
, - defalt
, 0);
2190 n
= Fprefix_numeric_value (n
);
2191 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2194 unbind_to (count
, Qnil
);
2197 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2198 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2199 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2200 When calling from a program, supply a number as argument or nil.")
2204 scroll_command (n
, 1);
2208 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2209 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2210 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2211 When calling from a program, supply a number as argument or nil.")
2215 scroll_command (n
, -1);
2219 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2220 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2221 The next window is the one below the current one; or the one at the top\n\
2222 if the current one is at the bottom.\n\
2223 When calling from a program, supply a number as argument or nil.\n\
2225 If in the minibuffer, `minibuf-scroll-window' if non-nil\n\
2226 specifies the window to scroll.\n\
2227 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2228 showing that buffer, popping the buffer up if necessary.")
2230 register Lisp_Object n
;
2232 register Lisp_Object window
;
2234 register struct window
*w
;
2235 register int count
= specpdl_ptr
- specpdl
;
2237 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2238 && !NILP (Vminibuf_scroll_window
))
2239 window
= Vminibuf_scroll_window
;
2240 /* If buffer is specified, scroll that buffer. */
2241 else if (!NILP (Vother_window_scroll_buffer
))
2243 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2245 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2249 /* Nothing specified; look for a neighboring window on the same
2251 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2253 if (EQ (window
, selected_window
))
2254 /* That didn't get us anywhere; look for a window on another
2257 window
= Fnext_window (window
, Qnil
, Qt
);
2258 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2259 && ! EQ (window
, selected_window
));
2262 CHECK_LIVE_WINDOW (window
, 0);
2264 if (EQ (window
, selected_window
))
2265 error ("There is no other window");
2267 w
= XWINDOW (window
);
2268 ht
= window_internal_height (w
);
2270 /* Don't screw up if window_scroll gets an error. */
2271 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2273 Fset_buffer (w
->buffer
);
2274 SET_PT (marker_position (w
->pointm
));
2277 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2278 else if (EQ (n
, Qminus
))
2279 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2282 if (XTYPE (n
) == Lisp_Cons
)
2284 CHECK_NUMBER (n
, 0);
2285 window_scroll (window
, XINT (n
), 1);
2288 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
2289 unbind_to (count
, Qnil
);
2294 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2295 "Scroll selected window display ARG columns left.\n\
2296 Default for ARG is window width minus 2.")
2298 register Lisp_Object arg
;
2302 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2304 arg
= Fprefix_numeric_value (arg
);
2307 Fset_window_hscroll (selected_window
,
2308 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2312 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2313 "Scroll selected window display ARG columns right.\n\
2314 Default for ARG is window width minus 2.")
2316 register Lisp_Object arg
;
2319 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2321 arg
= Fprefix_numeric_value (arg
);
2324 Fset_window_hscroll (selected_window
,
2325 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2329 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2330 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2331 The desired position of point is always relative to the current window.\n\
2332 Just C-u as prefix means put point in the center of the window.\n\
2333 No arg (i.e., it is nil) erases the entire frame and then\n\
2334 redraws with point in the center of the current window.")
2336 register Lisp_Object n
;
2338 register struct window
*w
= XWINDOW (selected_window
);
2339 register int ht
= window_internal_height (w
);
2340 register int opoint
= point
;
2344 extern int frame_garbaged
;
2346 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2347 XFASTINT (n
) = ht
/ 2;
2349 else if (XTYPE (n
) == Lisp_Cons
) /* Just C-u. */
2351 XFASTINT (n
) = ht
/ 2;
2355 n
= Fprefix_numeric_value (n
);
2356 CHECK_NUMBER (n
, 0);
2360 XSETINT (n
, XINT (n
) + ht
);
2362 XSETINT (n
, - XINT (n
));
2364 Fvertical_motion (n
);
2365 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2366 w
->start_at_line_beg
= Fbolp ();
2369 w
->force_start
= Qt
;
2374 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2376 "Position point relative to window.\n\
2377 With no argument, position text at center of window.\n\
2378 An argument specifies frame line; zero means top of window,\n\
2379 negative means relative to bottom of window.")
2381 register Lisp_Object arg
;
2383 register struct window
*w
= XWINDOW (selected_window
);
2384 register int height
= window_internal_height (w
);
2388 XFASTINT (arg
) = height
/ 2;
2391 arg
= Fprefix_numeric_value (arg
);
2393 XSETINT (arg
, XINT (arg
) + height
);
2396 start
= marker_position (w
->start
);
2397 if (start
< BEGV
|| start
> ZV
)
2399 Fvertical_motion (make_number (- height
/ 2));
2400 Fset_marker (w
->start
, make_number (point
), w
->buffer
);
2401 w
->start_at_line_beg
= Fbolp ();
2402 w
->force_start
= Qt
;
2407 return Fvertical_motion (arg
);
2410 struct save_window_data
2412 int size_from_Lisp_Vector_struct
;
2413 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2414 Lisp_Object frame_width
, frame_height
;
2415 Lisp_Object selected_frame
;
2416 Lisp_Object current_window
;
2417 Lisp_Object current_buffer
;
2418 Lisp_Object minibuf_scroll_window
;
2419 Lisp_Object root_window
;
2420 Lisp_Object focus_frame
;
2421 /* A vector, interpreted as a struct saved_window */
2422 Lisp_Object saved_windows
;
2425 /* Arg to Fmake_vector */
2426 #define SAVE_WINDOW_DATA_SIZE \
2427 ((sizeof (struct save_window_data) \
2428 - (sizeof (struct Lisp_Vector) \
2429 /* Don't count the contents member of the struct Lisp_Vector */ \
2430 - sizeof (Lisp_Object))) \
2431 / sizeof (Lisp_Object))
2433 /* This is saved as a Lisp_Vector */
2436 /* these first two must agree with struct Lisp_Vector in lisp.h */
2437 int size_from_Lisp_Vector_struct
;
2438 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2441 Lisp_Object buffer
, start
, pointm
, mark
;
2442 Lisp_Object left
, top
, width
, height
, hscroll
;
2443 Lisp_Object parent
, prev
;
2444 Lisp_Object start_at_line_beg
;
2445 Lisp_Object display_table
;
2447 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2449 #define SAVED_WINDOW_N(swv,n) \
2450 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2452 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2453 "T if OBJECT is a window-configration object.")
2457 if (XTYPE (obj
) == Lisp_Window_Configuration
)
2463 DEFUN ("set-window-configuration", Fset_window_configuration
,
2464 Sset_window_configuration
, 1, 1, 0,
2465 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2466 CONFIGURATION must be a value previously returned\n\
2467 by `current-window-configuration' (which see).")
2469 Lisp_Object configuration
;
2471 register struct save_window_data
*data
;
2472 struct Lisp_Vector
*saved_windows
;
2473 Lisp_Object new_current_buffer
;
2477 while (XTYPE (configuration
) != Lisp_Window_Configuration
)
2479 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2483 data
= (struct save_window_data
*) XVECTOR (configuration
);
2484 saved_windows
= XVECTOR (data
->saved_windows
);
2486 new_current_buffer
= data
->current_buffer
;
2487 if (NILP (XBUFFER (new_current_buffer
)->name
))
2488 new_current_buffer
= Qnil
;
2490 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2493 /* If f is a dead frame, don't bother rebuilding its window tree.
2494 However, there is other stuff we should still try to do below. */
2495 if (FRAME_LIVE_P (f
))
2497 register struct window
*w
;
2498 register struct saved_window
*p
;
2501 /* If the frame has been resized since this window configuration was
2502 made, we change the frame to the size specified in the
2503 configuration, restore the configuration, and then resize it
2504 back. We keep track of the prevailing height in these variables. */
2505 int previous_frame_height
= FRAME_HEIGHT (f
);
2506 int previous_frame_width
= FRAME_WIDTH (f
);
2508 if (XFASTINT (data
->frame_height
) != previous_frame_height
2509 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2510 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2512 windows_or_buffers_changed
++;
2515 Mark all windows now on frame as "deleted".
2516 Restoring the new configuration "undeletes" any that are in it.
2518 Save their current buffers in their height fields, since we may
2519 need it later, if a buffer saved in the configuration is now
2521 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2523 for (k
= 0; k
< saved_windows
->size
; k
++)
2525 p
= SAVED_WINDOW_N (saved_windows
, k
);
2526 w
= XWINDOW (p
->window
);
2529 if (!NILP (p
->parent
))
2530 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2531 XFASTINT (p
->parent
))->window
;
2535 if (!NILP (p
->prev
))
2537 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2538 XFASTINT (p
->prev
))->window
;
2539 XWINDOW (w
->prev
)->next
= p
->window
;
2544 if (!NILP (w
->parent
))
2546 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2548 XWINDOW (w
->parent
)->vchild
= p
->window
;
2549 XWINDOW (w
->parent
)->hchild
= Qnil
;
2553 XWINDOW (w
->parent
)->hchild
= p
->window
;
2554 XWINDOW (w
->parent
)->vchild
= Qnil
;
2559 /* If we squirreled away the buffer in the window's height,
2561 if (XTYPE (w
->height
) == Lisp_Buffer
)
2562 w
->buffer
= w
->height
;
2565 w
->width
= p
->width
;
2566 w
->height
= p
->height
;
2567 w
->hscroll
= p
->hscroll
;
2568 w
->display_table
= p
->display_table
;
2569 XFASTINT (w
->last_modified
) = 0;
2571 /* Reinstall the saved buffer and pointers into it. */
2572 if (NILP (p
->buffer
))
2573 w
->buffer
= p
->buffer
;
2576 if (!NILP (XBUFFER (p
->buffer
)->name
))
2577 /* If saved buffer is alive, install it. */
2579 w
->buffer
= p
->buffer
;
2580 w
->start_at_line_beg
= p
->start_at_line_beg
;
2581 set_marker_restricted (w
->start
,
2582 Fmarker_position (p
->start
),
2584 set_marker_restricted (w
->pointm
,
2585 Fmarker_position (p
->pointm
),
2587 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2588 Fmarker_position (p
->mark
), w
->buffer
);
2590 /* As documented in Fcurrent_window_configuration, don't
2591 save the location of point in the buffer which was current
2592 when the window configuration was recorded. */
2593 if (!EQ (p
->buffer
, new_current_buffer
) &&
2594 XBUFFER (p
->buffer
) == current_buffer
)
2595 Fgoto_char (w
->pointm
);
2597 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2598 /* Else unless window has a live buffer, get one. */
2600 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2601 /* This will set the markers to beginning of visible
2603 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2604 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2605 w
->start_at_line_beg
= Qt
;
2608 /* Keeping window's old buffer; make sure the markers
2611 /* Set window markers at start of visible range. */
2612 if (XMARKER (w
->start
)->buffer
== 0)
2613 set_marker_restricted (w
->start
, make_number (0),
2615 if (XMARKER (w
->pointm
)->buffer
== 0)
2616 set_marker_restricted (w
->pointm
,
2618 (BUF_PT (XBUFFER (w
->buffer
)))),
2620 w
->start_at_line_beg
= Qt
;
2625 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2626 Fselect_window (data
->current_window
);
2629 if (NILP (data
->focus_frame
)
2630 || (XTYPE (data
->focus_frame
) == Lisp_Frame
2631 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2632 Fredirect_frame_focus (frame
, data
->focus_frame
);
2635 #if 0 /* I don't understand why this is needed, and it causes problems
2636 when the frame's old selected window has been deleted. */
2638 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2639 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2643 /* Set the screen height to the value it had before this function. */
2644 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2645 || previous_frame_width
!= FRAME_WIDTH (f
))
2646 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2651 /* Fselect_window will have made f the selected frame, so we
2652 reselect the proper frame here. Fhandle_switch_frame will change the
2653 selected window too, but that doesn't make the call to
2654 Fselect_window above totally superfluous; it still sets f's
2656 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2657 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2660 if (!NILP (new_current_buffer
))
2661 Fset_buffer (new_current_buffer
);
2663 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2667 /* Mark all windows now on frame as deleted
2668 by setting their buffers to nil. */
2671 delete_all_subwindows (w
)
2672 register struct window
*w
;
2674 if (!NILP (w
->next
))
2675 delete_all_subwindows (XWINDOW (w
->next
));
2676 if (!NILP (w
->vchild
))
2677 delete_all_subwindows (XWINDOW (w
->vchild
));
2678 if (!NILP (w
->hchild
))
2679 delete_all_subwindows (XWINDOW (w
->hchild
));
2681 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
2683 /* We set all three of these fields to nil, to make sure that we can
2684 distinguish this dead window from any live window. Live leaf
2685 windows will have buffer set, and combination windows will have
2686 vchild or hchild set. */
2693 count_windows (window
)
2694 register struct window
*window
;
2696 register int count
= 1;
2697 if (!NILP (window
->next
))
2698 count
+= count_windows (XWINDOW (window
->next
));
2699 if (!NILP (window
->vchild
))
2700 count
+= count_windows (XWINDOW (window
->vchild
));
2701 if (!NILP (window
->hchild
))
2702 count
+= count_windows (XWINDOW (window
->hchild
));
2707 save_window_save (window
, vector
, i
)
2709 struct Lisp_Vector
*vector
;
2712 register struct saved_window
*p
;
2713 register struct window
*w
;
2714 register Lisp_Object tem
;
2716 for (;!NILP (window
); window
= w
->next
)
2718 p
= SAVED_WINDOW_N (vector
, i
);
2719 w
= XWINDOW (window
);
2721 XFASTINT (w
->temslot
) = i
++;
2723 p
->buffer
= w
->buffer
;
2726 p
->width
= w
->width
;
2727 p
->height
= w
->height
;
2728 p
->hscroll
= w
->hscroll
;
2729 p
->display_table
= w
->display_table
;
2730 if (!NILP (w
->buffer
))
2732 /* Save w's value of point in the window configuration.
2733 If w is the selected window, then get the value of point
2734 from the buffer; pointm is garbage in the selected window. */
2735 if (EQ (window
, selected_window
))
2737 p
->pointm
= Fmake_marker ();
2738 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
2742 p
->pointm
= Fcopy_marker (w
->pointm
);
2744 p
->start
= Fcopy_marker (w
->start
);
2745 p
->start_at_line_beg
= w
->start_at_line_beg
;
2747 tem
= XBUFFER (w
->buffer
)->mark
;
2748 p
->mark
= Fcopy_marker (tem
);
2755 p
->start_at_line_beg
= Qnil
;
2758 if (NILP (w
->parent
))
2761 p
->parent
= XWINDOW (w
->parent
)->temslot
;
2766 p
->prev
= XWINDOW (w
->prev
)->temslot
;
2768 if (!NILP (w
->vchild
))
2769 i
= save_window_save (w
->vchild
, vector
, i
);
2770 if (!NILP (w
->hchild
))
2771 i
= save_window_save (w
->hchild
, vector
, i
);
2777 DEFUN ("current-window-configuration",
2778 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
2779 "Return an object representing the current window configuration of FRAME.\n\
2780 If FRAME is nil or omitted, use the selected frame.\n\
2781 This describes the number of windows, their sizes and current buffers,\n\
2782 and for each displayed buffer, where display starts, and the positions of\n\
2783 point and mark. An exception is made for point in the current buffer:\n\
2784 its value is -not- saved.\n\
2785 This also records the currently selected frame, and FRAME's focus\n\
2786 redirection (see `redirect-frame-focus').")
2790 register Lisp_Object tem
;
2791 register int n_windows
;
2792 register struct save_window_data
*data
;
2800 CHECK_LIVE_FRAME (frame
, 0);
2804 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2805 data
= (struct save_window_data
*)
2806 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
2808 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
2809 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
2811 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
2813 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
2814 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
2815 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
2816 data
->root_window
= FRAME_ROOT_WINDOW (f
);
2817 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
2818 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
2819 data
->saved_windows
= tem
;
2820 for (i
= 0; i
< n_windows
; i
++)
2821 XVECTOR (tem
)->contents
[i
]
2822 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
2823 save_window_save (FRAME_ROOT_WINDOW (f
),
2825 XSET (tem
, Lisp_Window_Configuration
, data
);
2829 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
2831 "Execute body, preserving window sizes and contents.\n\
2832 Restores which buffer appears in which window, where display starts,\n\
2833 as well as the current buffer.\n\
2834 Does not restore the value of point in current buffer.")
2838 register Lisp_Object val
;
2839 register int count
= specpdl_ptr
- specpdl
;
2841 record_unwind_protect (Fset_window_configuration
,
2842 Fcurrent_window_configuration (Qnil
));
2843 val
= Fprogn (args
);
2844 return unbind_to (count
, val
);
2850 selected_frame
= make_terminal_frame ();
2851 minibuf_window
= selected_frame
->minibuffer_window
;
2852 selected_window
= selected_frame
->selected_window
;
2853 last_nonminibuf_frame
= selected_frame
;
2854 #else /* not MULTI_FRAME */
2855 extern Lisp_Object
get_minibuffer ();
2857 minibuf_window
= make_window ();
2858 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
2860 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
2861 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
2862 XWINDOW (minibuf_window
)->mini_p
= Qt
;
2864 /* These values 9 and 10 are arbitrary,
2865 just so that there is "something there."
2866 Correct values are put in in init_xdisp */
2868 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
2869 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
2871 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
2872 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
2873 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
2875 /* Prevent error in Fset_window_buffer. */
2876 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
2877 XWINDOW (minibuf_window
)->buffer
= Qt
;
2879 /* Now set them up for real. */
2880 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
2881 Fcurrent_buffer ());
2882 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
2884 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
2885 /* Make sure this window seems more recently used than
2886 a newly-created, never-selected window. Increment
2887 window_select_count so the first selection ever will get
2888 something newer than this. */
2889 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
2890 #endif /* not MULTI_FRAME */
2895 Qwindowp
= intern ("windowp");
2896 staticpro (&Qwindowp
);
2898 Qwindow_live_p
= intern ("window-live-p");
2899 staticpro (&Qwindow_live_p
);
2902 /* Make sure all windows get marked */
2903 staticpro (&minibuf_window
);
2906 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
2907 "Non-nil means call as function to display a help buffer.\n\
2908 Used by `with-output-to-temp-buffer'.");
2909 Vtemp_buffer_show_function
= Qnil
;
2911 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
2912 "If non-nil, function to call to handle `display-buffer'.\n\
2913 It will receive two args, the buffer and a flag which if non-nil means\n\
2914 that the currently selected window is not acceptable.\n\
2915 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
2916 work using this function.");
2917 Vdisplay_buffer_function
= Qnil
;
2919 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
2920 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
2921 Vminibuf_scroll_window
= Qnil
;
2923 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
2924 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
2925 Vother_window_scroll_buffer
= Qnil
;
2927 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
2928 "*Non-nil means `display-buffer' should make a separate frame.");
2931 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
2932 "*If non-nil, function to call to handle automatic new frame creation.\n\
2933 It is called with no arguments and should return a newly created frame.\n\
2935 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
2936 where `pop-up-frame-alist' would hold the default frame parameters.");
2937 Vpop_up_frame_function
= Qnil
;
2939 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
2940 "*Non-nil means display-buffer should make new windows.");
2943 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
2944 "*Number of lines of continuity when scrolling by screenfuls.");
2945 next_screen_context_lines
= 2;
2947 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
2948 "*display-buffer would prefer to split the largest window if this large.\n\
2949 If there is only one window, it is split regardless of this value.");
2950 split_height_threshold
= 500;
2952 DEFVAR_INT ("window-min-height", &window_min_height
,
2953 "*Delete any window less than this tall (including its mode line).");
2954 window_min_height
= 4;
2956 DEFVAR_INT ("window-min-width", &window_min_width
,
2957 "*Delete any window less than this wide.");
2958 window_min_width
= 10;
2960 defsubr (&Sselected_window
);
2961 defsubr (&Sminibuffer_window
);
2962 defsubr (&Swindow_minibuffer_p
);
2963 defsubr (&Swindowp
);
2964 defsubr (&Swindow_live_p
);
2965 defsubr (&Spos_visible_in_window_p
);
2966 defsubr (&Swindow_buffer
);
2967 defsubr (&Swindow_height
);
2968 defsubr (&Swindow_width
);
2969 defsubr (&Swindow_hscroll
);
2970 defsubr (&Sset_window_hscroll
);
2971 defsubr (&Swindow_edges
);
2972 defsubr (&Scoordinates_in_window_p
);
2973 defsubr (&Swindow_at
);
2974 defsubr (&Swindow_point
);
2975 defsubr (&Swindow_start
);
2976 defsubr (&Swindow_end
);
2977 defsubr (&Sset_window_point
);
2978 defsubr (&Sset_window_start
);
2979 defsubr (&Swindow_dedicated_p
);
2980 defsubr (&Sset_window_dedicated_p
);
2981 defsubr (&Swindow_display_table
);
2982 defsubr (&Sset_window_display_table
);
2983 defsubr (&Snext_window
);
2984 defsubr (&Sprevious_window
);
2985 defsubr (&Sother_window
);
2986 defsubr (&Sget_lru_window
);
2987 defsubr (&Sget_largest_window
);
2988 defsubr (&Sget_buffer_window
);
2989 defsubr (&Sdelete_other_windows
);
2990 defsubr (&Sdelete_windows_on
);
2991 defsubr (&Sreplace_buffer_in_windows
);
2992 defsubr (&Sdelete_window
);
2993 defsubr (&Sset_window_buffer
);
2994 defsubr (&Sselect_window
);
2995 defsubr (&Sdisplay_buffer
);
2996 defsubr (&Ssplit_window
);
2997 defsubr (&Senlarge_window
);
2998 defsubr (&Sshrink_window
);
2999 defsubr (&Sscroll_up
);
3000 defsubr (&Sscroll_down
);
3001 defsubr (&Sscroll_left
);
3002 defsubr (&Sscroll_right
);
3003 defsubr (&Sscroll_other_window
);
3004 defsubr (&Srecenter
);
3005 defsubr (&Smove_to_window_line
);
3006 defsubr (&Swindow_configuration_p
);
3007 defsubr (&Sset_window_configuration
);
3008 defsubr (&Scurrent_window_configuration
);
3009 defsubr (&Ssave_window_excursion
);
3014 initial_define_key (control_x_map
, '1', "delete-other-windows");
3015 initial_define_key (control_x_map
, '2', "split-window");
3016 initial_define_key (control_x_map
, '0', "delete-window");
3017 initial_define_key (control_x_map
, 'o', "other-window");
3018 initial_define_key (control_x_map
, '^', "enlarge-window");
3019 initial_define_key (control_x_map
, '<', "scroll-left");
3020 initial_define_key (control_x_map
, '>', "scroll-right");
3022 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3023 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3024 initial_define_key (meta_map
, 'v', "scroll-down");
3026 initial_define_key (global_map
, Ctl('L'), "recenter");
3027 initial_define_key (meta_map
, 'r', "move-to-window-line");