1 /* Window creation, deletion and examination for GNU Emacs.
2 Does not include redisplay.
3 Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 Lisp_Object Qwindowp
, Qwindow_live_p
;
34 Lisp_Object
Fnext_window (), Fdelete_window (), Fselect_window ();
35 Lisp_Object
Fset_window_buffer (), Fsplit_window (), Frecenter ();
37 void delete_all_subwindows ();
38 static struct window
*decode_window();
40 /* This is the window in which the terminal's cursor should
41 be left when nothing is being done with it. This must
42 always be a leaf window, and its buffer is selected by
43 the top level editing loop at the end of each command.
45 This value is always the same as
46 FRAME_SELECTED_WINDOW (selected_frame). */
48 Lisp_Object selected_window
;
50 /* The minibuffer window of the selected frame.
51 Note that you cannot test for minibufferness of an arbitrary window
52 by comparing against this; but you can test for minibufferness of
53 the selected window. */
54 Lisp_Object minibuf_window
;
56 /* Non-nil means it is the window for C-M-v to scroll
57 when the minibuffer is selected. */
58 Lisp_Object Vminibuf_scroll_window
;
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */
61 Lisp_Object Vother_window_scroll_buffer
;
63 /* Non-nil means it's function to call to display temp buffers. */
64 Lisp_Object Vtemp_buffer_show_function
;
66 /* If a window gets smaller than either of these, it is removed. */
67 int window_min_height
;
70 /* Nonzero implies Fdisplay_buffer should create windows. */
73 /* Nonzero implies make new frames for Fdisplay_buffer. */
76 /* Non-nil means use this function instead of default */
77 Lisp_Object Vpop_up_frame_function
;
79 /* Function to call to handle Fdisplay_buffer. */
80 Lisp_Object Vdisplay_buffer_function
;
82 /* List of buffer *names* for buffers that should have their own frames. */
83 Lisp_Object Vspecial_display_buffer_names
;
85 /* List of regexps for buffer names that should have their own frames. */
86 Lisp_Object Vspecial_display_regexps
;
88 /* Function to pop up a special frame. */
89 Lisp_Object Vspecial_display_function
;
91 /* Fdisplay_buffer always splits the largest window
92 if that window is more than this high. */
93 int split_height_threshold
;
95 /* Number of lines of continuity in scrolling by screenfuls. */
96 int next_screen_context_lines
;
98 /* Incremented for each window created. */
99 static int sequence_number
;
101 #define min(a, b) ((a) < (b) ? (a) : (b))
103 DEFUN ("windowp", Fwindowp
, Swindowp
, 1, 1, 0,
104 "Returns t if OBJ is a window.")
108 return WINDOWP (obj
) ? Qt
: Qnil
;
111 DEFUN ("window-live-p", Fwindow_live_p
, Swindow_live_p
, 1, 1, 0,
112 "Returns t if OBJ is a window which is currently visible.")
116 return (WINDOWP (obj
) && ! NILP (XWINDOW (obj
)->buffer
) ? Qt
: Qnil
);
122 register Lisp_Object val
;
123 register struct window
*p
;
125 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector)
126 includes the first element. */
128 make_number ((sizeof (struct window
) - sizeof (struct Lisp_Vector
)
129 + sizeof (Lisp_Object
))
130 / sizeof (Lisp_Object
)),
132 XSETTYPE (val
, Lisp_Window
);
134 XFASTINT (p
->sequence_number
) = ++sequence_number
;
135 XFASTINT (p
->left
) = XFASTINT (p
->top
)
136 = XFASTINT (p
->height
) = XFASTINT (p
->width
)
137 = XFASTINT (p
->hscroll
) = 0;
138 XFASTINT (p
->last_point_x
) = XFASTINT (p
->last_point_y
) = 0;
139 p
->start
= Fmake_marker ();
140 p
->pointm
= Fmake_marker ();
141 XFASTINT (p
->use_time
) = 0;
143 p
->display_table
= Qnil
;
148 DEFUN ("selected-window", Fselected_window
, Sselected_window
, 0, 0, 0,
149 "Return the window that the cursor now appears in and commands apply to.")
152 return selected_window
;
155 DEFUN ("minibuffer-window", Fminibuffer_window
, Sminibuffer_window
, 0, 1, 0,
156 "Return the window used now for minibuffers.\n\
157 If the optional argument FRAME is specified, return the minibuffer window\n\
158 used by that frame.")
164 XSET (frame
, Lisp_Frame
, selected_frame
);
166 CHECK_LIVE_FRAME (frame
, 0);
169 return FRAME_MINIBUF_WINDOW (XFRAME (frame
));
172 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p
, Swindow_minibuffer_p
, 0, 1, 0,
173 "Returns non-nil if WINDOW is a minibuffer window.")
177 struct window
*w
= decode_window (window
);
178 return (MINI_WINDOW_P (w
) ? Qt
: Qnil
);
181 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p
,
182 Spos_visible_in_window_p
, 0, 2, 0,
183 "Return t if position POS is currently on the frame in WINDOW.\n\
184 Returns nil if that position is scrolled vertically out of view.\n\
185 POS defaults to point; WINDOW, to the selected window.")
187 Lisp_Object pos
, window
;
189 register struct window
*w
;
193 register struct buffer
*buf
;
194 struct position posval
;
201 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
205 w
= decode_window (window
);
206 top
= marker_position (w
->start
);
207 hscroll
= XINT (w
->hscroll
);
212 height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
214 buf
= XBUFFER (w
->buffer
);
215 if (XFASTINT (w
->last_modified
) >= BUF_MODIFF (buf
))
217 /* If frame is up to date,
218 use the info recorded about how much text fit on it. */
219 if (posint
< BUF_Z (buf
) - XFASTINT (w
->window_end_pos
)
220 || (XFASTINT (w
->window_end_vpos
) < height
))
226 if (posint
> BUF_ZV (buf
))
229 /* w->start can be out of range. If it is, do something reasonable. */
230 if (top
< BUF_BEGV (buf
) || top
> BUF_ZV (buf
))
233 /* If that info is not correct, calculate afresh */
234 posval
= *compute_motion (top
, 0, (hscroll
? 1 - hscroll
: 0),
236 window_internal_width (w
) - 1,
239 return posval
.vpos
< height
? Qt
: Qnil
;
243 static struct window
*
244 decode_window (window
)
245 register Lisp_Object window
;
248 return XWINDOW (selected_window
);
250 CHECK_LIVE_WINDOW (window
, 0);
251 return XWINDOW (window
);
254 DEFUN ("window-buffer", Fwindow_buffer
, Swindow_buffer
, 0, 1, 0,
255 "Return the buffer that WINDOW is displaying.")
259 return decode_window (window
)->buffer
;
262 DEFUN ("window-height", Fwindow_height
, Swindow_height
, 0, 1, 0,
263 "Return the number of lines in WINDOW (including its mode line).")
267 return decode_window (window
)->height
;
270 DEFUN ("window-width", Fwindow_width
, Swindow_width
, 0, 1, 0,
271 "Return the number of display columns in WINDOW.\n\
272 This is the width that is usable columns available for text in WINDOW.\n\
273 If you want to find out how many columns WINDOW takes up,\n\
274 use (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
278 return make_number (window_internal_width (decode_window (window
)));
281 DEFUN ("window-hscroll", Fwindow_hscroll
, Swindow_hscroll
, 0, 1, 0,
282 "Return the number of columns by which WINDOW is scrolled from left margin.")
286 return decode_window (window
)->hscroll
;
289 DEFUN ("set-window-hscroll", Fset_window_hscroll
, Sset_window_hscroll
, 2, 2, 0,
290 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
291 NCOL should be zero or positive.")
293 register Lisp_Object window
, ncol
;
295 register struct window
*w
;
297 CHECK_NUMBER (ncol
, 1);
298 if (XINT (ncol
) < 0) XFASTINT (ncol
) = 0;
299 if (XFASTINT (ncol
) >= (1 << (SHORTBITS
- 1)))
300 args_out_of_range (ncol
, Qnil
);
301 w
= decode_window (window
);
302 if (XINT (w
->hscroll
) != XINT (ncol
))
303 clip_changed
= 1; /* Prevent redisplay shortcuts */
308 DEFUN ("window-edges", Fwindow_edges
, Swindow_edges
, 0, 1, 0,
309 "Return a list of the edge coordinates of WINDOW.\n\
310 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
311 RIGHT is one more than the rightmost column used by WINDOW,\n\
312 and BOTTOM is one more than the bottommost row used by WINDOW\n\
317 register struct window
*w
= decode_window (window
);
319 return Fcons (w
->left
, Fcons (w
->top
,
320 Fcons (make_number (XFASTINT (w
->left
) + XFASTINT (w
->width
)),
321 Fcons (make_number (XFASTINT (w
->top
)
322 + XFASTINT (w
->height
)),
326 /* Test if the character at column *x, row *y is within window *w.
327 If it is not, return 0;
328 if it is in the window's text area,
329 set *x and *y to its location relative to the upper left corner
332 if it is on the window's modeline, return 2;
333 if it is on the border between the window and its right sibling,
336 coordinates_in_window (w
, x
, y
)
337 register struct window
*w
;
340 register int left
= XINT (w
->left
);
341 register int width
= XINT (w
->width
);
342 register int window_height
= XINT (w
->height
);
343 register int top
= XFASTINT (w
->top
);
345 if ( *x
< left
|| *x
>= left
+ width
346 || *y
< top
|| *y
>= top
+ window_height
)
349 /* Is the character is the mode line? */
350 if (*y
== top
+ window_height
- 1
351 && ! MINI_WINDOW_P (w
))
354 /* Is the character in the right border? */
355 if (*x
== left
+ width
- 1
356 && left
+ width
!= FRAME_WIDTH (XFRAME (w
->frame
)))
364 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p
,
365 Scoordinates_in_window_p
, 2, 2, 0,
366 "Return non-nil if COORDINATES are in WINDOW.\n\
367 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
368 measured in characters from the upper-left corner of the frame.\n\
369 (0 . 0) denotes the character in the upper left corner of the\n\
371 If COORDINATES are in the text portion of WINDOW,\n\
372 the coordinates relative to the window are returned.\n\
373 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
374 If they are on the border between WINDOW and its right sibling,\n\
375 `vertical-line' is returned.")
376 (coordinates
, window
)
377 register Lisp_Object coordinates
, window
;
381 CHECK_LIVE_WINDOW (window
, 0);
382 CHECK_CONS (coordinates
, 1);
383 x
= XINT (Fcar (coordinates
));
384 y
= XINT (Fcdr (coordinates
));
386 switch (coordinates_in_window (XWINDOW (window
), &x
, &y
))
388 case 0: /* NOT in window at all. */
391 case 1: /* In text part of window. */
394 case 2: /* In mode line of window. */
397 case 3: /* On right border of window. */
398 return Qvertical_line
;
405 /* Find the window containing column x, row y, and return it as a
406 Lisp_Object. If x, y is on the window's modeline, set *part
407 to 1; if it is on the separating line between the window and its
408 right sibling, set it to 2; otherwise set it to 0. If there is no
409 window under x, y return nil and leave *part unmodified. */
411 window_from_coordinates (frame
, x
, y
, part
)
416 register Lisp_Object tem
, first
;
418 tem
= first
= FRAME_SELECTED_WINDOW (frame
);
422 int found
= coordinates_in_window (XWINDOW (tem
), &x
, &y
);
430 tem
= Fnext_window (tem
, Qt
, Qlambda
);
432 while (! EQ (tem
, first
));
437 DEFUN ("window-at", Fwindow_at
, Swindow_at
, 2, 3, 0,
438 "Return window containing coordinates X and Y on FRAME.\n\
439 If omitted, FRAME defaults to the currently selected frame.\n\
440 The top left corner of the frame is considered to be row 0,\n\
443 Lisp_Object x
, y
, frame
;
449 XSET (frame
, Lisp_Frame
, selected_frame
);
451 CHECK_LIVE_FRAME (frame
, 2);
456 return window_from_coordinates (XFRAME (frame
),
461 DEFUN ("window-point", Fwindow_point
, Swindow_point
, 0, 1, 0,
462 "Return current value of point in WINDOW.\n\
463 For a nonselected window, this is the value point would have\n\
464 if that window were selected.\n\
466 Note that, when WINDOW is the selected window and its buffer\n\
467 is also currently selected, the value returned is the same as (point).\n\
468 It would be more strictly correct to return the `top-level' value\n\
469 of point, outside of any save-excursion forms.\n\
470 But that is hard to define.")
474 register struct window
*w
= decode_window (window
);
476 if (w
== XWINDOW (selected_window
)
477 && current_buffer
== XBUFFER (w
->buffer
))
479 return Fmarker_position (w
->pointm
);
482 DEFUN ("window-start", Fwindow_start
, Swindow_start
, 0, 1, 0,
483 "Return position at which display currently starts in WINDOW.")
487 return Fmarker_position (decode_window (window
)->start
);
490 /* This is text temporarily removed from the doc string below.
492 This function returns nil if the position is not currently known.\n\
493 That happens when redisplay is preempted and doesn't finish.\n\
494 If in that case you want to compute where the end of the window would\n\
495 have been if redisplay had finished, do this:\n\
497 (goto-char (window-start window))\n\
498 (vertical-motion (1- (window-height window)) window)\n\
501 DEFUN ("window-end", Fwindow_end
, Swindow_end
, 0, 1, 0,
502 "Return position at which display currently ends in WINDOW.\n\
503 This is updated by redisplay, when it runs to completion.\n\
504 Simply changing the buffer text or setting `window-start'\n\
505 does not update this value.")
510 struct window
*w
= decode_window (window
);
514 CHECK_BUFFER (buf
, 0);
516 #if 0 /* This change broke some things. We should make it later. */
517 /* If we don't know the end position, return nil.
518 The user can compute it with vertical-motion if he wants to.
519 It would be nicer to do it automatically,
520 but that's so slow that it would probably bother people. */
521 if (NILP (w
->window_end_valid
))
525 XSET (value
, Lisp_Int
,
526 BUF_Z (XBUFFER (buf
)) - XFASTINT (w
->window_end_pos
));
531 DEFUN ("set-window-point", Fset_window_point
, Sset_window_point
, 2, 2, 0,
532 "Make point value in WINDOW be at position POS in WINDOW's buffer.")
534 Lisp_Object window
, pos
;
536 register struct window
*w
= decode_window (window
);
538 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
539 if (w
== XWINDOW (selected_window
))
542 set_marker_restricted (w
->pointm
, pos
, w
->buffer
);
547 DEFUN ("set-window-start", Fset_window_start
, Sset_window_start
, 2, 3, 0,
548 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
549 Optional third arg NOFORCE non-nil inhibits next redisplay\n\
550 from overriding motion of point in order to display at this exact start.")
551 (window
, pos
, noforce
)
552 Lisp_Object window
, pos
, noforce
;
554 register struct window
*w
= decode_window (window
);
556 CHECK_NUMBER_COERCE_MARKER (pos
, 1);
557 set_marker_restricted (w
->start
, pos
, w
->buffer
);
558 /* this is not right, but much easier than doing what is right. */
559 w
->start_at_line_beg
= Qnil
;
562 w
->update_mode_line
= Qt
;
563 XFASTINT (w
->last_modified
) = 0;
564 if (!EQ (window
, selected_window
))
565 windows_or_buffers_changed
++;
569 DEFUN ("window-dedicated-p", Fwindow_dedicated_p
, Swindow_dedicated_p
,
571 "Return WINDOW's dedicated object, usually t or nil.\n\
572 See also `set-window-dedicated-p'.")
576 return decode_window (window
)->dedicated
;
579 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p
,
580 Sset_window_dedicated_p
, 2, 2, 0,
581 "Control whether WINDOW is dedicated to the buffer it displays.\n\
582 If it is dedicated, Emacs will not automatically change\n\
583 which buffer appears in it.\n\
584 The second argument is the new value for the dedication flag;\n\
587 Lisp_Object window
, arg
;
589 register struct window
*w
= decode_window (window
);
599 DEFUN ("window-display-table", Fwindow_display_table
, Swindow_display_table
,
601 "Return the display-table that WINDOW is using.")
605 return decode_window (window
)->display_table
;
608 /* Get the display table for use currently on window W.
609 This is either W's display table or W's buffer's display table.
610 Ignore the specified tables if they are not valid;
611 if no valid table is specified, return 0. */
614 window_display_table (w
)
618 tem
= w
->display_table
;
619 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
620 return XVECTOR (tem
);
621 tem
= XBUFFER (w
->buffer
)->display_table
;
622 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
623 return XVECTOR (tem
);
624 tem
= Vstandard_display_table
;
625 if (VECTORP (tem
) && XVECTOR (tem
)->size
== DISP_TABLE_SIZE
)
626 return XVECTOR (tem
);
630 DEFUN ("set-window-display-table", Fset_window_display_table
, Sset_window_display_table
, 2, 2, 0,
631 "Set WINDOW's display-table to TABLE.")
633 register Lisp_Object window
, table
;
635 register struct window
*w
;
636 register Lisp_Object z
; /* Return value. */
638 w
= decode_window (window
);
639 w
->display_table
= table
;
643 /* Record info on buffer window w is displaying
644 when it is about to cease to display that buffer. */
647 register struct window
*w
;
652 if (XBUFFER (buf
) != XMARKER (w
->pointm
)->buffer
)
656 if (w
== XWINDOW (selected_window
)
657 || ! EQ (buf
, XWINDOW (selected_window
)->buffer
))
658 /* Do this except when the selected window's buffer
659 is being removed from some other window. */
661 /* last_window_start records the start position that this buffer
662 had in the last window to be disconnected from it.
663 Now that this statement is unconditional,
664 it is possible for the buffer to be displayed in the
665 selected window, while last_window_start reflects another
666 window which was recently showing the same buffer.
667 Some people might say that might be a good thing. Let's see. */
668 XBUFFER (buf
)->last_window_start
= marker_position (w
->start
);
670 /* Point in the selected window's buffer
671 is actually stored in that buffer, and the window's pointm isn't used.
672 So don't clobber point in that buffer. */
673 if (! EQ (buf
, XWINDOW (selected_window
)->buffer
))
674 BUF_PT (XBUFFER (buf
))
675 = clip_to_bounds (BUF_BEGV (XBUFFER (buf
)),
676 marker_position (w
->pointm
),
677 BUF_ZV (XBUFFER (buf
)));
680 /* Put replacement into the window structure in place of old. */
682 replace_window (old
, replacement
)
683 Lisp_Object old
, replacement
;
685 register Lisp_Object tem
;
686 register struct window
*o
= XWINDOW (old
), *p
= XWINDOW (replacement
);
688 /* If OLD is its frame's root_window, then replacement is the new
689 root_window for that frame. */
691 if (EQ (old
, FRAME_ROOT_WINDOW (XFRAME (o
->frame
))))
692 FRAME_ROOT_WINDOW (XFRAME (o
->frame
)) = replacement
;
697 p
->height
= o
->height
;
699 p
->next
= tem
= o
->next
;
701 XWINDOW (tem
)->prev
= replacement
;
703 p
->prev
= tem
= o
->prev
;
705 XWINDOW (tem
)->next
= replacement
;
707 p
->parent
= tem
= o
->parent
;
710 if (EQ (XWINDOW (tem
)->vchild
, old
))
711 XWINDOW (tem
)->vchild
= replacement
;
712 if (EQ (XWINDOW (tem
)->hchild
, old
))
713 XWINDOW (tem
)->hchild
= replacement
;
716 /*** Here, if replacement is a vertical combination
717 and so is its new parent, we should make replacement's
718 children be children of that parent instead. ***/
721 DEFUN ("delete-window", Fdelete_window
, Sdelete_window
, 0, 1, "",
722 "Remove WINDOW from the display. Default is selected window.")
724 register Lisp_Object window
;
726 register Lisp_Object tem
, parent
, sib
;
727 register struct window
*p
;
728 register struct window
*par
;
730 /* Because this function is called by other C code on non-leaf
731 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately,
732 so we can't decode_window here. */
734 window
= selected_window
;
736 CHECK_WINDOW (window
, 0);
737 p
= XWINDOW (window
);
739 /* It's okay to delete an already-deleted window. */
747 error ("Attempt to delete minibuffer or sole ordinary window");
748 par
= XWINDOW (parent
);
750 windows_or_buffers_changed
++;
752 /* Are we trying to delete any frame's selected window? */
754 Lisp_Object frame
, pwindow
;
756 /* See if the frame's selected window is either WINDOW
757 or any subwindow of it, by finding all that window's parents
758 and comparing each one with WINDOW. */
759 frame
= WINDOW_FRAME (XWINDOW (window
));
760 pwindow
= FRAME_SELECTED_WINDOW (XFRAME (frame
));
762 while (!NILP (pwindow
))
764 if (EQ (window
, pwindow
))
766 pwindow
= XWINDOW (pwindow
)->parent
;
769 if (EQ (window
, pwindow
))
771 Lisp_Object alternative
;
772 alternative
= Fnext_window (window
, Qlambda
, Qnil
);
774 /* If we're about to delete the selected window on the
775 selected frame, then we should use Fselect_window to select
776 the new window. On the other hand, if we're about to
777 delete the selected window on any other frame, we shouldn't do
778 anything but set the frame's selected_window slot. */
779 if (EQ (window
, selected_window
))
780 Fselect_window (alternative
);
782 FRAME_SELECTED_WINDOW (XFRAME (frame
)) = alternative
;
787 /* tem is null for dummy parent windows
788 (which have inferiors but not any contents themselves) */
792 unchain_marker (p
->pointm
);
793 unchain_marker (p
->start
);
798 XWINDOW (tem
)->prev
= p
->prev
;
802 XWINDOW (tem
)->next
= p
->next
;
804 if (EQ (window
, par
->hchild
))
805 par
->hchild
= p
->next
;
806 if (EQ (window
, par
->vchild
))
807 par
->vchild
= p
->next
;
809 /* Find one of our siblings to give our space to. */
813 /* If p gives its space to its next sibling, that sibling needs
814 to have its top/left side pulled back to where p's is.
815 set_window_{height,width} will re-position the sibling's
818 XWINDOW (sib
)->top
= p
->top
;
819 XWINDOW (sib
)->left
= p
->left
;
822 /* Stretch that sibling. */
823 if (!NILP (par
->vchild
))
824 set_window_height (sib
,
825 XFASTINT (XWINDOW (sib
)->height
) + XFASTINT (p
->height
),
827 if (!NILP (par
->hchild
))
828 set_window_width (sib
,
829 XFASTINT (XWINDOW (sib
)->width
) + XFASTINT (p
->width
),
832 /* If parent now has only one child,
833 put the child into the parent's place. */
837 if (NILP (XWINDOW (tem
)->next
))
838 replace_window (parent
, tem
);
840 /* Since we may be deleting combination windows, we must make sure that
841 not only p but all its children have been marked as deleted. */
842 if (! NILP (p
->hchild
))
843 delete_all_subwindows (XWINDOW (p
->hchild
));
844 else if (! NILP (p
->vchild
))
845 delete_all_subwindows (XWINDOW (p
->vchild
));
847 /* Mark this window as deleted. */
848 p
->buffer
= p
->hchild
= p
->vchild
= Qnil
;
854 extern Lisp_Object
next_frame (), prev_frame ();
856 /* This comment supplies the doc string for `next-window',
857 for make-docfile to see. We cannot put this in the real DEFUN
858 due to limits in the Unix cpp.
860 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
861 "Return next window after WINDOW in canonical ordering of windows.\n\
862 If omitted, WINDOW defaults to the selected window.\n\
864 Optional second arg MINIBUF t means count the minibuffer window even\n\
865 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
866 it is active. MINIBUF neither t nor nil means not to count the\n\
867 minibuffer even if it is active.\n\
869 Several frames may share a single minibuffer; if the minibuffer\n\
870 counts, all windows on all frames that share that minibuffer count\n\
871 too. Therefore, `next-window' can be used to iterate through the\n\
872 set of windows even when the minibuffer is on another frame. If the\n\
873 minibuffer does not count, only windows from WINDOW's frame count.\n\
875 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
876 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
877 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
878 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
879 Anything else means restrict to WINDOW's frame.\n\
881 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
882 `next-window' to iterate through the entire cycle of acceptable\n\
883 windows, eventually ending up back at the window you started with.\n\
884 `previous-window' traverses the same cycle, in the reverse order.")
885 (window, minibuf, all_frames) */
887 DEFUN ("next-window", Fnext_window
, Snext_window
, 0, 3, 0,
889 (window
, minibuf
, all_frames
)
890 register Lisp_Object window
, minibuf
, all_frames
;
892 register Lisp_Object tem
;
893 Lisp_Object start_window
;
896 window
= selected_window
;
898 CHECK_LIVE_WINDOW (window
, 0);
900 start_window
= window
;
902 /* minibuf == nil may or may not include minibuffers.
903 Decide if it does. */
905 minibuf
= (minibuf_level
? Qt
: Qlambda
);
908 /* all_frames == nil doesn't specify which frames to include. */
909 if (NILP (all_frames
))
910 all_frames
= (EQ (minibuf
, Qt
)
911 ? (FRAME_MINIBUF_WINDOW
914 (XWINDOW (window
)))))
916 else if (EQ (all_frames
, Qvisible
))
918 else if (XFASTINT (all_frames
) == 0)
920 else if (! EQ (all_frames
, Qt
))
922 /* Now all_frames is t meaning search all frames,
923 nil meaning search just current frame,
924 visible meaning search just visible frames,
925 0 meaning search visible and iconified frames,
926 or a window, meaning search the frame that window belongs to. */
929 /* Do this loop at least once, to get the next window, and perhaps
930 again, if we hit the minibuffer and that is not acceptable. */
933 /* Find a window that actually has a next one. This loop
934 climbs up the tree. */
935 while (tem
= XWINDOW (window
)->next
, NILP (tem
))
936 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
940 /* We've reached the end of this frame.
941 Which other frames are acceptable? */
942 tem
= WINDOW_FRAME (XWINDOW (window
));
944 if (! NILP (all_frames
))
949 tem
= next_frame (tem
, all_frames
);
950 /* In the case where the minibuffer is active,
951 and we include its frame as well as the selected one,
952 next_frame may get stuck in that frame.
953 If that happens, go back to the selected frame
954 so we can complete the cycle. */
956 XSET (tem
, Lisp_Frame
, selected_frame
);
959 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
966 /* If we're in a combination window, find its first child and
967 recurse on that. Otherwise, we've found the window we want. */
970 if (!NILP (XWINDOW (window
)->hchild
))
971 window
= XWINDOW (window
)->hchild
;
972 else if (!NILP (XWINDOW (window
)->vchild
))
973 window
= XWINDOW (window
)->vchild
;
977 /* Which windows are acceptible?
978 Exit the loop and accept this window if
979 this isn't a minibuffer window, or
980 we're accepting minibuffer windows, or
981 we've come all the way around and we're back at the original window. */
982 while (MINI_WINDOW_P (XWINDOW (window
))
983 && ! EQ (minibuf
, Qt
)
984 && ! EQ (window
, start_window
));
989 /* This comment supplies the doc string for `previous-window',
990 for make-docfile to see. We cannot put this in the real DEFUN
991 due to limits in the Unix cpp.
993 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
994 "Return the window preceeding WINDOW in canonical ordering of windows.\n\
995 If omitted, WINDOW defaults to the selected window.\n\
997 Optional second arg MINIBUF t means count the minibuffer window even\n\
998 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\
999 it is active. MINIBUF neither t nor nil means not to count the\n\
1000 minibuffer even if it is active.\n\
1002 Several frames may share a single minibuffer; if the minibuffer\n\
1003 counts, all windows on all frames that share that minibuffer count\n\
1004 too. Therefore, `previous-window' can be used to iterate through\n\
1005 the set of windows even when the minibuffer is on another frame. If\n\
1006 the minibuffer does not count, only windows from WINDOW's frame count\n\
1008 Optional third arg ALL-FRAMES t means include windows on all frames.\n\
1009 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
1010 above. ALL-FRAMES = `visible' means include windows on all visible frames.\n\
1011 ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
1012 Anything else means restrict to WINDOW's frame.\n\
1014 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
1015 `previous-window' to iterate through the entire cycle of acceptable\n\
1016 windows, eventually ending up back at the window you started with.\n\
1017 `next-window' traverses the same cycle, in the reverse order.")
1018 (window, minibuf, all_frames) */
1021 DEFUN ("previous-window", Fprevious_window
, Sprevious_window
, 0, 3, 0,
1023 (window
, minibuf
, all_frames
)
1024 register Lisp_Object window
, minibuf
, all_frames
;
1026 register Lisp_Object tem
;
1027 Lisp_Object start_window
;
1030 window
= selected_window
;
1032 CHECK_LIVE_WINDOW (window
, 0);
1034 start_window
= window
;
1036 /* minibuf == nil may or may not include minibuffers.
1037 Decide if it does. */
1039 minibuf
= (minibuf_level
? Qt
: Qlambda
);
1042 /* all_frames == nil doesn't specify which frames to include.
1043 Decide which frames it includes. */
1044 if (NILP (all_frames
))
1045 all_frames
= (EQ (minibuf
, Qt
)
1046 ? (FRAME_MINIBUF_WINDOW
1049 (XWINDOW (window
)))))
1051 else if (EQ (all_frames
, Qvisible
))
1053 else if (XFASTINT (all_frames
) == 0)
1055 else if (! EQ (all_frames
, Qt
))
1057 /* Now all_frames is t meaning search all frames,
1058 nil meaning search just current frame,
1059 visible meaning search just visible frames,
1060 0 meaning search visible and iconified frames,
1061 or a window, meaning search the frame that window belongs to. */
1064 /* Do this loop at least once, to get the previous window, and perhaps
1065 again, if we hit the minibuffer and that is not acceptable. */
1068 /* Find a window that actually has a previous one. This loop
1069 climbs up the tree. */
1070 while (tem
= XWINDOW (window
)->prev
, NILP (tem
))
1071 if (tem
= XWINDOW (window
)->parent
, !NILP (tem
))
1075 /* We have found the top window on the frame.
1076 Which frames are acceptable? */
1077 tem
= WINDOW_FRAME (XWINDOW (window
));
1079 if (! NILP (all_frames
))
1080 /* It's actually important that we use prev_frame here,
1081 rather than next_frame. All the windows acceptable
1082 according to the given parameters should form a ring;
1083 Fnext_window and Fprevious_window should go back and
1084 forth around the ring. If we use next_frame here,
1085 then Fnext_window and Fprevious_window take different
1086 paths through the set of acceptable windows.
1087 window_loop assumes that these `ring' requirement are
1093 tem
= prev_frame (tem
, all_frames
);
1094 /* In the case where the minibuffer is active,
1095 and we include its frame as well as the selected one,
1096 next_frame may get stuck in that frame.
1097 If that happens, go back to the selected frame
1098 so we can complete the cycle. */
1100 XSET (tem
, Lisp_Frame
, selected_frame
);
1103 /* If this frame has a minibuffer, find that window first,
1104 because it is conceptually the last window in that frame. */
1105 if (FRAME_HAS_MINIBUF_P (XFRAME (tem
)))
1106 tem
= FRAME_MINIBUF_WINDOW (XFRAME (tem
));
1108 tem
= FRAME_ROOT_WINDOW (XFRAME (tem
));
1114 /* If we're in a combination window, find its last child and
1115 recurse on that. Otherwise, we've found the window we want. */
1118 if (!NILP (XWINDOW (window
)->hchild
))
1119 window
= XWINDOW (window
)->hchild
;
1120 else if (!NILP (XWINDOW (window
)->vchild
))
1121 window
= XWINDOW (window
)->vchild
;
1123 while (tem
= XWINDOW (window
)->next
, !NILP (tem
))
1127 /* Which windows are acceptable?
1128 Exit the loop and accept this window if
1129 this isn't a minibuffer window, or
1130 we're accepting minibuffer windows, or
1131 we've come all the way around and we're back at the original window. */
1132 while (MINI_WINDOW_P (XWINDOW (window
))
1133 && !EQ (minibuf
, Qt
)
1134 && !EQ (window
, start_window
));
1139 DEFUN ("other-window", Fother_window
, Sother_window
, 1, 2, "p",
1140 "Select the ARG'th different window on this frame.\n\
1141 All windows on current frame are arranged in a cyclic order.\n\
1142 This command selects the window ARG steps away in that order.\n\
1143 A negative ARG moves in the opposite order. If the optional second\n\
1144 argument ALL_FRAMES is non-nil, cycle through all frames.")
1146 register Lisp_Object n
, all_frames
;
1149 register Lisp_Object w
;
1151 CHECK_NUMBER (n
, 0);
1152 w
= selected_window
;
1157 w
= Fnext_window (w
, Qnil
, all_frames
);
1162 w
= Fprevious_window (w
, Qnil
, all_frames
);
1169 /* Look at all windows, performing an operation specified by TYPE
1171 If FRAMES is Qt, look at all frames;
1172 Qnil, look at just the selected frame;
1173 Qvisible, look at visible frames;
1174 a frame, just look at windows on that frame.
1175 If MINI is non-zero, perform the operation on minibuffer windows too.
1181 GET_BUFFER_WINDOW
, /* Arg is buffer */
1182 GET_LRU_WINDOW
, /* Arg is t for full-width windows only */
1183 DELETE_OTHER_WINDOWS
, /* Arg is window not to delete */
1184 DELETE_BUFFER_WINDOWS
, /* Arg is buffer */
1186 UNSHOW_BUFFER
/* Arg is buffer */
1190 window_loop (type
, obj
, mini
, frames
)
1191 enum window_loop type
;
1192 register Lisp_Object obj
, frames
;
1195 register Lisp_Object w
;
1196 register Lisp_Object best_window
;
1197 register Lisp_Object next_window
;
1198 register Lisp_Object last_window
;
1200 Lisp_Object frame_arg
;
1204 /* If we're only looping through windows on a particular frame,
1205 frame points to that frame. If we're looping through windows
1206 on all frames, frame is 0. */
1207 if (FRAMEP (frames
))
1208 frame
= XFRAME (frames
);
1209 else if (NILP (frames
))
1210 frame
= selected_frame
;
1214 frame_arg
= Qlambda
;
1215 else if (XFASTINT (frames
) == 0)
1217 else if (EQ (frames
, Qvisible
))
1223 /* frame_arg is Qlambda to stick to one frame,
1224 Qvisible to consider all visible frames,
1227 /* Pick a window to start with. */
1231 w
= FRAME_SELECTED_WINDOW (frame
);
1233 w
= FRAME_SELECTED_WINDOW (selected_frame
);
1235 /* Figure out the last window we're going to mess with. Since
1236 Fnext_window, given the same options, is guaranteed to go in a
1237 ring, we can just use Fprevious_window to find the last one.
1239 We can't just wait until we hit the first window again, because
1240 it might be deleted. */
1242 last_window
= Fprevious_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1247 FRAME_PTR w_frame
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1249 /* Pick the next window now, since some operations will delete
1250 the current window. */
1251 next_window
= Fnext_window (w
, mini
? Qt
: Qnil
, frame_arg
);
1253 /* Note that we do not pay attention here to whether
1254 the frame is visible, since Fnext_window skips non-visible frames
1255 if that is desired, under the control of frame_arg. */
1256 if (! MINI_WINDOW_P (XWINDOW (w
))
1257 || (mini
&& minibuf_level
> 0))
1260 case GET_BUFFER_WINDOW
:
1261 if (XBUFFER (XWINDOW (w
)->buffer
) == XBUFFER (obj
))
1265 case GET_LRU_WINDOW
:
1266 /* t as arg means consider only full-width windows */
1267 if (!NILP (obj
) && XFASTINT (XWINDOW (w
)->width
)
1268 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w
)))))
1270 /* Ignore dedicated windows and minibuffers. */
1271 if (MINI_WINDOW_P (XWINDOW (w
))
1272 || !NILP (XWINDOW (w
)->dedicated
))
1274 if (NILP (best_window
)
1275 || (XFASTINT (XWINDOW (best_window
)->use_time
)
1276 > XFASTINT (XWINDOW (w
)->use_time
)))
1280 case DELETE_OTHER_WINDOWS
:
1281 if (XWINDOW (w
) != XWINDOW (obj
))
1285 case DELETE_BUFFER_WINDOWS
:
1286 if (EQ (XWINDOW (w
)->buffer
, obj
))
1288 /* If we're deleting the buffer displayed in the only window
1289 on the frame, find a new buffer to display there. */
1290 if (NILP (XWINDOW (w
)->parent
))
1292 Lisp_Object new_buffer
;
1293 new_buffer
= Fother_buffer (obj
, Qnil
);
1294 if (NILP (new_buffer
))
1296 = Fget_buffer_create (build_string ("*scratch*"));
1297 Fset_window_buffer (w
, new_buffer
);
1298 if (EQ (w
, selected_window
))
1299 Fset_buffer (XWINDOW (w
)->buffer
);
1306 case GET_LARGEST_WINDOW
:
1307 /* Ignore dedicated windows and minibuffers. */
1308 if (MINI_WINDOW_P (XWINDOW (w
))
1309 || !NILP (XWINDOW (w
)->dedicated
))
1312 struct window
*best_window_ptr
= XWINDOW (best_window
);
1313 struct window
*w_ptr
= XWINDOW (w
);
1314 if (NILP (best_window
)
1315 || (XFASTINT (w_ptr
->height
) * XFASTINT (w_ptr
->width
)
1316 > (XFASTINT (best_window_ptr
->height
)
1317 * XFASTINT (best_window_ptr
->width
))))
1323 if (EQ (XWINDOW (w
)->buffer
, obj
))
1325 /* Find another buffer to show in this window. */
1326 Lisp_Object another_buffer
;
1327 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (w
)));
1328 another_buffer
= Fother_buffer (obj
, Qnil
);
1329 if (NILP (another_buffer
))
1331 = Fget_buffer_create (build_string ("*scratch*"));
1333 /* If this window is dedicated, and in a frame of its own,
1335 if (EQ (w
, FRAME_ROOT_WINDOW (f
))
1336 && !NILP (XWINDOW (w
)->dedicated
)
1337 && other_visible_frames (f
))
1339 /* Skip the other windows on this frame.
1340 There might be one, the minibuffer! */
1341 if (! EQ (w
, last_window
))
1342 while (f
== XFRAME (WINDOW_FRAME (XWINDOW (next_window
))))
1344 /* As we go, check for the end of the loop.
1345 We mustn't start going around a second time. */
1346 if (EQ (next_window
, last_window
))
1351 next_window
= Fnext_window (next_window
,
1355 /* Now we can safely delete the frame. */
1356 Fdelete_frame (WINDOW_FRAME (XWINDOW (w
)), Qnil
);
1361 /* Otherwise show a different buffer in the window. */
1362 XWINDOW (w
)->dedicated
= Qnil
;
1363 Fset_window_buffer (w
, another_buffer
);
1364 if (EQ (w
, selected_window
))
1365 Fset_buffer (XWINDOW (w
)->buffer
);
1371 if (EQ (w
, last_window
))
1380 DEFUN ("get-lru-window", Fget_lru_window
, Sget_lru_window
, 0, 1, 0,
1381 "Return the window least recently selected or used for display.\n\
1382 If optional argument FRAME is `visible', search all visible frames.\n\
1383 If FRAME is 0, search all visible and iconified frames.\n\
1384 If FRAME is t, search all frames.\n\
1385 If FRAME is nil, search only the selected frame.\n\
1386 If FRAME is a frame, search only that frame.")
1390 register Lisp_Object w
;
1391 /* First try for a window that is full-width */
1392 w
= window_loop (GET_LRU_WINDOW
, Qt
, 0, frame
);
1393 if (!NILP (w
) && !EQ (w
, selected_window
))
1395 /* If none of them, try the rest */
1396 return window_loop (GET_LRU_WINDOW
, Qnil
, 0, frame
);
1399 DEFUN ("get-largest-window", Fget_largest_window
, Sget_largest_window
, 0, 1, 0,
1400 "Return the largest window in area.\n\
1401 If optional argument FRAME is `visible', search all visible frames.\n\
1402 If FRAME is 0, search all visible and iconified frames.\n\
1403 If FRAME is t, search all frames.\n\
1404 If FRAME is nil, search only the selected frame.\n\
1405 If FRAME is a frame, search only that frame.")
1409 return window_loop (GET_LARGEST_WINDOW
, Qnil
, 0,
1413 DEFUN ("get-buffer-window", Fget_buffer_window
, Sget_buffer_window
, 1, 2, 0,
1414 "Return a window currently displaying BUFFER, or nil if none.\n\
1415 If optional argument FRAME is `visible', search all visible frames.\n\
1416 If optional argument FRAME is 0, search all visible and iconified frames.\n\
1417 If FRAME is t, search all frames.\n\
1418 If FRAME is nil, search only the selected frame.\n\
1419 If FRAME is a frame, search only that frame.")
1421 Lisp_Object buffer
, frame
;
1423 buffer
= Fget_buffer (buffer
);
1424 if (BUFFERP (buffer
))
1425 return window_loop (GET_BUFFER_WINDOW
, buffer
, 1, frame
);
1430 DEFUN ("delete-other-windows", Fdelete_other_windows
, Sdelete_other_windows
,
1432 "Make WINDOW (or the selected window) fill its frame.\n\
1433 Only the frame WINDOW is on is affected.\n\
1434 This function tries to reduce display jumps\n\
1435 by keeping the text previously visible in WINDOW\n\
1436 in the same place on the frame. Doing this depends on\n\
1437 the value of (window-start WINDOW), so if calling this function\n\
1438 in a program gives strange scrolling, make sure the window-start\n\
1439 value is reasonable when this function is called.")
1448 window
= selected_window
;
1450 CHECK_LIVE_WINDOW (window
, 0);
1452 w
= XWINDOW (window
);
1454 startpos
= marker_position (w
->start
);
1455 top
= XFASTINT (w
->top
) - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w
)));
1457 if (MINI_WINDOW_P (w
) && top
> 0)
1458 error ("Can't expand minibuffer to full frame");
1460 window_loop (DELETE_OTHER_WINDOWS
, window
, 0, WINDOW_FRAME (w
));
1462 /* Try to minimize scrolling, by setting the window start to the point
1463 will cause the text at the old window start to be at the same place
1464 on the frame. But don't try to do this if the window start is
1465 outside the visible portion (as might happen when the display is
1466 not current, due to typeahead). */
1467 if (startpos
>= BUF_BEGV (XBUFFER (w
->buffer
))
1468 && startpos
<= BUF_ZV (XBUFFER (w
->buffer
)))
1470 struct position pos
;
1471 struct buffer
*obuf
= current_buffer
;
1473 Fset_buffer (w
->buffer
);
1474 /* This computation used to temporarily move point, but that can
1475 have unwanted side effects due to text properties. */
1476 pos
= *vmotion (startpos
, -top
, window_internal_width (w
) - 1,
1477 XINT (w
->hscroll
), window
);
1478 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
1479 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
1480 || FETCH_CHAR (pos
.bufpos
- 1) == '\n') ? Qt
1483 set_buffer_internal (obuf
);
1488 DEFUN ("delete-windows-on", Fdelete_windows_on
, Sdelete_windows_on
,
1489 1, 2, "bDelete windows on (buffer): ",
1490 "Delete all windows showing BUFFER.\n\
1491 Optional second argument FRAME controls which frames are affected.\n\
1492 If nil or omitted, delete all windows showing BUFFER in any frame.\n\
1493 If t, delete only windows showing BUFFER in the selected frame.\n\
1494 If `visible', delete all windows showing BUFFER in any visible frame.\n\
1495 If a frame, delete only windows showing BUFFER in that frame.")
1497 Lisp_Object buffer
, frame
;
1500 /* FRAME uses t and nil to mean the opposite of what window_loop
1502 if (! FRAMEP (frame
))
1503 frame
= NILP (frame
) ? Qt
: Qnil
;
1510 buffer
= Fget_buffer (buffer
);
1511 CHECK_BUFFER (buffer
, 0);
1512 window_loop (DELETE_BUFFER_WINDOWS
, buffer
, 0, frame
);
1517 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows
,
1518 Sreplace_buffer_in_windows
,
1519 1, 1, "bReplace buffer in windows: ",
1520 "Replace BUFFER with some other buffer in all windows showing it.")
1526 buffer
= Fget_buffer (buffer
);
1527 CHECK_BUFFER (buffer
, 0);
1528 window_loop (UNSHOW_BUFFER
, buffer
, 0, Qt
);
1533 /* Set the height of WINDOW and all its inferiors. */
1535 /* The smallest acceptable dimensions for a window. Anything smaller
1536 might crash Emacs. */
1537 #define MIN_SAFE_WINDOW_WIDTH (2)
1538 #define MIN_SAFE_WINDOW_HEIGHT (2)
1540 /* Make sure that window_min_height and window_min_width are
1541 not too small; if they are, set them to safe minima. */
1544 check_min_window_sizes ()
1546 /* Smaller values might permit a crash. */
1547 if (window_min_width
< MIN_SAFE_WINDOW_WIDTH
)
1548 window_min_width
= MIN_SAFE_WINDOW_WIDTH
;
1549 if (window_min_height
< MIN_SAFE_WINDOW_HEIGHT
)
1550 window_min_height
= MIN_SAFE_WINDOW_HEIGHT
;
1553 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
1554 minimum allowable size. */
1556 check_frame_size (frame
, rows
, cols
)
1560 /* For height, we have to see:
1561 whether the frame has a minibuffer,
1562 whether it wants a mode line, and
1563 whether it has a menu bar. */
1565 (FRAME_MINIBUF_ONLY_P (frame
) ? MIN_SAFE_WINDOW_HEIGHT
- 1
1566 : (! FRAME_HAS_MINIBUF_P (frame
)) ? MIN_SAFE_WINDOW_HEIGHT
1567 : 2 * MIN_SAFE_WINDOW_HEIGHT
- 1);
1568 if (FRAME_MENU_BAR_LINES (frame
) > 0)
1569 min_height
+= FRAME_MENU_BAR_LINES (frame
);
1571 if (*rows
< min_height
)
1573 if (*cols
< MIN_SAFE_WINDOW_WIDTH
)
1574 *cols
= MIN_SAFE_WINDOW_WIDTH
;
1577 /* Normally the window is deleted if it gets too small.
1578 nodelete nonzero means do not do this.
1579 (The caller should check later and do so if appropriate) */
1581 set_window_height (window
, height
, nodelete
)
1586 register struct window
*w
= XWINDOW (window
);
1587 register struct window
*c
;
1588 int oheight
= XFASTINT (w
->height
);
1589 int top
, pos
, lastbot
, opos
, lastobot
;
1592 check_min_window_sizes ();
1595 && ! NILP (w
->parent
)
1596 && height
< window_min_height
)
1598 Fdelete_window (window
);
1602 XFASTINT (w
->last_modified
) = 0;
1603 windows_or_buffers_changed
++;
1604 XFASTINT (w
->height
) = height
;
1605 if (!NILP (w
->hchild
))
1607 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1609 XWINDOW (child
)->top
= w
->top
;
1610 set_window_height (child
, height
, nodelete
);
1613 else if (!NILP (w
->vchild
))
1615 lastbot
= top
= XFASTINT (w
->top
);
1617 for (child
= w
->vchild
; !NILP (child
); child
= c
->next
)
1619 c
= XWINDOW (child
);
1621 opos
= lastobot
+ XFASTINT (c
->height
);
1623 XFASTINT (c
->top
) = lastbot
;
1625 pos
= (((opos
* height
) << 1) + oheight
) / (oheight
<< 1);
1627 /* Avoid confusion: inhibit deletion of child if becomes too small */
1628 set_window_height (child
, pos
+ top
- lastbot
, 1);
1630 /* Now advance child to next window,
1631 and set lastbot if child was not just deleted. */
1632 lastbot
= pos
+ top
;
1635 /* Now delete any children that became too small. */
1637 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1639 set_window_height (child
, XINT (XWINDOW (child
)->height
), 0);
1644 /* Recursively set width of WINDOW and its inferiors. */
1646 set_window_width (window
, width
, nodelete
)
1651 register struct window
*w
= XWINDOW (window
);
1652 register struct window
*c
;
1653 int owidth
= XFASTINT (w
->width
);
1654 int left
, pos
, lastright
, opos
, lastoright
;
1657 if (!nodelete
&& width
< window_min_width
&& !NILP (w
->parent
))
1659 Fdelete_window (window
);
1663 XFASTINT (w
->last_modified
) = 0;
1664 windows_or_buffers_changed
++;
1665 XFASTINT (w
->width
) = width
;
1666 if (!NILP (w
->vchild
))
1668 for (child
= w
->vchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1670 XWINDOW (child
)->left
= w
->left
;
1671 set_window_width (child
, width
, nodelete
);
1674 else if (!NILP (w
->hchild
))
1676 lastright
= left
= XFASTINT (w
->left
);
1678 for (child
= w
->hchild
; !NILP (child
); child
= c
->next
)
1680 c
= XWINDOW (child
);
1682 opos
= lastoright
+ XFASTINT (c
->width
);
1684 XFASTINT (c
->left
) = lastright
;
1686 pos
= (((opos
* width
) << 1) + owidth
) / (owidth
<< 1);
1688 /* Inhibit deletion for becoming too small */
1689 set_window_width (child
, pos
+ left
- lastright
, 1);
1691 /* Now advance child to next window,
1692 and set lastright if child was not just deleted. */
1693 lastright
= pos
+ left
, lastoright
= opos
;
1695 /* Delete children that became too small */
1697 for (child
= w
->hchild
; !NILP (child
); child
= XWINDOW (child
)->next
)
1699 set_window_width (child
, XINT (XWINDOW (child
)->width
), 0);
1704 int window_select_count
;
1706 DEFUN ("set-window-buffer", Fset_window_buffer
, Sset_window_buffer
, 2, 2, 0,
1707 "Make WINDOW display BUFFER as its contents.\n\
1708 BUFFER can be a buffer or buffer name.")
1710 register Lisp_Object window
, buffer
;
1712 register Lisp_Object tem
;
1713 register struct window
*w
= decode_window (window
);
1715 buffer
= Fget_buffer (buffer
);
1716 CHECK_BUFFER (buffer
, 1);
1718 if (NILP (XBUFFER (buffer
)->name
))
1719 error ("Attempt to display deleted buffer");
1723 error ("Window is deleted");
1724 else if (! EQ (tem
, Qt
)) /* w->buffer is t when the window
1725 is first being set up. */
1727 if (!NILP (w
->dedicated
) && !EQ (tem
, buffer
))
1728 error ("Window is dedicated to `%s'",
1729 XSTRING (XBUFFER (tem
)->name
)->data
);
1735 XFASTINT (w
->window_end_pos
) = 0;
1736 w
->window_end_valid
= Qnil
;
1737 XFASTINT(w
->hscroll
) = 0;
1738 Fset_marker (w
->pointm
,
1739 make_number (BUF_PT (XBUFFER (buffer
))),
1741 set_marker_restricted (w
->start
,
1742 make_number (XBUFFER (buffer
)->last_window_start
),
1744 w
->start_at_line_beg
= Qnil
;
1745 w
->force_start
= Qnil
;
1746 XFASTINT (w
->last_modified
) = 0;
1747 windows_or_buffers_changed
++;
1748 if (EQ (window
, selected_window
))
1749 Fset_buffer (buffer
);
1754 DEFUN ("select-window", Fselect_window
, Sselect_window
, 1, 1, 0,
1755 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\
1756 The main editor command loop selects the buffer of the selected window\n\
1757 before each command.")
1759 register Lisp_Object window
;
1761 register struct window
*w
;
1762 register struct window
*ow
= XWINDOW (selected_window
);
1764 CHECK_LIVE_WINDOW (window
, 0);
1766 w
= XWINDOW (window
);
1768 if (NILP (w
->buffer
))
1769 error ("Trying to select deleted window or non-leaf window");
1771 XFASTINT (w
->use_time
) = ++window_select_count
;
1772 if (EQ (window
, selected_window
))
1775 Fset_marker (ow
->pointm
, make_number (BUF_PT (XBUFFER (ow
->buffer
))),
1778 selected_window
= window
;
1780 if (XFRAME (WINDOW_FRAME (w
)) != selected_frame
)
1782 XFRAME (WINDOW_FRAME (w
))->selected_window
= window
;
1783 /* Use this rather than Fhandle_switch_frame
1784 so that FRAME_FOCUS_FRAME is moved appropriately as we
1785 move around in the state where a minibuffer in a separate
1787 Fselect_frame (WINDOW_FRAME (w
), Qnil
);
1790 selected_frame
->selected_window
= window
;
1793 record_buffer (w
->buffer
);
1794 Fset_buffer (w
->buffer
);
1796 /* Go to the point recorded in the window.
1797 This is important when the buffer is in more
1798 than one window. It also matters when
1799 redisplay_window has altered point after scrolling,
1800 because it makes the change only in the window. */
1802 register int new_point
= marker_position (w
->pointm
);
1803 if (new_point
< BEGV
)
1805 else if (new_point
> ZV
)
1811 windows_or_buffers_changed
++;
1815 DEFUN ("display-buffer", Fdisplay_buffer
, Sdisplay_buffer
, 1, 2,
1816 "BDisplay buffer: \nP",
1817 "Make BUFFER appear in some window but don't select it.\n\
1818 BUFFER can be a buffer or a buffer name.\n\
1819 If BUFFER is shown already in some window, just use that one,\n\
1820 unless the window is the selected window and the optional second\n\
1821 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
1822 If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
1823 Returns the window displaying BUFFER.")
1824 (buffer
, not_this_window
)
1825 register Lisp_Object buffer
, not_this_window
;
1827 register Lisp_Object window
, tem
;
1829 buffer
= Fget_buffer (buffer
);
1830 CHECK_BUFFER (buffer
, 0);
1832 if (!NILP (Vdisplay_buffer_function
))
1833 return call2 (Vdisplay_buffer_function
, buffer
, not_this_window
);
1835 if (NILP (not_this_window
)
1836 && XBUFFER (XWINDOW (selected_window
)->buffer
) == XBUFFER (buffer
))
1837 return selected_window
;
1840 /* If pop_up_frames,
1841 look for a window showing BUFFER on any visible or iconified frame. */
1842 window
= Fget_buffer_window (buffer
, pop_up_frames
? make_number (0) : Qnil
);
1844 window
= Fget_buffer_window (buffer
, Qnil
);
1847 && (NILP (not_this_window
) || !EQ (window
, selected_window
)))
1850 if (FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (window
)))))
1851 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
1856 /* Certain buffer names get special handling. */
1857 if (! NILP (Vspecial_display_function
))
1859 tem
= Fmember (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1861 return call1 (Vspecial_display_function
, buffer
);
1863 tem
= Fassoc (XBUFFER (buffer
)->name
, Vspecial_display_buffer_names
);
1865 return call2 (Vspecial_display_function
, buffer
, XCONS (tem
)->cdr
);
1867 for (tem
= Vspecial_display_regexps
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
1869 Lisp_Object car
= XCONS (tem
)->car
;
1871 && fast_string_match (car
, XBUFFER (buffer
)->name
) >= 0)
1872 return call1 (Vspecial_display_function
, buffer
);
1873 else if (CONSP (car
)
1874 && STRINGP (XCONS (car
)->car
)
1875 && fast_string_match (XCONS (car
)->car
,
1876 XBUFFER (buffer
)->name
) >= 0)
1877 return call2 (Vspecial_display_function
,
1884 /* If there are no frames open that have more than a minibuffer,
1885 we need to create a new frame. */
1886 if (pop_up_frames
|| last_nonminibuf_frame
== 0)
1888 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1889 Fset_window_buffer (window
, buffer
);
1892 #endif /* MULTI_FRAME */
1896 || FRAME_MINIBUF_ONLY_P (selected_frame
)
1897 /* If the current frame is a special display frame,
1898 don't try to reuse its windows. */
1899 || !NILP (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->dedicated
)
1907 if (FRAME_MINIBUF_ONLY_P (selected_frame
))
1908 XSET (frames
, Lisp_Frame
, last_nonminibuf_frame
);
1910 /* Don't try to create a window if would get an error */
1911 if (split_height_threshold
< window_min_height
<< 1)
1912 split_height_threshold
= window_min_height
<< 1;
1914 /* Note that both Fget_largest_window and Fget_lru_window
1915 ignore minibuffers and dedicated windows.
1916 This means they can return nil. */
1919 /* If the frame we would try to split cannot be split,
1920 try other frames. */
1921 if (FRAME_NO_SPLIT_P (NILP (frames
) ? selected_frame
1922 : last_nonminibuf_frame
))
1924 /* Try visible frames first. */
1925 window
= Fget_largest_window (Qvisible
);
1926 /* If that didn't work, try iconified frames. */
1928 window
= Fget_largest_window (make_number (0));
1930 window
= Fget_largest_window (Qt
);
1934 window
= Fget_largest_window (frames
);
1936 /* If we got a tall enough full-width window, split it. */
1938 && window_height (window
) >= split_height_threshold
1939 && (XFASTINT (XWINDOW (window
)->width
)
1940 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window
))))))
1941 window
= Fsplit_window (window
, Qnil
, Qnil
);
1944 window
= Fget_lru_window (frames
);
1945 /* If the LRU window is selected, and big enough, split it. */
1947 && (EQ (window
, selected_window
)
1948 || EQ (XWINDOW (window
)->parent
, Qnil
))
1949 && window_height (window
) >= window_min_height
<< 1)
1950 window
= Fsplit_window (window
, Qnil
, Qnil
);
1952 /* If Fget_lru_window returned nil, try other approaches. */
1953 /* Try visible frames first. */
1955 window
= Fget_largest_window (Qvisible
);
1956 /* If that didn't work, try iconified frames. */
1958 window
= Fget_largest_window (make_number (0));
1959 /* Try invisible frames. */
1961 window
= Fget_largest_window (Qt
);
1962 /* As a last resort, make a new frame. */
1964 window
= Fframe_selected_window (call0 (Vpop_up_frame_function
));
1966 /* As a last resort, use a non minibuffer window. */
1968 window
= Fframe_first_window (Fselected_frame ());
1973 window
= Fget_lru_window (Qnil
);
1975 Fset_window_buffer (window
, buffer
);
1980 temp_output_buffer_show (buf
)
1981 register Lisp_Object buf
;
1983 register struct buffer
*old
= current_buffer
;
1984 register Lisp_Object window
;
1985 register struct window
*w
;
1988 XBUFFER (buf
)->save_modified
= MODIFF
;
1993 set_buffer_internal (old
);
1995 if (!EQ (Vtemp_buffer_show_function
, Qnil
))
1996 call1 (Vtemp_buffer_show_function
, buf
);
1999 window
= Fdisplay_buffer (buf
, Qnil
);
2002 if (XFRAME (XWINDOW (window
)->frame
) != selected_frame
)
2003 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window
)));
2004 #endif /* MULTI_FRAME */
2005 Vminibuf_scroll_window
= window
;
2006 w
= XWINDOW (window
);
2007 XFASTINT (w
->hscroll
) = 0;
2008 set_marker_restricted (w
->start
, make_number (1), buf
);
2009 set_marker_restricted (w
->pointm
, make_number (1), buf
);
2014 make_dummy_parent (window
)
2017 register Lisp_Object old
, new;
2018 register struct window
*o
, *p
;
2021 XSETTYPE (old
, Lisp_Vector
);
2022 new = Fcopy_sequence (old
);
2023 XSETTYPE (new, Lisp_Window
);
2027 XFASTINT (p
->sequence_number
) = ++sequence_number
;
2029 /* Put new into window structure in place of window */
2030 replace_window (window
, new);
2043 DEFUN ("split-window", Fsplit_window
, Ssplit_window
, 0, 3, "",
2044 "Split WINDOW, putting SIZE lines in the first of the pair.\n\
2045 WINDOW defaults to selected one and SIZE to half its size.\n\
2046 If optional third arg HOR-FLAG is non-nil, split side by side\n\
2047 and put SIZE columns in the first of the pair.")
2048 (window
, chsize
, horflag
)
2049 Lisp_Object window
, chsize
, horflag
;
2051 register Lisp_Object
new;
2052 register struct window
*o
, *p
;
2056 window
= selected_window
;
2058 CHECK_LIVE_WINDOW (window
, 0);
2060 o
= XWINDOW (window
);
2064 if (!NILP (horflag
))
2065 /* Round odd size up, since this is for the left-hand window,
2066 and it will lose a column for the separators. */
2067 size
= ((XFASTINT (o
->width
) + 1) & -2) >> 1;
2069 size
= XFASTINT (o
->height
) >> 1;
2073 CHECK_NUMBER (chsize
, 1);
2074 size
= XINT (chsize
);
2077 if (MINI_WINDOW_P (o
))
2078 error ("Attempt to split minibuffer window");
2079 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o
))))
2080 error ("Attempt to split unsplittable frame");
2082 check_min_window_sizes ();
2086 if (size
< window_min_height
2087 || size
+ window_min_height
> XFASTINT (o
->height
))
2088 args_out_of_range_3 (window
, chsize
, horflag
);
2089 if (NILP (o
->parent
)
2090 || NILP (XWINDOW (o
->parent
)->vchild
))
2092 make_dummy_parent (window
);
2094 XWINDOW (new)->vchild
= window
;
2099 if (size
< window_min_width
2100 || size
+ window_min_width
> XFASTINT (o
->width
))
2101 args_out_of_range_3 (window
, chsize
, horflag
);
2102 if (NILP (o
->parent
)
2103 || NILP (XWINDOW (o
->parent
)->hchild
))
2105 make_dummy_parent (window
);
2107 XWINDOW (new)->hchild
= window
;
2111 /* Now we know that window's parent is a vertical combination
2112 if we are dividing vertically, or a horizontal combination
2113 if we are making side-by-side windows */
2115 windows_or_buffers_changed
++;
2116 new = make_window ();
2119 p
->frame
= o
->frame
;
2121 if (!NILP (p
->next
))
2122 XWINDOW (p
->next
)->prev
= new;
2125 p
->parent
= o
->parent
;
2128 Fset_window_buffer (new, o
->buffer
);
2130 /* Apportion the available frame space among the two new windows */
2132 if (!NILP (horflag
))
2134 p
->height
= o
->height
;
2136 XFASTINT (p
->width
) = XFASTINT (o
->width
) - size
;
2137 XFASTINT (o
->width
) = size
;
2138 XFASTINT (p
->left
) = XFASTINT (o
->left
) + size
;
2143 p
->width
= o
->width
;
2144 XFASTINT (p
->height
) = XFASTINT (o
->height
) - size
;
2145 XFASTINT (o
->height
) = size
;
2146 XFASTINT (p
->top
) = XFASTINT (o
->top
) + size
;
2152 DEFUN ("enlarge-window", Fenlarge_window
, Senlarge_window
, 1, 2, "p",
2153 "Make current window ARG lines bigger.\n\
2154 From program, optional second arg non-nil means grow sideways ARG columns.")
2156 register Lisp_Object n
, side
;
2158 CHECK_NUMBER (n
, 0);
2159 change_window_height (XINT (n
), !NILP (side
));
2163 DEFUN ("shrink-window", Fshrink_window
, Sshrink_window
, 1, 2, "p",
2164 "Make current window ARG lines smaller.\n\
2165 From program, optional second arg non-nil means shrink sideways ARG columns.")
2167 register Lisp_Object n
, side
;
2169 CHECK_NUMBER (n
, 0);
2170 change_window_height (-XINT (n
), !NILP (side
));
2175 window_height (window
)
2178 register struct window
*p
= XWINDOW (window
);
2179 return XFASTINT (p
->height
);
2183 window_width (window
)
2186 register struct window
*p
= XWINDOW (window
);
2187 return XFASTINT (p
->width
);
2190 #define MINSIZE(w) \
2192 ? window_min_width \
2193 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height))
2196 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top))
2198 #define CURSIZE(w) \
2199 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height))
2201 /* Unlike set_window_height, this function
2202 also changes the heights of the siblings so as to
2203 keep everything consistent. */
2205 change_window_height (delta
, widthflag
)
2209 register Lisp_Object parent
;
2211 register struct window
*p
;
2213 int (*sizefun
) () = widthflag
? window_width
: window_height
;
2214 register int (*setsizefun
) () = (widthflag
2216 : set_window_height
);
2218 check_min_window_sizes ();
2220 window
= selected_window
;
2223 p
= XWINDOW (window
);
2228 error ("No other window to side of this one");
2231 if (widthflag
? !NILP (XWINDOW (parent
)->hchild
)
2232 : !NILP (XWINDOW (parent
)->vchild
))
2237 sizep
= &CURSIZE (window
);
2240 register int maxdelta
;
2242 maxdelta
= (!NILP (parent
) ? (*sizefun
) (parent
) - *sizep
2243 : !NILP (p
->next
) ? (*sizefun
) (p
->next
) - MINSIZE (p
->next
)
2244 : !NILP (p
->prev
) ? (*sizefun
) (p
->prev
) - MINSIZE (p
->prev
)
2245 /* This is a frame with only one window, a minibuffer-only
2246 or a minibufferless frame. */
2249 if (delta
> maxdelta
)
2250 /* This case traps trying to make the minibuffer
2251 the full frame, or make the only window aside from the
2252 minibuffer the full frame. */
2256 if (*sizep
+ delta
< MINSIZE (window
))
2258 Fdelete_window (window
);
2266 && (*sizefun
) (p
->next
) - delta
>= MINSIZE (p
->next
))
2268 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
) - delta
, 0);
2269 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2270 CURBEG (p
->next
) += delta
;
2271 /* This does not change size of p->next,
2272 but it propagates the new top edge to its children */
2273 (*setsizefun
) (p
->next
, (*sizefun
) (p
->next
), 0);
2275 else if (!NILP (p
->prev
)
2276 && (*sizefun
) (p
->prev
) - delta
>= MINSIZE (p
->prev
))
2278 (*setsizefun
) (p
->prev
, (*sizefun
) (p
->prev
) - delta
, 0);
2279 CURBEG (window
) -= delta
;
2280 (*setsizefun
) (window
, *sizep
+ delta
, 0);
2284 register int delta1
;
2285 register int opht
= (*sizefun
) (parent
);
2287 /* If trying to grow this window to or beyond size of the parent,
2288 make delta1 so big that, on shrinking back down,
2289 all the siblings end up with less than one line and are deleted. */
2290 if (opht
<= *sizep
+ delta
)
2291 delta1
= opht
* opht
* 2;
2292 /* Otherwise, make delta1 just right so that if we add delta1
2293 lines to this window and to the parent, and then shrink
2294 the parent back to its original size, the new proportional
2295 size of this window will increase by delta. */
2297 delta1
= (delta
* opht
* 100) / ((opht
- *sizep
- delta
) * 100);
2299 /* Add delta1 lines or columns to this window, and to the parent,
2300 keeping things consistent while not affecting siblings. */
2301 CURSIZE (parent
) = opht
+ delta1
;
2302 (*setsizefun
) (window
, *sizep
+ delta1
, 0);
2304 /* Squeeze out delta1 lines or columns from our parent,
2305 shriking this window and siblings proportionately.
2306 This brings parent back to correct size.
2307 Delta1 was calculated so this makes this window the desired size,
2308 taking it all out of the siblings. */
2309 (*setsizefun
) (parent
, opht
, 0);
2312 XFASTINT (p
->last_modified
) = 0;
2319 /* Return number of lines of text (not counting mode line) in W. */
2322 window_internal_height (w
)
2325 int ht
= XFASTINT (w
->height
);
2327 if (MINI_WINDOW_P (w
))
2330 if (!NILP (w
->parent
) || !NILP (w
->vchild
) || !NILP (w
->hchild
)
2331 || !NILP (w
->next
) || !NILP (w
->prev
)
2332 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w
))))
2339 /* Return the number of columns in W.
2340 Don't count columns occupied by scroll bars or the vertical bar
2341 separating W from the sibling to its right. */
2343 window_internal_width (w
)
2346 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2347 int left
= XINT (w
->left
);
2348 int width
= XINT (w
->width
);
2350 /* If this window is flush against the right edge of the frame, its
2351 internal width is its full width. */
2352 if (left
+ width
>= FRAME_WIDTH (f
))
2355 /* If we are not flush right, then our rightmost columns are
2356 occupied by some sort of separator. */
2358 /* Scroll bars occupy a few columns. */
2359 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2360 return width
- FRAME_SCROLL_BAR_COLS (f
);
2362 /* The column of `|' characters separating side-by-side windows
2363 occupies one column only. */
2368 /* Scroll contents of window WINDOW up N lines. */
2371 window_scroll (window
, n
, noerror
)
2376 register struct window
*w
= XWINDOW (window
);
2377 register int opoint
= PT
;
2379 register int ht
= window_internal_height (w
);
2380 register Lisp_Object tem
;
2382 Lisp_Object bolp
, nmoved
;
2384 XFASTINT (tem
) = PT
;
2385 tem
= Fpos_visible_in_window_p (tem
, window
);
2389 Fvertical_motion (make_number (- (ht
/ 2)), window
);
2390 XFASTINT (tem
) = PT
;
2391 Fset_marker (w
->start
, tem
, w
->buffer
);
2392 w
->force_start
= Qt
;
2395 SET_PT (marker_position (w
->start
));
2396 lose
= n
< 0 && PT
== BEGV
;
2397 Fvertical_motion (make_number (n
), window
);
2407 Fsignal (Qbeginning_of_buffer
, Qnil
);
2412 set_marker_restricted (w
->start
, make_number (pos
), w
->buffer
);
2413 w
->start_at_line_beg
= bolp
;
2414 w
->update_mode_line
= Qt
;
2415 XFASTINT (w
->last_modified
) = 0;
2421 tem
= Fvertical_motion (make_number (ht
), window
);
2422 if (PT
> opoint
|| XFASTINT (tem
) < ht
)
2425 Fvertical_motion (make_number (-1), window
);
2433 Fsignal (Qend_of_buffer
, Qnil
);
2437 /* This is the guts of Fscroll_up and Fscroll_down. */
2440 scroll_command (n
, direction
)
2441 register Lisp_Object n
;
2444 register int defalt
;
2445 int count
= specpdl_ptr
- specpdl
;
2447 /* If selected window's buffer isn't current, make it current for the moment.
2448 But don't screw up if window_scroll gets an error. */
2449 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
2451 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2452 Fset_buffer (XWINDOW (selected_window
)->buffer
);
2455 defalt
= (window_internal_height (XWINDOW (selected_window
))
2456 - next_screen_context_lines
);
2457 defalt
= direction
* (defalt
< 1 ? 1 : defalt
);
2460 window_scroll (selected_window
, defalt
, 0);
2461 else if (EQ (n
, Qminus
))
2462 window_scroll (selected_window
, - defalt
, 0);
2465 n
= Fprefix_numeric_value (n
);
2466 window_scroll (selected_window
, XINT (n
) * direction
, 0);
2469 unbind_to (count
, Qnil
);
2472 DEFUN ("scroll-up", Fscroll_up
, Sscroll_up
, 0, 1, "P",
2473 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
2474 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2475 Negative ARG means scroll downward.\n\
2476 When calling from a program, supply a number as argument or nil.")
2480 scroll_command (n
, 1);
2484 DEFUN ("scroll-down", Fscroll_down
, Sscroll_down
, 0, 1, "P",
2485 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\
2486 A near full screen is `next-screen-context-lines' less than a full screen.\n\
2487 Negative ARG means scroll upward.\n\
2488 When calling from a program, supply a number as argument or nil.")
2492 scroll_command (n
, -1);
2496 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling
, Sother_window_for_scrolling
, 0, 0, 0,
2497 "Return the other window for \"other window scroll\" commands.\n\
2498 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2499 specifies the window.\n\
2500 If `other-window-scroll-buffer' is non-nil, a window\n\
2501 showing that buffer is used.")
2506 if (MINI_WINDOW_P (XWINDOW (selected_window
))
2507 && !NILP (Vminibuf_scroll_window
))
2508 window
= Vminibuf_scroll_window
;
2509 /* If buffer is specified, scroll that buffer. */
2510 else if (!NILP (Vother_window_scroll_buffer
))
2512 window
= Fget_buffer_window (Vother_window_scroll_buffer
, Qnil
);
2514 window
= Fdisplay_buffer (Vother_window_scroll_buffer
, Qt
);
2518 /* Nothing specified; look for a neighboring window on the same
2520 window
= Fnext_window (selected_window
, Qnil
, Qnil
);
2522 if (EQ (window
, selected_window
))
2523 /* That didn't get us anywhere; look for a window on another
2526 window
= Fnext_window (window
, Qnil
, Qt
);
2527 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window
))))
2528 && ! EQ (window
, selected_window
));
2531 CHECK_LIVE_WINDOW (window
, 0);
2533 if (EQ (window
, selected_window
))
2534 error ("There is no other window");
2539 DEFUN ("scroll-other-window", Fscroll_other_window
, Sscroll_other_window
, 0, 1, "P",
2540 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
2541 The next window is the one below the current one; or the one at the top\n\
2542 if the current one is at the bottom. Negative ARG means scroll downward.\n\
2543 When calling from a program, supply a number as argument or nil.\n\
2545 If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
2546 specifies the window to scroll.\n\
2547 If `other-window-scroll-buffer' is non-nil, scroll the window\n\
2548 showing that buffer, popping the buffer up if necessary.")
2550 register Lisp_Object n
;
2552 register Lisp_Object window
;
2554 register struct window
*w
;
2555 register int count
= specpdl_ptr
- specpdl
;
2557 window
= Fother_window_for_scrolling ();
2559 w
= XWINDOW (window
);
2560 ht
= window_internal_height (w
);
2562 /* Don't screw up if window_scroll gets an error. */
2563 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2565 Fset_buffer (w
->buffer
);
2566 SET_PT (marker_position (w
->pointm
));
2569 window_scroll (window
, ht
- next_screen_context_lines
, 1);
2570 else if (EQ (n
, Qminus
))
2571 window_scroll (window
, next_screen_context_lines
- ht
, 1);
2576 CHECK_NUMBER (n
, 0);
2577 window_scroll (window
, XINT (n
), 1);
2580 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
2581 unbind_to (count
, Qnil
);
2586 DEFUN ("scroll-left", Fscroll_left
, Sscroll_left
, 0, 1, "P",
2587 "Scroll selected window display ARG columns left.\n\
2588 Default for ARG is window width minus 2.")
2590 register Lisp_Object arg
;
2594 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2596 arg
= Fprefix_numeric_value (arg
);
2599 Fset_window_hscroll (selected_window
,
2600 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2604 DEFUN ("scroll-right", Fscroll_right
, Sscroll_right
, 0, 1, "P",
2605 "Scroll selected window display ARG columns right.\n\
2606 Default for ARG is window width minus 2.")
2608 register Lisp_Object arg
;
2611 XFASTINT (arg
) = window_internal_width (XWINDOW (selected_window
)) - 2;
2613 arg
= Fprefix_numeric_value (arg
);
2616 Fset_window_hscroll (selected_window
,
2617 make_number (XINT (XWINDOW (selected_window
)->hscroll
)
2621 DEFUN ("recenter", Frecenter
, Srecenter
, 0, 1, "P",
2622 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\
2623 The desired position of point is always relative to the current window.\n\
2624 Just C-u as prefix means put point in the center of the window.\n\
2625 No arg (i.e., it is nil) erases the entire frame and then\n\
2626 redraws with point in the center of the current window.")
2628 register Lisp_Object n
;
2630 register struct window
*w
= XWINDOW (selected_window
);
2631 register int ht
= window_internal_height (w
);
2632 struct position pos
;
2637 extern int frame_garbaged
;
2639 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w
)));
2640 XFASTINT (n
) = ht
/ 2;
2642 else if (CONSP (n
)) /* Just C-u. */
2644 XFASTINT (n
) = ht
/ 2;
2648 n
= Fprefix_numeric_value (n
);
2649 CHECK_NUMBER (n
, 0);
2653 XSETINT (n
, XINT (n
) + ht
);
2655 XSET (window
, Lisp_Window
, w
);
2656 pos
= *vmotion (point
, - XINT (n
), window_internal_width (w
) - 1,
2657 XINT (w
->hscroll
), window
);
2659 Fset_marker (w
->start
, make_number (pos
.bufpos
), w
->buffer
);
2660 w
->start_at_line_beg
= ((pos
.bufpos
== BEGV
2661 || FETCH_CHAR (pos
.bufpos
- 1) == '\n')
2663 w
->force_start
= Qt
;
2668 DEFUN ("move-to-window-line", Fmove_to_window_line
, Smove_to_window_line
,
2670 "Position point relative to window.\n\
2671 With no argument, position point at center of window.\n\
2672 An argument specifies frame line; zero means top of window,\n\
2673 negative means relative to bottom of window.")
2675 register Lisp_Object arg
;
2677 register struct window
*w
= XWINDOW (selected_window
);
2678 register int height
= window_internal_height (w
);
2683 XFASTINT (arg
) = height
/ 2;
2686 arg
= Fprefix_numeric_value (arg
);
2688 XSETINT (arg
, XINT (arg
) + height
);
2691 start
= marker_position (w
->start
);
2692 XSET (window
, Lisp_Window
, w
);
2693 if (start
< BEGV
|| start
> ZV
)
2695 Fvertical_motion (make_number (- (height
/ 2)), window
);
2696 Fset_marker (w
->start
, make_number (PT
), w
->buffer
);
2697 w
->start_at_line_beg
= Fbolp ();
2698 w
->force_start
= Qt
;
2703 return Fvertical_motion (arg
, window
);
2706 struct save_window_data
2708 int size_from_Lisp_Vector_struct
;
2709 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2710 Lisp_Object frame_width
, frame_height
, frame_menu_bar_lines
;
2711 Lisp_Object selected_frame
;
2712 Lisp_Object current_window
;
2713 Lisp_Object current_buffer
;
2714 Lisp_Object minibuf_scroll_window
;
2715 Lisp_Object root_window
;
2716 Lisp_Object focus_frame
;
2717 /* Record the values of window-min-width and window-min-height
2718 so that window sizes remain consistent with them. */
2719 Lisp_Object min_width
, min_height
;
2720 /* A vector, interpreted as a struct saved_window */
2721 Lisp_Object saved_windows
;
2724 /* Arg to Fmake_vector */
2725 #define SAVE_WINDOW_DATA_SIZE \
2726 ((sizeof (struct save_window_data) \
2727 - (sizeof (struct Lisp_Vector) \
2728 /* Don't count the contents member of the struct Lisp_Vector */ \
2729 - sizeof (Lisp_Object))) \
2730 / sizeof (Lisp_Object))
2732 /* This is saved as a Lisp_Vector */
2735 /* these first two must agree with struct Lisp_Vector in lisp.h */
2736 int size_from_Lisp_Vector_struct
;
2737 struct Lisp_Vector
*next_from_Lisp_Vector_struct
;
2740 Lisp_Object buffer
, start
, pointm
, mark
;
2741 Lisp_Object left
, top
, width
, height
, hscroll
;
2742 Lisp_Object parent
, prev
;
2743 Lisp_Object start_at_line_beg
;
2744 Lisp_Object display_table
;
2746 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
2748 #define SAVED_WINDOW_N(swv,n) \
2749 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
2751 DEFUN ("window-configuration-p", Fwindow_configuration_p
, Swindow_configuration_p
, 1, 1, 0,
2752 "T if OBJECT is a window-configration object.")
2756 if (WINDOW_CONFIGURATIONP (obj
))
2762 DEFUN ("set-window-configuration", Fset_window_configuration
,
2763 Sset_window_configuration
, 1, 1, 0,
2764 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
2765 CONFIGURATION must be a value previously returned\n\
2766 by `current-window-configuration' (which see).")
2768 Lisp_Object configuration
;
2770 register struct save_window_data
*data
;
2771 struct Lisp_Vector
*saved_windows
;
2772 Lisp_Object new_current_buffer
;
2776 while (!WINDOW_CONFIGURATIONP (configuration
))
2778 configuration
= wrong_type_argument (intern ("window-configuration-p"),
2782 data
= (struct save_window_data
*) XVECTOR (configuration
);
2783 saved_windows
= XVECTOR (data
->saved_windows
);
2785 new_current_buffer
= data
->current_buffer
;
2786 if (NILP (XBUFFER (new_current_buffer
)->name
))
2787 new_current_buffer
= Qnil
;
2789 frame
= XWINDOW (SAVED_WINDOW_N (saved_windows
, 0)->window
)->frame
;
2792 /* If f is a dead frame, don't bother rebuilding its window tree.
2793 However, there is other stuff we should still try to do below. */
2794 if (FRAME_LIVE_P (f
))
2796 register struct window
*w
;
2797 register struct saved_window
*p
;
2800 /* If the frame has been resized since this window configuration was
2801 made, we change the frame to the size specified in the
2802 configuration, restore the configuration, and then resize it
2803 back. We keep track of the prevailing height in these variables. */
2804 int previous_frame_height
= FRAME_HEIGHT (f
);
2805 int previous_frame_width
= FRAME_WIDTH (f
);
2806 int previous_frame_menu_bar_lines
= FRAME_MENU_BAR_LINES (f
);
2808 if (XFASTINT (data
->frame_height
) != previous_frame_height
2809 || XFASTINT (data
->frame_width
) != previous_frame_width
)
2810 change_frame_size (f
, data
->frame_height
, data
->frame_width
, 0, 0);
2811 #ifdef HAVE_X_WINDOWS
2812 if (XFASTINT (data
->frame_menu_bar_lines
)
2813 != previous_frame_menu_bar_lines
)
2814 x_set_menu_bar_lines (f
, data
->frame_menu_bar_lines
, 0);
2817 windows_or_buffers_changed
++;
2819 /* Temporarily avoid any problems with windows that are smaller
2820 than they are supposed to be. */
2821 window_min_height
= 1;
2822 window_min_width
= 1;
2825 Mark all windows now on frame as "deleted".
2826 Restoring the new configuration "undeletes" any that are in it.
2828 Save their current buffers in their height fields, since we may
2829 need it later, if a buffer saved in the configuration is now
2831 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2833 for (k
= 0; k
< saved_windows
->size
; k
++)
2835 p
= SAVED_WINDOW_N (saved_windows
, k
);
2836 w
= XWINDOW (p
->window
);
2839 if (!NILP (p
->parent
))
2840 w
->parent
= SAVED_WINDOW_N (saved_windows
,
2841 XFASTINT (p
->parent
))->window
;
2845 if (!NILP (p
->prev
))
2847 w
->prev
= SAVED_WINDOW_N (saved_windows
,
2848 XFASTINT (p
->prev
))->window
;
2849 XWINDOW (w
->prev
)->next
= p
->window
;
2854 if (!NILP (w
->parent
))
2856 if (EQ (p
->width
, XWINDOW (w
->parent
)->width
))
2858 XWINDOW (w
->parent
)->vchild
= p
->window
;
2859 XWINDOW (w
->parent
)->hchild
= Qnil
;
2863 XWINDOW (w
->parent
)->hchild
= p
->window
;
2864 XWINDOW (w
->parent
)->vchild
= Qnil
;
2869 /* If we squirreled away the buffer in the window's height,
2871 if (BUFFERP (w
->height
))
2872 w
->buffer
= w
->height
;
2875 w
->width
= p
->width
;
2876 w
->height
= p
->height
;
2877 w
->hscroll
= p
->hscroll
;
2878 w
->display_table
= p
->display_table
;
2879 XFASTINT (w
->last_modified
) = 0;
2881 /* Reinstall the saved buffer and pointers into it. */
2882 if (NILP (p
->buffer
))
2883 w
->buffer
= p
->buffer
;
2886 if (!NILP (XBUFFER (p
->buffer
)->name
))
2887 /* If saved buffer is alive, install it. */
2889 w
->buffer
= p
->buffer
;
2890 w
->start_at_line_beg
= p
->start_at_line_beg
;
2891 set_marker_restricted (w
->start
,
2892 Fmarker_position (p
->start
),
2894 set_marker_restricted (w
->pointm
,
2895 Fmarker_position (p
->pointm
),
2897 Fset_marker (XBUFFER (w
->buffer
)->mark
,
2898 Fmarker_position (p
->mark
), w
->buffer
);
2900 /* As documented in Fcurrent_window_configuration, don't
2901 save the location of point in the buffer which was current
2902 when the window configuration was recorded. */
2903 if (!EQ (p
->buffer
, new_current_buffer
)
2904 && XBUFFER (p
->buffer
) == current_buffer
)
2905 Fgoto_char (w
->pointm
);
2907 else if (NILP (w
->buffer
) || NILP (XBUFFER (w
->buffer
)->name
))
2908 /* Else unless window has a live buffer, get one. */
2910 w
->buffer
= Fcdr (Fcar (Vbuffer_alist
));
2911 /* This will set the markers to beginning of visible
2913 set_marker_restricted (w
->start
, make_number (0), w
->buffer
);
2914 set_marker_restricted (w
->pointm
, make_number (0),w
->buffer
);
2915 w
->start_at_line_beg
= Qt
;
2918 /* Keeping window's old buffer; make sure the markers
2921 /* Set window markers at start of visible range. */
2922 if (XMARKER (w
->start
)->buffer
== 0)
2923 set_marker_restricted (w
->start
, make_number (0),
2925 if (XMARKER (w
->pointm
)->buffer
== 0)
2926 set_marker_restricted (w
->pointm
,
2928 (BUF_PT (XBUFFER (w
->buffer
)))),
2930 w
->start_at_line_beg
= Qt
;
2935 FRAME_ROOT_WINDOW (f
) = data
->root_window
;
2936 Fselect_window (data
->current_window
);
2939 if (NILP (data
->focus_frame
)
2940 || (FRAMEP (data
->focus_frame
)
2941 && FRAME_LIVE_P (XFRAME (data
->focus_frame
))))
2942 Fredirect_frame_focus (frame
, data
->focus_frame
);
2945 #if 0 /* I don't understand why this is needed, and it causes problems
2946 when the frame's old selected window has been deleted. */
2948 if (f
!= selected_frame
&& ! FRAME_TERMCAP_P (f
))
2949 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data
->root_window
)), Qnil
);
2953 /* Set the screen height to the value it had before this function. */
2954 if (previous_frame_height
!= FRAME_HEIGHT (f
)
2955 || previous_frame_width
!= FRAME_WIDTH (f
))
2956 change_frame_size (f
, previous_frame_height
, previous_frame_width
,
2958 #ifdef HAVE_X_WINDOWS
2959 if (previous_frame_menu_bar_lines
!= FRAME_MENU_BAR_LINES (f
))
2960 x_set_menu_bar_lines (f
, previous_frame_menu_bar_lines
, 0);
2964 /* Restore the minimum heights recorded in the configuration. */
2965 window_min_height
= XINT (data
->min_height
);
2966 window_min_width
= XINT (data
->min_width
);
2969 /* Fselect_window will have made f the selected frame, so we
2970 reselect the proper frame here. Fhandle_switch_frame will change the
2971 selected window too, but that doesn't make the call to
2972 Fselect_window above totally superfluous; it still sets f's
2974 if (FRAME_LIVE_P (XFRAME (data
->selected_frame
)))
2975 Fhandle_switch_frame (data
->selected_frame
, Qnil
);
2978 if (!NILP (new_current_buffer
))
2979 Fset_buffer (new_current_buffer
);
2981 Vminibuf_scroll_window
= data
->minibuf_scroll_window
;
2985 /* Mark all windows now on frame as deleted
2986 by setting their buffers to nil. */
2989 delete_all_subwindows (w
)
2990 register struct window
*w
;
2992 if (!NILP (w
->next
))
2993 delete_all_subwindows (XWINDOW (w
->next
));
2994 if (!NILP (w
->vchild
))
2995 delete_all_subwindows (XWINDOW (w
->vchild
));
2996 if (!NILP (w
->hchild
))
2997 delete_all_subwindows (XWINDOW (w
->hchild
));
2999 w
->height
= w
->buffer
; /* See Fset_window_configuration for excuse. */
3001 /* We set all three of these fields to nil, to make sure that we can
3002 distinguish this dead window from any live window. Live leaf
3003 windows will have buffer set, and combination windows will have
3004 vchild or hchild set. */
3011 count_windows (window
)
3012 register struct window
*window
;
3014 register int count
= 1;
3015 if (!NILP (window
->next
))
3016 count
+= count_windows (XWINDOW (window
->next
));
3017 if (!NILP (window
->vchild
))
3018 count
+= count_windows (XWINDOW (window
->vchild
));
3019 if (!NILP (window
->hchild
))
3020 count
+= count_windows (XWINDOW (window
->hchild
));
3025 save_window_save (window
, vector
, i
)
3027 struct Lisp_Vector
*vector
;
3030 register struct saved_window
*p
;
3031 register struct window
*w
;
3032 register Lisp_Object tem
;
3034 for (;!NILP (window
); window
= w
->next
)
3036 p
= SAVED_WINDOW_N (vector
, i
);
3037 w
= XWINDOW (window
);
3039 XFASTINT (w
->temslot
) = i
++;
3041 p
->buffer
= w
->buffer
;
3044 p
->width
= w
->width
;
3045 p
->height
= w
->height
;
3046 p
->hscroll
= w
->hscroll
;
3047 p
->display_table
= w
->display_table
;
3048 if (!NILP (w
->buffer
))
3050 /* Save w's value of point in the window configuration.
3051 If w is the selected window, then get the value of point
3052 from the buffer; pointm is garbage in the selected window. */
3053 if (EQ (window
, selected_window
))
3055 p
->pointm
= Fmake_marker ();
3056 Fset_marker (p
->pointm
, BUF_PT (XBUFFER (w
->buffer
)),
3060 p
->pointm
= Fcopy_marker (w
->pointm
);
3062 p
->start
= Fcopy_marker (w
->start
);
3063 p
->start_at_line_beg
= w
->start_at_line_beg
;
3065 tem
= XBUFFER (w
->buffer
)->mark
;
3066 p
->mark
= Fcopy_marker (tem
);
3073 p
->start_at_line_beg
= Qnil
;
3076 if (NILP (w
->parent
))
3079 p
->parent
= XWINDOW (w
->parent
)->temslot
;
3084 p
->prev
= XWINDOW (w
->prev
)->temslot
;
3086 if (!NILP (w
->vchild
))
3087 i
= save_window_save (w
->vchild
, vector
, i
);
3088 if (!NILP (w
->hchild
))
3089 i
= save_window_save (w
->hchild
, vector
, i
);
3095 DEFUN ("current-window-configuration",
3096 Fcurrent_window_configuration
, Scurrent_window_configuration
, 0, 1, 0,
3097 "Return an object representing the current window configuration of FRAME.\n\
3098 If FRAME is nil or omitted, use the selected frame.\n\
3099 This describes the number of windows, their sizes and current buffers,\n\
3100 and for each displayed buffer, where display starts, and the positions of\n\
3101 point and mark. An exception is made for point in the current buffer:\n\
3102 its value is -not- saved.\n\
3103 This also records the currently selected frame, and FRAME's focus\n\
3104 redirection (see `redirect-frame-focus').")
3108 register Lisp_Object tem
;
3109 register int n_windows
;
3110 register struct save_window_data
*data
;
3118 CHECK_LIVE_FRAME (frame
, 0);
3122 n_windows
= count_windows (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3123 data
= (struct save_window_data
*)
3124 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE
),
3126 XFASTINT (data
->frame_width
) = FRAME_WIDTH (f
);
3127 XFASTINT (data
->frame_height
) = FRAME_HEIGHT (f
);
3128 XFASTINT (data
->frame_menu_bar_lines
) = FRAME_MENU_BAR_LINES (f
);
3130 XSET (data
->selected_frame
, Lisp_Frame
, selected_frame
);
3132 data
->current_window
= FRAME_SELECTED_WINDOW (f
);
3133 XSET (data
->current_buffer
, Lisp_Buffer
, current_buffer
);
3134 data
->minibuf_scroll_window
= Vminibuf_scroll_window
;
3135 data
->root_window
= FRAME_ROOT_WINDOW (f
);
3136 data
->focus_frame
= FRAME_FOCUS_FRAME (f
);
3137 XSET (data
->min_height
, Lisp_Int
, window_min_height
);
3138 XSET (data
->min_width
, Lisp_Int
, window_min_width
);
3139 tem
= Fmake_vector (make_number (n_windows
), Qnil
);
3140 data
->saved_windows
= tem
;
3141 for (i
= 0; i
< n_windows
; i
++)
3142 XVECTOR (tem
)->contents
[i
]
3143 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE
), Qnil
);
3144 save_window_save (FRAME_ROOT_WINDOW (f
),
3146 XSET (tem
, Lisp_Window_Configuration
, data
);
3150 DEFUN ("save-window-excursion", Fsave_window_excursion
, Ssave_window_excursion
,
3152 "Execute body, preserving window sizes and contents.\n\
3153 Restore which buffer appears in which window, where display starts,\n\
3154 and the value of point and mark for each window.\n\
3155 Also restore which buffer is current.\n\
3156 But do not preserve point in the current buffer.\n\
3157 Does not restore the value of point in current buffer.")
3161 register Lisp_Object val
;
3162 register int count
= specpdl_ptr
- specpdl
;
3164 record_unwind_protect (Fset_window_configuration
,
3165 Fcurrent_window_configuration (Qnil
));
3166 val
= Fprogn (args
);
3167 return unbind_to (count
, val
);
3173 selected_frame
= make_terminal_frame ();
3174 minibuf_window
= selected_frame
->minibuffer_window
;
3175 selected_window
= selected_frame
->selected_window
;
3176 last_nonminibuf_frame
= selected_frame
;
3177 #else /* not MULTI_FRAME */
3178 extern Lisp_Object
get_minibuffer ();
3180 minibuf_window
= make_window ();
3181 FRAME_ROOT_WINDOW (selected_frame
) = make_window ();
3183 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->next
= minibuf_window
;
3184 XWINDOW (minibuf_window
)->prev
= FRAME_ROOT_WINDOW (selected_frame
);
3185 XWINDOW (minibuf_window
)->mini_p
= Qt
;
3187 /* These values 9 and 10 are arbitrary,
3188 just so that there is "something there."
3189 Correct values are put in in init_xdisp */
3191 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->width
) = 10;
3192 XFASTINT (XWINDOW (minibuf_window
)->width
) = 10;
3194 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->height
) = 9;
3195 XFASTINT (XWINDOW (minibuf_window
)->top
) = 9;
3196 XFASTINT (XWINDOW (minibuf_window
)->height
) = 1;
3198 /* Prevent error in Fset_window_buffer. */
3199 XWINDOW (FRAME_ROOT_WINDOW (selected_frame
))->buffer
= Qt
;
3200 XWINDOW (minibuf_window
)->buffer
= Qt
;
3202 /* Now set them up for real. */
3203 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame
),
3204 Fcurrent_buffer ());
3205 Fset_window_buffer (minibuf_window
, get_minibuffer (0));
3207 selected_window
= FRAME_ROOT_WINDOW (selected_frame
);
3208 /* Make sure this window seems more recently used than
3209 a newly-created, never-selected window. Increment
3210 window_select_count so the first selection ever will get
3211 something newer than this. */
3212 XFASTINT (XWINDOW (selected_window
)->use_time
) = ++window_select_count
;
3213 #endif /* not MULTI_FRAME */
3218 Qwindowp
= intern ("windowp");
3219 staticpro (&Qwindowp
);
3221 Qwindow_live_p
= intern ("window-live-p");
3222 staticpro (&Qwindow_live_p
);
3225 /* Make sure all windows get marked */
3226 staticpro (&minibuf_window
);
3229 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function
,
3230 "Non-nil means call as function to display a help buffer.\n\
3231 Used by `with-output-to-temp-buffer'.");
3232 Vtemp_buffer_show_function
= Qnil
;
3234 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function
,
3235 "If non-nil, function to call to handle `display-buffer'.\n\
3236 It will receive two args, the buffer and a flag which if non-nil means\n\
3237 that the currently selected window is not acceptable.\n\
3238 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
3239 work using this function.");
3240 Vdisplay_buffer_function
= Qnil
;
3242 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window
,
3243 "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
3244 Vminibuf_scroll_window
= Qnil
;
3246 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer
,
3247 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
3248 Vother_window_scroll_buffer
= Qnil
;
3250 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames
,
3251 "*Non-nil means `display-buffer' should make a separate frame.");
3254 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function
,
3255 "Function to call to handle automatic new frame creation.\n\
3256 It is called with no arguments and should return a newly created frame.\n\
3258 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
3259 where `pop-up-frame-alist' would hold the default frame parameters.");
3260 Vpop_up_frame_function
= Qnil
;
3262 DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names
,
3263 "*List of buffer names that should have their own special frames.\n\
3264 Displaying a buffer whose name is in this list makes a special frame for it\n\
3265 using `special-display-function'.\n\
3266 Instead of a buffer name, the list entries can be cons cells. In that\n\
3267 case the car should be a buffer name, and the cdr data to be passed as a
3268 second argument to `special-display-function'.\n\
3269 See also `special-display-regexps'.");
3270 Vspecial_display_buffer_names
= Qnil
;
3272 DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps
,
3273 "*List of regexps saying which buffers should have their own special frames.\n\
3274 If a buffer name matches one of these regexps, it gets its own frame.\n\
3275 Displaying a buffer whose name is in this list makes a special frame for it\n\
3276 using `special-display-function'.\n\
3277 Instead of a buffer name, the list entries can be cons cells. In that\n\
3278 case the car should be the regexp, and the cdr data to be passed as a
3279 second argument to `special-display-function'.\n\
3280 See also `special-display-buffer-names'.");
3281 Vspecial_display_regexps
= Qnil
;
3283 DEFVAR_LISP ("special-display-function", &Vspecial_display_function
,
3284 "Function to call to make a new frame for a special buffer.\n\
3285 It is called with two arguments, the buffer and optional buffer specific\n\
3286 data, and should return a window displaying that buffer.\n\
3287 The default value makes a separate frame for the buffer,\n\
3288 using `special-display-frame-alist' to specify the frame parameters.\n\
3290 A buffer is special if its is listed in `special-display-buffer-names'\n\
3291 or matches a regexp in `special-display-regexps'.");
3292 Vspecial_display_function
= Qnil
;
3294 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows
,
3295 "*Non-nil means display-buffer should make new windows.");
3298 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines
,
3299 "*Number of lines of continuity when scrolling by screenfuls.");
3300 next_screen_context_lines
= 2;
3302 DEFVAR_INT ("split-height-threshold", &split_height_threshold
,
3303 "*display-buffer would prefer to split the largest window if this large.\n\
3304 If there is only one window, it is split regardless of this value.");
3305 split_height_threshold
= 500;
3307 DEFVAR_INT ("window-min-height", &window_min_height
,
3308 "*Delete any window less than this tall (including its mode line).");
3309 window_min_height
= 4;
3311 DEFVAR_INT ("window-min-width", &window_min_width
,
3312 "*Delete any window less than this wide.");
3313 window_min_width
= 10;
3315 defsubr (&Sselected_window
);
3316 defsubr (&Sminibuffer_window
);
3317 defsubr (&Swindow_minibuffer_p
);
3318 defsubr (&Swindowp
);
3319 defsubr (&Swindow_live_p
);
3320 defsubr (&Spos_visible_in_window_p
);
3321 defsubr (&Swindow_buffer
);
3322 defsubr (&Swindow_height
);
3323 defsubr (&Swindow_width
);
3324 defsubr (&Swindow_hscroll
);
3325 defsubr (&Sset_window_hscroll
);
3326 defsubr (&Swindow_edges
);
3327 defsubr (&Scoordinates_in_window_p
);
3328 defsubr (&Swindow_at
);
3329 defsubr (&Swindow_point
);
3330 defsubr (&Swindow_start
);
3331 defsubr (&Swindow_end
);
3332 defsubr (&Sset_window_point
);
3333 defsubr (&Sset_window_start
);
3334 defsubr (&Swindow_dedicated_p
);
3335 defsubr (&Sset_window_dedicated_p
);
3336 defsubr (&Swindow_display_table
);
3337 defsubr (&Sset_window_display_table
);
3338 defsubr (&Snext_window
);
3339 defsubr (&Sprevious_window
);
3340 defsubr (&Sother_window
);
3341 defsubr (&Sget_lru_window
);
3342 defsubr (&Sget_largest_window
);
3343 defsubr (&Sget_buffer_window
);
3344 defsubr (&Sdelete_other_windows
);
3345 defsubr (&Sdelete_windows_on
);
3346 defsubr (&Sreplace_buffer_in_windows
);
3347 defsubr (&Sdelete_window
);
3348 defsubr (&Sset_window_buffer
);
3349 defsubr (&Sselect_window
);
3350 defsubr (&Sdisplay_buffer
);
3351 defsubr (&Ssplit_window
);
3352 defsubr (&Senlarge_window
);
3353 defsubr (&Sshrink_window
);
3354 defsubr (&Sscroll_up
);
3355 defsubr (&Sscroll_down
);
3356 defsubr (&Sscroll_left
);
3357 defsubr (&Sscroll_right
);
3358 defsubr (&Sother_window_for_scrolling
);
3359 defsubr (&Sscroll_other_window
);
3360 defsubr (&Srecenter
);
3361 defsubr (&Smove_to_window_line
);
3362 defsubr (&Swindow_configuration_p
);
3363 defsubr (&Sset_window_configuration
);
3364 defsubr (&Scurrent_window_configuration
);
3365 defsubr (&Ssave_window_excursion
);
3370 initial_define_key (control_x_map
, '1', "delete-other-windows");
3371 initial_define_key (control_x_map
, '2', "split-window");
3372 initial_define_key (control_x_map
, '0', "delete-window");
3373 initial_define_key (control_x_map
, 'o', "other-window");
3374 initial_define_key (control_x_map
, '^', "enlarge-window");
3375 initial_define_key (control_x_map
, '<', "scroll-left");
3376 initial_define_key (control_x_map
, '>', "scroll-right");
3378 initial_define_key (global_map
, Ctl ('V'), "scroll-up");
3379 initial_define_key (meta_map
, Ctl ('V'), "scroll-other-window");
3380 initial_define_key (meta_map
, 'v', "scroll-down");
3382 initial_define_key (global_map
, Ctl('L'), "recenter");
3383 initial_define_key (meta_map
, 'r', "move-to-window-line");